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(Table
*pTab
, int iCol
){
25 assert( iCol
<pTab
->nCol
);
26 return iCol
>=0 ? pTab
->aCol
[iCol
].affinity
: SQLITE_AFF_INTEGER
;
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(Expr
*pExpr
){
47 pExpr
= sqlite3ExprSkipCollate(pExpr
);
48 if( pExpr
->flags
& EP_Generic
) return 0;
51 assert( pExpr
->flags
&EP_xIsSelect
);
52 return sqlite3ExprAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
);
54 if( op
==TK_REGISTER
) op
= pExpr
->op2
;
55 #ifndef SQLITE_OMIT_CAST
57 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
58 return sqlite3AffinityType(pExpr
->u
.zToken
, 0);
61 if( (op
==TK_AGG_COLUMN
|| op
==TK_COLUMN
) && pExpr
->pTab
){
62 return sqlite3TableColumnAffinity(pExpr
->pTab
, pExpr
->iColumn
);
64 if( op
==TK_SELECT_COLUMN
){
65 assert( pExpr
->pLeft
->flags
&EP_xIsSelect
);
66 return sqlite3ExprAffinity(
67 pExpr
->pLeft
->x
.pSelect
->pEList
->a
[pExpr
->iColumn
].pExpr
70 return pExpr
->affinity
;
74 ** Set the collating sequence for expression pExpr to be the collating
75 ** sequence named by pToken. Return a pointer to a new Expr node that
76 ** implements the COLLATE operator.
78 ** If a memory allocation error occurs, that fact is recorded in pParse->db
79 ** and the pExpr parameter is returned unchanged.
81 Expr
*sqlite3ExprAddCollateToken(
82 Parse
*pParse
, /* Parsing context */
83 Expr
*pExpr
, /* Add the "COLLATE" clause to this expression */
84 const Token
*pCollName
, /* Name of collating sequence */
85 int dequote
/* True to dequote pCollName */
88 Expr
*pNew
= sqlite3ExprAlloc(pParse
->db
, TK_COLLATE
, pCollName
, dequote
);
91 pNew
->flags
|= EP_Collate
|EP_Skip
;
97 Expr
*sqlite3ExprAddCollateString(Parse
*pParse
, Expr
*pExpr
, const char *zC
){
100 sqlite3TokenInit(&s
, (char*)zC
);
101 return sqlite3ExprAddCollateToken(pParse
, pExpr
, &s
, 0);
105 ** Skip over any TK_COLLATE operators and any unlikely()
106 ** or likelihood() function at the root of an expression.
108 Expr
*sqlite3ExprSkipCollate(Expr
*pExpr
){
109 while( pExpr
&& ExprHasProperty(pExpr
, EP_Skip
) ){
110 if( ExprHasProperty(pExpr
, EP_Unlikely
) ){
111 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
112 assert( pExpr
->x
.pList
->nExpr
>0 );
113 assert( pExpr
->op
==TK_FUNCTION
);
114 pExpr
= pExpr
->x
.pList
->a
[0].pExpr
;
116 assert( pExpr
->op
==TK_COLLATE
);
117 pExpr
= pExpr
->pLeft
;
124 ** Return the collation sequence for the expression pExpr. If
125 ** there is no defined collating sequence, return NULL.
127 ** See also: sqlite3ExprNNCollSeq()
129 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
130 ** default collation if pExpr has no defined collation.
132 ** The collating sequence might be determined by a COLLATE operator
133 ** or by the presence of a column with a defined collating sequence.
134 ** COLLATE operators take first precedence. Left operands take
135 ** precedence over right operands.
137 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, Expr
*pExpr
){
138 sqlite3
*db
= pParse
->db
;
143 if( p
->flags
& EP_Generic
) break;
144 if( op
==TK_CAST
|| op
==TK_UPLUS
){
148 if( op
==TK_COLLATE
|| (op
==TK_REGISTER
&& p
->op2
==TK_COLLATE
) ){
149 pColl
= sqlite3GetCollSeq(pParse
, ENC(db
), 0, p
->u
.zToken
);
152 if( (op
==TK_AGG_COLUMN
|| op
==TK_COLUMN
153 || op
==TK_REGISTER
|| op
==TK_TRIGGER
)
156 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
157 ** a TK_COLUMN but was previously evaluated and cached in a register */
160 const char *zColl
= p
->pTab
->aCol
[j
].zColl
;
161 pColl
= sqlite3FindCollSeq(db
, ENC(db
), zColl
, 0);
165 if( p
->flags
& EP_Collate
){
166 if( p
->pLeft
&& (p
->pLeft
->flags
& EP_Collate
)!=0 ){
169 Expr
*pNext
= p
->pRight
;
170 /* The Expr.x union is never used at the same time as Expr.pRight */
171 assert( p
->x
.pList
==0 || p
->pRight
==0 );
172 /* p->flags holds EP_Collate and p->pLeft->flags does not. And
173 ** p->x.pSelect cannot. So if p->x.pLeft exists, it must hold at
174 ** least one EP_Collate. Thus the following two ALWAYS. */
175 if( p
->x
.pList
!=0 && ALWAYS(!ExprHasProperty(p
, EP_xIsSelect
)) ){
177 for(i
=0; ALWAYS(i
<p
->x
.pList
->nExpr
); i
++){
178 if( ExprHasProperty(p
->x
.pList
->a
[i
].pExpr
, EP_Collate
) ){
179 pNext
= p
->x
.pList
->a
[i
].pExpr
;
190 if( sqlite3CheckCollSeq(pParse
, pColl
) ){
197 ** Return the collation sequence for the expression pExpr. If
198 ** there is no defined collating sequence, return a pointer to the
199 ** defautl collation sequence.
201 ** See also: sqlite3ExprCollSeq()
203 ** The sqlite3ExprCollSeq() routine works the same except that it
204 ** returns NULL if there is no defined collation.
206 CollSeq
*sqlite3ExprNNCollSeq(Parse
*pParse
, Expr
*pExpr
){
207 CollSeq
*p
= sqlite3ExprCollSeq(pParse
, pExpr
);
208 if( p
==0 ) p
= pParse
->db
->pDfltColl
;
214 ** Return TRUE if the two expressions have equivalent collating sequences.
216 int sqlite3ExprCollSeqMatch(Parse
*pParse
, Expr
*pE1
, Expr
*pE2
){
217 CollSeq
*pColl1
= sqlite3ExprNNCollSeq(pParse
, pE1
);
218 CollSeq
*pColl2
= sqlite3ExprNNCollSeq(pParse
, pE2
);
219 return sqlite3StrICmp(pColl1
->zName
, pColl2
->zName
)==0;
223 ** pExpr is an operand of a comparison operator. aff2 is the
224 ** type affinity of the other operand. This routine returns the
225 ** type affinity that should be used for the comparison operator.
227 char sqlite3CompareAffinity(Expr
*pExpr
, char aff2
){
228 char aff1
= sqlite3ExprAffinity(pExpr
);
230 /* Both sides of the comparison are columns. If one has numeric
231 ** affinity, use that. Otherwise use no affinity.
233 if( sqlite3IsNumericAffinity(aff1
) || sqlite3IsNumericAffinity(aff2
) ){
234 return SQLITE_AFF_NUMERIC
;
236 return SQLITE_AFF_BLOB
;
238 }else if( !aff1
&& !aff2
){
239 /* Neither side of the comparison is a column. Compare the
242 return SQLITE_AFF_BLOB
;
244 /* One side is a column, the other is not. Use the columns affinity. */
245 assert( aff1
==0 || aff2
==0 );
246 return (aff1
+ aff2
);
251 ** pExpr is a comparison operator. Return the type affinity that should
252 ** be applied to both operands prior to doing the comparison.
254 static char comparisonAffinity(Expr
*pExpr
){
256 assert( pExpr
->op
==TK_EQ
|| pExpr
->op
==TK_IN
|| pExpr
->op
==TK_LT
||
257 pExpr
->op
==TK_GT
|| pExpr
->op
==TK_GE
|| pExpr
->op
==TK_LE
||
258 pExpr
->op
==TK_NE
|| pExpr
->op
==TK_IS
|| pExpr
->op
==TK_ISNOT
);
259 assert( pExpr
->pLeft
);
260 aff
= sqlite3ExprAffinity(pExpr
->pLeft
);
262 aff
= sqlite3CompareAffinity(pExpr
->pRight
, aff
);
263 }else if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
264 aff
= sqlite3CompareAffinity(pExpr
->x
.pSelect
->pEList
->a
[0].pExpr
, aff
);
266 aff
= SQLITE_AFF_BLOB
;
272 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
273 ** idx_affinity is the affinity of an indexed column. Return true
274 ** if the index with affinity idx_affinity may be used to implement
275 ** the comparison in pExpr.
277 int sqlite3IndexAffinityOk(Expr
*pExpr
, char idx_affinity
){
278 char aff
= comparisonAffinity(pExpr
);
280 case SQLITE_AFF_BLOB
:
282 case SQLITE_AFF_TEXT
:
283 return idx_affinity
==SQLITE_AFF_TEXT
;
285 return sqlite3IsNumericAffinity(idx_affinity
);
290 ** Return the P5 value that should be used for a binary comparison
291 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
293 static u8
binaryCompareP5(Expr
*pExpr1
, Expr
*pExpr2
, int jumpIfNull
){
294 u8 aff
= (char)sqlite3ExprAffinity(pExpr2
);
295 aff
= (u8
)sqlite3CompareAffinity(pExpr1
, aff
) | (u8
)jumpIfNull
;
300 ** Return a pointer to the collation sequence that should be used by
301 ** a binary comparison operator comparing pLeft and pRight.
303 ** If the left hand expression has a collating sequence type, then it is
304 ** used. Otherwise the collation sequence for the right hand expression
305 ** is used, or the default (BINARY) if neither expression has a collating
308 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
309 ** it is not considered.
311 CollSeq
*sqlite3BinaryCompareCollSeq(
318 if( pLeft
->flags
& EP_Collate
){
319 pColl
= sqlite3ExprCollSeq(pParse
, pLeft
);
320 }else if( pRight
&& (pRight
->flags
& EP_Collate
)!=0 ){
321 pColl
= sqlite3ExprCollSeq(pParse
, pRight
);
323 pColl
= sqlite3ExprCollSeq(pParse
, pLeft
);
325 pColl
= sqlite3ExprCollSeq(pParse
, pRight
);
332 ** Generate code for a comparison operator.
334 static int codeCompare(
335 Parse
*pParse
, /* The parsing (and code generating) context */
336 Expr
*pLeft
, /* The left operand */
337 Expr
*pRight
, /* The right operand */
338 int opcode
, /* The comparison opcode */
339 int in1
, int in2
, /* Register holding operands */
340 int dest
, /* Jump here if true. */
341 int jumpIfNull
/* If true, jump if either operand is NULL */
347 p4
= sqlite3BinaryCompareCollSeq(pParse
, pLeft
, pRight
);
348 p5
= binaryCompareP5(pLeft
, pRight
, jumpIfNull
);
349 addr
= sqlite3VdbeAddOp4(pParse
->pVdbe
, opcode
, in2
, dest
, in1
,
350 (void*)p4
, P4_COLLSEQ
);
351 sqlite3VdbeChangeP5(pParse
->pVdbe
, (u8
)p5
);
356 ** Return true if expression pExpr is a vector, or false otherwise.
358 ** A vector is defined as any expression that results in two or more
359 ** columns of result. Every TK_VECTOR node is an vector because the
360 ** parser will not generate a TK_VECTOR with fewer than two entries.
361 ** But a TK_SELECT might be either a vector or a scalar. It is only
362 ** considered a vector if it has two or more result columns.
364 int sqlite3ExprIsVector(Expr
*pExpr
){
365 return sqlite3ExprVectorSize(pExpr
)>1;
369 ** If the expression passed as the only argument is of type TK_VECTOR
370 ** return the number of expressions in the vector. Or, if the expression
371 ** is a sub-select, return the number of columns in the sub-select. For
372 ** any other type of expression, return 1.
374 int sqlite3ExprVectorSize(Expr
*pExpr
){
376 if( op
==TK_REGISTER
) op
= pExpr
->op2
;
378 return pExpr
->x
.pList
->nExpr
;
379 }else if( op
==TK_SELECT
){
380 return pExpr
->x
.pSelect
->pEList
->nExpr
;
387 ** Return a pointer to a subexpression of pVector that is the i-th
388 ** column of the vector (numbered starting with 0). The caller must
389 ** ensure that i is within range.
391 ** If pVector is really a scalar (and "scalar" here includes subqueries
392 ** that return a single column!) then return pVector unmodified.
394 ** pVector retains ownership of the returned subexpression.
396 ** If the vector is a (SELECT ...) then the expression returned is
397 ** just the expression for the i-th term of the result set, and may
398 ** not be ready for evaluation because the table cursor has not yet
401 Expr
*sqlite3VectorFieldSubexpr(Expr
*pVector
, int i
){
402 assert( i
<sqlite3ExprVectorSize(pVector
) );
403 if( sqlite3ExprIsVector(pVector
) ){
404 assert( pVector
->op2
==0 || pVector
->op
==TK_REGISTER
);
405 if( pVector
->op
==TK_SELECT
|| pVector
->op2
==TK_SELECT
){
406 return pVector
->x
.pSelect
->pEList
->a
[i
].pExpr
;
408 return pVector
->x
.pList
->a
[i
].pExpr
;
415 ** Compute and return a new Expr object which when passed to
416 ** sqlite3ExprCode() will generate all necessary code to compute
417 ** the iField-th column of the vector expression pVector.
419 ** It is ok for pVector to be a scalar (as long as iField==0).
420 ** In that case, this routine works like sqlite3ExprDup().
422 ** The caller owns the returned Expr object and is responsible for
423 ** ensuring that the returned value eventually gets freed.
425 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
426 ** then the returned object will reference pVector and so pVector must remain
427 ** valid for the life of the returned object. If pVector is a TK_VECTOR
428 ** or a scalar expression, then it can be deleted as soon as this routine
431 ** A trick to cause a TK_SELECT pVector to be deleted together with
432 ** the returned Expr object is to attach the pVector to the pRight field
433 ** of the returned TK_SELECT_COLUMN Expr object.
435 Expr
*sqlite3ExprForVectorField(
436 Parse
*pParse
, /* Parsing context */
437 Expr
*pVector
, /* The vector. List of expressions or a sub-SELECT */
438 int iField
/* Which column of the vector to return */
441 if( pVector
->op
==TK_SELECT
){
442 assert( pVector
->flags
& EP_xIsSelect
);
443 /* The TK_SELECT_COLUMN Expr node:
445 ** pLeft: pVector containing TK_SELECT. Not deleted.
446 ** pRight: not used. But recursively deleted.
447 ** iColumn: Index of a column in pVector
448 ** iTable: 0 or the number of columns on the LHS of an assignment
449 ** pLeft->iTable: First in an array of register holding result, or 0
450 ** if the result is not yet computed.
452 ** sqlite3ExprDelete() specifically skips the recursive delete of
453 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
454 ** can be attached to pRight to cause this node to take ownership of
455 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
456 ** with the same pLeft pointer to the pVector, but only one of them
457 ** will own the pVector.
459 pRet
= sqlite3PExpr(pParse
, TK_SELECT_COLUMN
, 0, 0);
461 pRet
->iColumn
= iField
;
462 pRet
->pLeft
= pVector
;
464 assert( pRet
==0 || pRet
->iTable
==0 );
466 if( pVector
->op
==TK_VECTOR
) pVector
= pVector
->x
.pList
->a
[iField
].pExpr
;
467 pRet
= sqlite3ExprDup(pParse
->db
, pVector
, 0);
473 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
474 ** it. Return the register in which the result is stored (or, if the
475 ** sub-select returns more than one column, the first in an array
476 ** of registers in which the result is stored).
478 ** If pExpr is not a TK_SELECT expression, return 0.
480 static int exprCodeSubselect(Parse
*pParse
, Expr
*pExpr
){
482 #ifndef SQLITE_OMIT_SUBQUERY
483 if( pExpr
->op
==TK_SELECT
){
484 reg
= sqlite3CodeSubselect(pParse
, pExpr
, 0, 0);
491 ** Argument pVector points to a vector expression - either a TK_VECTOR
492 ** or TK_SELECT that returns more than one column. This function returns
493 ** the register number of a register that contains the value of
494 ** element iField of the vector.
496 ** If pVector is a TK_SELECT expression, then code for it must have
497 ** already been generated using the exprCodeSubselect() routine. In this
498 ** case parameter regSelect should be the first in an array of registers
499 ** containing the results of the sub-select.
501 ** If pVector is of type TK_VECTOR, then code for the requested field
502 ** is generated. In this case (*pRegFree) may be set to the number of
503 ** a temporary register to be freed by the caller before returning.
505 ** Before returning, output parameter (*ppExpr) is set to point to the
506 ** Expr object corresponding to element iElem of the vector.
508 static int exprVectorRegister(
509 Parse
*pParse
, /* Parse context */
510 Expr
*pVector
, /* Vector to extract element from */
511 int iField
, /* Field to extract from pVector */
512 int regSelect
, /* First in array of registers */
513 Expr
**ppExpr
, /* OUT: Expression element */
514 int *pRegFree
/* OUT: Temp register to free */
517 assert( op
==TK_VECTOR
|| op
==TK_REGISTER
|| op
==TK_SELECT
);
518 if( op
==TK_REGISTER
){
519 *ppExpr
= sqlite3VectorFieldSubexpr(pVector
, iField
);
520 return pVector
->iTable
+iField
;
523 *ppExpr
= pVector
->x
.pSelect
->pEList
->a
[iField
].pExpr
;
524 return regSelect
+iField
;
526 *ppExpr
= pVector
->x
.pList
->a
[iField
].pExpr
;
527 return sqlite3ExprCodeTemp(pParse
, *ppExpr
, pRegFree
);
531 ** Expression pExpr is a comparison between two vector values. Compute
532 ** the result of the comparison (1, 0, or NULL) and write that
533 ** result into register dest.
535 ** The caller must satisfy the following preconditions:
537 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
538 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
539 ** otherwise: op==pExpr->op and p5==0
541 static void codeVectorCompare(
542 Parse
*pParse
, /* Code generator context */
543 Expr
*pExpr
, /* The comparison operation */
544 int dest
, /* Write results into this register */
545 u8 op
, /* Comparison operator */
546 u8 p5
/* SQLITE_NULLEQ or zero */
548 Vdbe
*v
= pParse
->pVdbe
;
549 Expr
*pLeft
= pExpr
->pLeft
;
550 Expr
*pRight
= pExpr
->pRight
;
551 int nLeft
= sqlite3ExprVectorSize(pLeft
);
556 int addrDone
= sqlite3VdbeMakeLabel(v
);
558 if( nLeft
!=sqlite3ExprVectorSize(pRight
) ){
559 sqlite3ErrorMsg(pParse
, "row value misused");
562 assert( pExpr
->op
==TK_EQ
|| pExpr
->op
==TK_NE
563 || pExpr
->op
==TK_IS
|| pExpr
->op
==TK_ISNOT
564 || pExpr
->op
==TK_LT
|| pExpr
->op
==TK_GT
565 || pExpr
->op
==TK_LE
|| pExpr
->op
==TK_GE
567 assert( pExpr
->op
==op
|| (pExpr
->op
==TK_IS
&& op
==TK_EQ
)
568 || (pExpr
->op
==TK_ISNOT
&& op
==TK_NE
) );
569 assert( p5
==0 || pExpr
->op
!=op
);
570 assert( p5
==SQLITE_NULLEQ
|| pExpr
->op
==op
);
572 p5
|= SQLITE_STOREP2
;
573 if( opx
==TK_LE
) opx
= TK_LT
;
574 if( opx
==TK_GE
) opx
= TK_GT
;
576 regLeft
= exprCodeSubselect(pParse
, pLeft
);
577 regRight
= exprCodeSubselect(pParse
, pRight
);
579 for(i
=0; 1 /*Loop exits by "break"*/; i
++){
580 int regFree1
= 0, regFree2
= 0;
583 assert( i
>=0 && i
<nLeft
);
584 if( i
>0 ) sqlite3ExprCachePush(pParse
);
585 r1
= exprVectorRegister(pParse
, pLeft
, i
, regLeft
, &pL
, ®Free1
);
586 r2
= exprVectorRegister(pParse
, pRight
, i
, regRight
, &pR
, ®Free2
);
587 codeCompare(pParse
, pL
, pR
, opx
, r1
, r2
, dest
, p5
);
588 testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
589 testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
590 testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
591 testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
592 testcase(op
==OP_Eq
); VdbeCoverageIf(v
,op
==OP_Eq
);
593 testcase(op
==OP_Ne
); VdbeCoverageIf(v
,op
==OP_Ne
);
594 sqlite3ReleaseTempReg(pParse
, regFree1
);
595 sqlite3ReleaseTempReg(pParse
, regFree2
);
596 if( i
>0 ) sqlite3ExprCachePop(pParse
);
601 sqlite3VdbeAddOp2(v
, OP_IfNot
, dest
, addrDone
); VdbeCoverage(v
);
602 p5
|= SQLITE_KEEPNULL
;
603 }else if( opx
==TK_NE
){
604 sqlite3VdbeAddOp2(v
, OP_If
, dest
, addrDone
); VdbeCoverage(v
);
605 p5
|= SQLITE_KEEPNULL
;
607 assert( op
==TK_LT
|| op
==TK_GT
|| op
==TK_LE
|| op
==TK_GE
);
608 sqlite3VdbeAddOp2(v
, OP_ElseNotEq
, 0, addrDone
);
609 VdbeCoverageIf(v
, op
==TK_LT
);
610 VdbeCoverageIf(v
, op
==TK_GT
);
611 VdbeCoverageIf(v
, op
==TK_LE
);
612 VdbeCoverageIf(v
, op
==TK_GE
);
613 if( i
==nLeft
-2 ) opx
= op
;
616 sqlite3VdbeResolveLabel(v
, addrDone
);
619 #if SQLITE_MAX_EXPR_DEPTH>0
621 ** Check that argument nHeight is less than or equal to the maximum
622 ** expression depth allowed. If it is not, leave an error message in
625 int sqlite3ExprCheckHeight(Parse
*pParse
, int nHeight
){
627 int mxHeight
= pParse
->db
->aLimit
[SQLITE_LIMIT_EXPR_DEPTH
];
628 if( nHeight
>mxHeight
){
629 sqlite3ErrorMsg(pParse
,
630 "Expression tree is too large (maximum depth %d)", mxHeight
637 /* The following three functions, heightOfExpr(), heightOfExprList()
638 ** and heightOfSelect(), are used to determine the maximum height
639 ** of any expression tree referenced by the structure passed as the
642 ** If this maximum height is greater than the current value pointed
643 ** to by pnHeight, the second parameter, then set *pnHeight to that
646 static void heightOfExpr(Expr
*p
, int *pnHeight
){
648 if( p
->nHeight
>*pnHeight
){
649 *pnHeight
= p
->nHeight
;
653 static void heightOfExprList(ExprList
*p
, int *pnHeight
){
656 for(i
=0; i
<p
->nExpr
; i
++){
657 heightOfExpr(p
->a
[i
].pExpr
, pnHeight
);
661 static void heightOfSelect(Select
*pSelect
, int *pnHeight
){
663 for(p
=pSelect
; p
; p
=p
->pPrior
){
664 heightOfExpr(p
->pWhere
, pnHeight
);
665 heightOfExpr(p
->pHaving
, pnHeight
);
666 heightOfExpr(p
->pLimit
, pnHeight
);
667 heightOfExprList(p
->pEList
, pnHeight
);
668 heightOfExprList(p
->pGroupBy
, pnHeight
);
669 heightOfExprList(p
->pOrderBy
, pnHeight
);
674 ** Set the Expr.nHeight variable in the structure passed as an
675 ** argument. An expression with no children, Expr.pList or
676 ** Expr.pSelect member has a height of 1. Any other expression
677 ** has a height equal to the maximum height of any other
678 ** referenced Expr plus one.
680 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
683 static void exprSetHeight(Expr
*p
){
685 heightOfExpr(p
->pLeft
, &nHeight
);
686 heightOfExpr(p
->pRight
, &nHeight
);
687 if( ExprHasProperty(p
, EP_xIsSelect
) ){
688 heightOfSelect(p
->x
.pSelect
, &nHeight
);
689 }else if( p
->x
.pList
){
690 heightOfExprList(p
->x
.pList
, &nHeight
);
691 p
->flags
|= EP_Propagate
& sqlite3ExprListFlags(p
->x
.pList
);
693 p
->nHeight
= nHeight
+ 1;
697 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
698 ** the height is greater than the maximum allowed expression depth,
699 ** leave an error in pParse.
701 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
704 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
){
705 if( pParse
->nErr
) return;
707 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
711 ** Return the maximum height of any expression tree referenced
712 ** by the select statement passed as an argument.
714 int sqlite3SelectExprHeight(Select
*p
){
716 heightOfSelect(p
, &nHeight
);
719 #else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */
721 ** Propagate all EP_Propagate flags from the Expr.x.pList into
724 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
){
725 if( p
&& p
->x
.pList
&& !ExprHasProperty(p
, EP_xIsSelect
) ){
726 p
->flags
|= EP_Propagate
& sqlite3ExprListFlags(p
->x
.pList
);
729 #define exprSetHeight(y)
730 #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
733 ** This routine is the core allocator for Expr nodes.
735 ** Construct a new expression node and return a pointer to it. Memory
736 ** for this node and for the pToken argument is a single allocation
737 ** obtained from sqlite3DbMalloc(). The calling function
738 ** is responsible for making sure the node eventually gets freed.
740 ** If dequote is true, then the token (if it exists) is dequoted.
741 ** If dequote is false, no dequoting is performed. The deQuote
742 ** parameter is ignored if pToken is NULL or if the token does not
743 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
744 ** then the EP_DblQuoted flag is set on the expression node.
746 ** Special case: If op==TK_INTEGER and pToken points to a string that
747 ** can be translated into a 32-bit integer, then the token is not
748 ** stored in u.zToken. Instead, the integer values is written
749 ** into u.iValue and the EP_IntValue flag is set. No extra storage
750 ** is allocated to hold the integer text and the dequote flag is ignored.
752 Expr
*sqlite3ExprAlloc(
753 sqlite3
*db
, /* Handle for sqlite3DbMallocRawNN() */
754 int op
, /* Expression opcode */
755 const Token
*pToken
, /* Token argument. Might be NULL */
756 int dequote
/* True to dequote */
764 if( op
!=TK_INTEGER
|| pToken
->z
==0
765 || sqlite3GetInt32(pToken
->z
, &iValue
)==0 ){
766 nExtra
= pToken
->n
+1;
770 pNew
= sqlite3DbMallocRawNN(db
, sizeof(Expr
)+nExtra
);
772 memset(pNew
, 0, sizeof(Expr
));
777 pNew
->flags
|= EP_IntValue
|EP_Leaf
;
778 pNew
->u
.iValue
= iValue
;
780 pNew
->u
.zToken
= (char*)&pNew
[1];
781 assert( pToken
->z
!=0 || pToken
->n
==0 );
782 if( pToken
->n
) memcpy(pNew
->u
.zToken
, pToken
->z
, pToken
->n
);
783 pNew
->u
.zToken
[pToken
->n
] = 0;
784 if( dequote
&& sqlite3Isquote(pNew
->u
.zToken
[0]) ){
785 if( pNew
->u
.zToken
[0]=='"' ) pNew
->flags
|= EP_DblQuoted
;
786 sqlite3Dequote(pNew
->u
.zToken
);
790 #if SQLITE_MAX_EXPR_DEPTH>0
798 ** Allocate a new expression node from a zero-terminated token that has
799 ** already been dequoted.
802 sqlite3
*db
, /* Handle for sqlite3DbMallocZero() (may be null) */
803 int op
, /* Expression opcode */
804 const char *zToken
/* Token argument. Might be NULL */
808 x
.n
= sqlite3Strlen30(zToken
);
809 return sqlite3ExprAlloc(db
, op
, &x
, 0);
813 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
815 ** If pRoot==NULL that means that a memory allocation error has occurred.
816 ** In that case, delete the subtrees pLeft and pRight.
818 void sqlite3ExprAttachSubtrees(
825 assert( db
->mallocFailed
);
826 sqlite3ExprDelete(db
, pLeft
);
827 sqlite3ExprDelete(db
, pRight
);
830 pRoot
->pRight
= pRight
;
831 pRoot
->flags
|= EP_Propagate
& pRight
->flags
;
834 pRoot
->pLeft
= pLeft
;
835 pRoot
->flags
|= EP_Propagate
& pLeft
->flags
;
837 exprSetHeight(pRoot
);
842 ** Allocate an Expr node which joins as many as two subtrees.
844 ** One or both of the subtrees can be NULL. Return a pointer to the new
845 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
846 ** free the subtrees and return NULL.
849 Parse
*pParse
, /* Parsing context */
850 int op
, /* Expression opcode */
851 Expr
*pLeft
, /* Left operand */
852 Expr
*pRight
/* Right operand */
855 if( op
==TK_AND
&& pParse
->nErr
==0 ){
856 /* Take advantage of short-circuit false optimization for AND */
857 p
= sqlite3ExprAnd(pParse
->db
, pLeft
, pRight
);
859 p
= sqlite3DbMallocRawNN(pParse
->db
, sizeof(Expr
));
861 memset(p
, 0, sizeof(Expr
));
862 p
->op
= op
& TKFLG_MASK
;
865 sqlite3ExprAttachSubtrees(pParse
->db
, p
, pLeft
, pRight
);
868 sqlite3ExprCheckHeight(pParse
, p
->nHeight
);
874 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
875 ** do a memory allocation failure) then delete the pSelect object.
877 void sqlite3PExprAddSelect(Parse
*pParse
, Expr
*pExpr
, Select
*pSelect
){
879 pExpr
->x
.pSelect
= pSelect
;
880 ExprSetProperty(pExpr
, EP_xIsSelect
|EP_Subquery
);
881 sqlite3ExprSetHeightAndFlags(pParse
, pExpr
);
883 assert( pParse
->db
->mallocFailed
);
884 sqlite3SelectDelete(pParse
->db
, pSelect
);
890 ** If the expression is always either TRUE or FALSE (respectively),
891 ** then return 1. If one cannot determine the truth value of the
892 ** expression at compile-time return 0.
894 ** This is an optimization. If is OK to return 0 here even if
895 ** the expression really is always false or false (a false negative).
896 ** But it is a bug to return 1 if the expression might have different
897 ** boolean values in different circumstances (a false positive.)
899 ** Note that if the expression is part of conditional for a
900 ** LEFT JOIN, then we cannot determine at compile-time whether or not
901 ** is it true or false, so always return 0.
903 static int exprAlwaysTrue(Expr
*p
){
905 if( ExprHasProperty(p
, EP_FromJoin
) ) return 0;
906 if( !sqlite3ExprIsInteger(p
, &v
) ) return 0;
909 static int exprAlwaysFalse(Expr
*p
){
911 if( ExprHasProperty(p
, EP_FromJoin
) ) return 0;
912 if( !sqlite3ExprIsInteger(p
, &v
) ) return 0;
917 ** Join two expressions using an AND operator. If either expression is
918 ** NULL, then just return the other expression.
920 ** If one side or the other of the AND is known to be false, then instead
921 ** of returning an AND expression, just return a constant expression with
924 Expr
*sqlite3ExprAnd(sqlite3
*db
, Expr
*pLeft
, Expr
*pRight
){
927 }else if( pRight
==0 ){
929 }else if( exprAlwaysFalse(pLeft
) || exprAlwaysFalse(pRight
) ){
930 sqlite3ExprDelete(db
, pLeft
);
931 sqlite3ExprDelete(db
, pRight
);
932 return sqlite3ExprAlloc(db
, TK_INTEGER
, &sqlite3IntTokens
[0], 0);
934 Expr
*pNew
= sqlite3ExprAlloc(db
, TK_AND
, 0, 0);
935 sqlite3ExprAttachSubtrees(db
, pNew
, pLeft
, pRight
);
941 ** Construct a new expression node for a function with multiple
944 Expr
*sqlite3ExprFunction(Parse
*pParse
, ExprList
*pList
, Token
*pToken
){
946 sqlite3
*db
= pParse
->db
;
948 pNew
= sqlite3ExprAlloc(db
, TK_FUNCTION
, pToken
, 1);
950 sqlite3ExprListDelete(db
, pList
); /* Avoid memory leak when malloc fails */
953 pNew
->x
.pList
= pList
;
954 ExprSetProperty(pNew
, EP_HasFunc
);
955 assert( !ExprHasProperty(pNew
, EP_xIsSelect
) );
956 sqlite3ExprSetHeightAndFlags(pParse
, pNew
);
961 ** Assign a variable number to an expression that encodes a wildcard
962 ** in the original SQL statement.
964 ** Wildcards consisting of a single "?" are assigned the next sequential
967 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
968 ** sure "nnn" is not too big to avoid a denial of service attack when
969 ** the SQL statement comes from an external source.
971 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
972 ** as the previous instance of the same wildcard. Or if this is the first
973 ** instance of the wildcard, the next sequential variable number is
976 void sqlite3ExprAssignVarNumber(Parse
*pParse
, Expr
*pExpr
, u32 n
){
977 sqlite3
*db
= pParse
->db
;
981 if( pExpr
==0 ) return;
982 assert( !ExprHasProperty(pExpr
, EP_IntValue
|EP_Reduced
|EP_TokenOnly
) );
986 assert( n
==(u32
)sqlite3Strlen30(z
) );
988 /* Wildcard of the form "?". Assign the next variable number */
990 x
= (ynVar
)(++pParse
->nVar
);
994 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
995 ** use it as the variable number */
998 if( n
==2 ){ /*OPTIMIZATION-IF-TRUE*/
999 i
= z
[1]-'0'; /* The common case of ?N for a single digit N */
1002 bOk
= 0==sqlite3Atoi64(&z
[1], &i
, n
-1, SQLITE_UTF8
);
1006 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]-1 );
1007 testcase( i
==db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] );
1008 if( bOk
==0 || i
<1 || i
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
1009 sqlite3ErrorMsg(pParse
, "variable number must be between ?1 and ?%d",
1010 db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]);
1014 if( x
>pParse
->nVar
){
1015 pParse
->nVar
= (int)x
;
1017 }else if( sqlite3VListNumToName(pParse
->pVList
, x
)==0 ){
1021 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1022 ** number as the prior appearance of the same name, or if the name
1023 ** has never appeared before, reuse the same variable number
1025 x
= (ynVar
)sqlite3VListNameToNum(pParse
->pVList
, z
, n
);
1027 x
= (ynVar
)(++pParse
->nVar
);
1032 pParse
->pVList
= sqlite3VListAdd(db
, pParse
->pVList
, z
, n
, x
);
1036 if( x
>db
->aLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
] ){
1037 sqlite3ErrorMsg(pParse
, "too many SQL variables");
1042 ** Recursively delete an expression tree.
1044 static SQLITE_NOINLINE
void sqlite3ExprDeleteNN(sqlite3
*db
, Expr
*p
){
1046 /* Sanity check: Assert that the IntValue is non-negative if it exists */
1047 assert( !ExprHasProperty(p
, EP_IntValue
) || p
->u
.iValue
>=0 );
1049 if( ExprHasProperty(p
, EP_Leaf
) && !ExprHasProperty(p
, EP_TokenOnly
) ){
1050 assert( p
->pLeft
==0 );
1051 assert( p
->pRight
==0 );
1052 assert( p
->x
.pSelect
==0 );
1055 if( !ExprHasProperty(p
, (EP_TokenOnly
|EP_Leaf
)) ){
1056 /* The Expr.x union is never used at the same time as Expr.pRight */
1057 assert( p
->x
.pList
==0 || p
->pRight
==0 );
1058 if( p
->pLeft
&& p
->op
!=TK_SELECT_COLUMN
) sqlite3ExprDeleteNN(db
, p
->pLeft
);
1060 sqlite3ExprDeleteNN(db
, p
->pRight
);
1061 }else if( ExprHasProperty(p
, EP_xIsSelect
) ){
1062 sqlite3SelectDelete(db
, p
->x
.pSelect
);
1064 sqlite3ExprListDelete(db
, p
->x
.pList
);
1067 if( ExprHasProperty(p
, EP_MemToken
) ) sqlite3DbFree(db
, p
->u
.zToken
);
1068 if( !ExprHasProperty(p
, EP_Static
) ){
1069 sqlite3DbFreeNN(db
, p
);
1072 void sqlite3ExprDelete(sqlite3
*db
, Expr
*p
){
1073 if( p
) sqlite3ExprDeleteNN(db
, p
);
1077 ** Return the number of bytes allocated for the expression structure
1078 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1079 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1081 static int exprStructSize(Expr
*p
){
1082 if( ExprHasProperty(p
, EP_TokenOnly
) ) return EXPR_TOKENONLYSIZE
;
1083 if( ExprHasProperty(p
, EP_Reduced
) ) return EXPR_REDUCEDSIZE
;
1084 return EXPR_FULLSIZE
;
1088 ** The dupedExpr*Size() routines each return the number of bytes required
1089 ** to store a copy of an expression or expression tree. They differ in
1090 ** how much of the tree is measured.
1092 ** dupedExprStructSize() Size of only the Expr structure
1093 ** dupedExprNodeSize() Size of Expr + space for token
1094 ** dupedExprSize() Expr + token + subtree components
1096 ***************************************************************************
1098 ** The dupedExprStructSize() function returns two values OR-ed together:
1099 ** (1) the space required for a copy of the Expr structure only and
1100 ** (2) the EP_xxx flags that indicate what the structure size should be.
1101 ** The return values is always one of:
1104 ** EXPR_REDUCEDSIZE | EP_Reduced
1105 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1107 ** The size of the structure can be found by masking the return value
1108 ** of this routine with 0xfff. The flags can be found by masking the
1109 ** return value with EP_Reduced|EP_TokenOnly.
1111 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1112 ** (unreduced) Expr objects as they or originally constructed by the parser.
1113 ** During expression analysis, extra information is computed and moved into
1114 ** later parts of teh Expr object and that extra information might get chopped
1115 ** off if the expression is reduced. Note also that it does not work to
1116 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1117 ** to reduce a pristine expression tree from the parser. The implementation
1118 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1119 ** to enforce this constraint.
1121 static int dupedExprStructSize(Expr
*p
, int flags
){
1123 assert( flags
==EXPRDUP_REDUCE
|| flags
==0 ); /* Only one flag value allowed */
1124 assert( EXPR_FULLSIZE
<=0xfff );
1125 assert( (0xfff & (EP_Reduced
|EP_TokenOnly
))==0 );
1126 if( 0==flags
|| p
->op
==TK_SELECT_COLUMN
){
1127 nSize
= EXPR_FULLSIZE
;
1129 assert( !ExprHasProperty(p
, EP_TokenOnly
|EP_Reduced
) );
1130 assert( !ExprHasProperty(p
, EP_FromJoin
) );
1131 assert( !ExprHasProperty(p
, EP_MemToken
) );
1132 assert( !ExprHasProperty(p
, EP_NoReduce
) );
1133 if( p
->pLeft
|| p
->x
.pList
){
1134 nSize
= EXPR_REDUCEDSIZE
| EP_Reduced
;
1136 assert( p
->pRight
==0 );
1137 nSize
= EXPR_TOKENONLYSIZE
| EP_TokenOnly
;
1144 ** This function returns the space in bytes required to store the copy
1145 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1146 ** string is defined.)
1148 static int dupedExprNodeSize(Expr
*p
, int flags
){
1149 int nByte
= dupedExprStructSize(p
, flags
) & 0xfff;
1150 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
1151 nByte
+= sqlite3Strlen30(p
->u
.zToken
)+1;
1153 return ROUND8(nByte
);
1157 ** Return the number of bytes required to create a duplicate of the
1158 ** expression passed as the first argument. The second argument is a
1159 ** mask containing EXPRDUP_XXX flags.
1161 ** The value returned includes space to create a copy of the Expr struct
1162 ** itself and the buffer referred to by Expr.u.zToken, if any.
1164 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1165 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1166 ** and Expr.pRight variables (but not for any structures pointed to or
1167 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1169 static int dupedExprSize(Expr
*p
, int flags
){
1172 nByte
= dupedExprNodeSize(p
, flags
);
1173 if( flags
&EXPRDUP_REDUCE
){
1174 nByte
+= dupedExprSize(p
->pLeft
, flags
) + dupedExprSize(p
->pRight
, flags
);
1181 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1182 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1183 ** to store the copy of expression p, the copies of p->u.zToken
1184 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1185 ** if any. Before returning, *pzBuffer is set to the first byte past the
1186 ** portion of the buffer copied into by this function.
1188 static Expr
*exprDup(sqlite3
*db
, Expr
*p
, int dupFlags
, u8
**pzBuffer
){
1189 Expr
*pNew
; /* Value to return */
1190 u8
*zAlloc
; /* Memory space from which to build Expr object */
1191 u32 staticFlag
; /* EP_Static if space not obtained from malloc */
1195 assert( dupFlags
==0 || dupFlags
==EXPRDUP_REDUCE
);
1196 assert( pzBuffer
==0 || dupFlags
==EXPRDUP_REDUCE
);
1198 /* Figure out where to write the new Expr structure. */
1201 staticFlag
= EP_Static
;
1203 zAlloc
= sqlite3DbMallocRawNN(db
, dupedExprSize(p
, dupFlags
));
1206 pNew
= (Expr
*)zAlloc
;
1209 /* Set nNewSize to the size allocated for the structure pointed to
1210 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1211 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1212 ** by the copy of the p->u.zToken string (if any).
1214 const unsigned nStructSize
= dupedExprStructSize(p
, dupFlags
);
1215 const int nNewSize
= nStructSize
& 0xfff;
1217 if( !ExprHasProperty(p
, EP_IntValue
) && p
->u
.zToken
){
1218 nToken
= sqlite3Strlen30(p
->u
.zToken
) + 1;
1223 assert( ExprHasProperty(p
, EP_Reduced
)==0 );
1224 memcpy(zAlloc
, p
, nNewSize
);
1226 u32 nSize
= (u32
)exprStructSize(p
);
1227 memcpy(zAlloc
, p
, nSize
);
1228 if( nSize
<EXPR_FULLSIZE
){
1229 memset(&zAlloc
[nSize
], 0, EXPR_FULLSIZE
-nSize
);
1233 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1234 pNew
->flags
&= ~(EP_Reduced
|EP_TokenOnly
|EP_Static
|EP_MemToken
);
1235 pNew
->flags
|= nStructSize
& (EP_Reduced
|EP_TokenOnly
);
1236 pNew
->flags
|= staticFlag
;
1238 /* Copy the p->u.zToken string, if any. */
1240 char *zToken
= pNew
->u
.zToken
= (char*)&zAlloc
[nNewSize
];
1241 memcpy(zToken
, p
->u
.zToken
, nToken
);
1244 if( 0==((p
->flags
|pNew
->flags
) & (EP_TokenOnly
|EP_Leaf
)) ){
1245 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1246 if( ExprHasProperty(p
, EP_xIsSelect
) ){
1247 pNew
->x
.pSelect
= sqlite3SelectDup(db
, p
->x
.pSelect
, dupFlags
);
1249 pNew
->x
.pList
= sqlite3ExprListDup(db
, p
->x
.pList
, dupFlags
);
1253 /* Fill in pNew->pLeft and pNew->pRight. */
1254 if( ExprHasProperty(pNew
, EP_Reduced
|EP_TokenOnly
) ){
1255 zAlloc
+= dupedExprNodeSize(p
, dupFlags
);
1256 if( !ExprHasProperty(pNew
, EP_TokenOnly
|EP_Leaf
) ){
1257 pNew
->pLeft
= p
->pLeft
?
1258 exprDup(db
, p
->pLeft
, EXPRDUP_REDUCE
, &zAlloc
) : 0;
1259 pNew
->pRight
= p
->pRight
?
1260 exprDup(db
, p
->pRight
, EXPRDUP_REDUCE
, &zAlloc
) : 0;
1266 if( !ExprHasProperty(p
, EP_TokenOnly
|EP_Leaf
) ){
1267 if( pNew
->op
==TK_SELECT_COLUMN
){
1268 pNew
->pLeft
= p
->pLeft
;
1269 assert( p
->iColumn
==0 || p
->pRight
==0 );
1270 assert( p
->pRight
==0 || p
->pRight
==p
->pLeft
);
1272 pNew
->pLeft
= sqlite3ExprDup(db
, p
->pLeft
, 0);
1274 pNew
->pRight
= sqlite3ExprDup(db
, p
->pRight
, 0);
1282 ** Create and return a deep copy of the object passed as the second
1283 ** argument. If an OOM condition is encountered, NULL is returned
1284 ** and the db->mallocFailed flag set.
1286 #ifndef SQLITE_OMIT_CTE
1287 static With
*withDup(sqlite3
*db
, With
*p
){
1290 int nByte
= sizeof(*p
) + sizeof(p
->a
[0]) * (p
->nCte
-1);
1291 pRet
= sqlite3DbMallocZero(db
, nByte
);
1294 pRet
->nCte
= p
->nCte
;
1295 for(i
=0; i
<p
->nCte
; i
++){
1296 pRet
->a
[i
].pSelect
= sqlite3SelectDup(db
, p
->a
[i
].pSelect
, 0);
1297 pRet
->a
[i
].pCols
= sqlite3ExprListDup(db
, p
->a
[i
].pCols
, 0);
1298 pRet
->a
[i
].zName
= sqlite3DbStrDup(db
, p
->a
[i
].zName
);
1305 # define withDup(x,y) 0
1309 ** The following group of routines make deep copies of expressions,
1310 ** expression lists, ID lists, and select statements. The copies can
1311 ** be deleted (by being passed to their respective ...Delete() routines)
1312 ** without effecting the originals.
1314 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1315 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1316 ** by subsequent calls to sqlite*ListAppend() routines.
1318 ** Any tables that the SrcList might point to are not duplicated.
1320 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1321 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1322 ** truncated version of the usual Expr structure that will be stored as
1323 ** part of the in-memory representation of the database schema.
1325 Expr
*sqlite3ExprDup(sqlite3
*db
, Expr
*p
, int flags
){
1326 assert( flags
==0 || flags
==EXPRDUP_REDUCE
);
1327 return p
? exprDup(db
, p
, flags
, 0) : 0;
1329 ExprList
*sqlite3ExprListDup(sqlite3
*db
, ExprList
*p
, int flags
){
1331 struct ExprList_item
*pItem
, *pOldItem
;
1333 Expr
*pPriorSelectCol
= 0;
1335 if( p
==0 ) return 0;
1336 pNew
= sqlite3DbMallocRawNN(db
, sqlite3DbMallocSize(db
, p
));
1337 if( pNew
==0 ) return 0;
1338 pNew
->nExpr
= p
->nExpr
;
1341 for(i
=0; i
<p
->nExpr
; i
++, pItem
++, pOldItem
++){
1342 Expr
*pOldExpr
= pOldItem
->pExpr
;
1344 pItem
->pExpr
= sqlite3ExprDup(db
, pOldExpr
, flags
);
1346 && pOldExpr
->op
==TK_SELECT_COLUMN
1347 && (pNewExpr
= pItem
->pExpr
)!=0
1349 assert( pNewExpr
->iColumn
==0 || i
>0 );
1350 if( pNewExpr
->iColumn
==0 ){
1351 assert( pOldExpr
->pLeft
==pOldExpr
->pRight
);
1352 pPriorSelectCol
= pNewExpr
->pLeft
= pNewExpr
->pRight
;
1355 assert( pItem
[-1].pExpr
!=0 );
1356 assert( pNewExpr
->iColumn
==pItem
[-1].pExpr
->iColumn
+1 );
1357 assert( pPriorSelectCol
==pItem
[-1].pExpr
->pLeft
);
1358 pNewExpr
->pLeft
= pPriorSelectCol
;
1361 pItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
1362 pItem
->zSpan
= sqlite3DbStrDup(db
, pOldItem
->zSpan
);
1363 pItem
->sortOrder
= pOldItem
->sortOrder
;
1365 pItem
->bSpanIsTab
= pOldItem
->bSpanIsTab
;
1366 pItem
->u
= pOldItem
->u
;
1372 ** If cursors, triggers, views and subqueries are all omitted from
1373 ** the build, then none of the following routines, except for
1374 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1375 ** called with a NULL argument.
1377 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1378 || !defined(SQLITE_OMIT_SUBQUERY)
1379 SrcList
*sqlite3SrcListDup(sqlite3
*db
, SrcList
*p
, int flags
){
1384 if( p
==0 ) return 0;
1385 nByte
= sizeof(*p
) + (p
->nSrc
>0 ? sizeof(p
->a
[0]) * (p
->nSrc
-1) : 0);
1386 pNew
= sqlite3DbMallocRawNN(db
, nByte
);
1387 if( pNew
==0 ) return 0;
1388 pNew
->nSrc
= pNew
->nAlloc
= p
->nSrc
;
1389 for(i
=0; i
<p
->nSrc
; i
++){
1390 struct SrcList_item
*pNewItem
= &pNew
->a
[i
];
1391 struct SrcList_item
*pOldItem
= &p
->a
[i
];
1393 pNewItem
->pSchema
= pOldItem
->pSchema
;
1394 pNewItem
->zDatabase
= sqlite3DbStrDup(db
, pOldItem
->zDatabase
);
1395 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
1396 pNewItem
->zAlias
= sqlite3DbStrDup(db
, pOldItem
->zAlias
);
1397 pNewItem
->fg
= pOldItem
->fg
;
1398 pNewItem
->iCursor
= pOldItem
->iCursor
;
1399 pNewItem
->addrFillSub
= pOldItem
->addrFillSub
;
1400 pNewItem
->regReturn
= pOldItem
->regReturn
;
1401 if( pNewItem
->fg
.isIndexedBy
){
1402 pNewItem
->u1
.zIndexedBy
= sqlite3DbStrDup(db
, pOldItem
->u1
.zIndexedBy
);
1404 pNewItem
->pIBIndex
= pOldItem
->pIBIndex
;
1405 if( pNewItem
->fg
.isTabFunc
){
1406 pNewItem
->u1
.pFuncArg
=
1407 sqlite3ExprListDup(db
, pOldItem
->u1
.pFuncArg
, flags
);
1409 pTab
= pNewItem
->pTab
= pOldItem
->pTab
;
1413 pNewItem
->pSelect
= sqlite3SelectDup(db
, pOldItem
->pSelect
, flags
);
1414 pNewItem
->pOn
= sqlite3ExprDup(db
, pOldItem
->pOn
, flags
);
1415 pNewItem
->pUsing
= sqlite3IdListDup(db
, pOldItem
->pUsing
);
1416 pNewItem
->colUsed
= pOldItem
->colUsed
;
1420 IdList
*sqlite3IdListDup(sqlite3
*db
, IdList
*p
){
1424 if( p
==0 ) return 0;
1425 pNew
= sqlite3DbMallocRawNN(db
, sizeof(*pNew
) );
1426 if( pNew
==0 ) return 0;
1428 pNew
->a
= sqlite3DbMallocRawNN(db
, p
->nId
*sizeof(p
->a
[0]) );
1430 sqlite3DbFreeNN(db
, pNew
);
1433 /* Note that because the size of the allocation for p->a[] is not
1434 ** necessarily a power of two, sqlite3IdListAppend() may not be called
1435 ** on the duplicate created by this function. */
1436 for(i
=0; i
<p
->nId
; i
++){
1437 struct IdList_item
*pNewItem
= &pNew
->a
[i
];
1438 struct IdList_item
*pOldItem
= &p
->a
[i
];
1439 pNewItem
->zName
= sqlite3DbStrDup(db
, pOldItem
->zName
);
1440 pNewItem
->idx
= pOldItem
->idx
;
1444 Select
*sqlite3SelectDup(sqlite3
*db
, Select
*pDup
, int flags
){
1447 Select
**pp
= &pRet
;
1451 for(p
=pDup
; p
; p
=p
->pPrior
){
1452 Select
*pNew
= sqlite3DbMallocRawNN(db
, sizeof(*p
) );
1453 if( pNew
==0 ) break;
1454 pNew
->pEList
= sqlite3ExprListDup(db
, p
->pEList
, flags
);
1455 pNew
->pSrc
= sqlite3SrcListDup(db
, p
->pSrc
, flags
);
1456 pNew
->pWhere
= sqlite3ExprDup(db
, p
->pWhere
, flags
);
1457 pNew
->pGroupBy
= sqlite3ExprListDup(db
, p
->pGroupBy
, flags
);
1458 pNew
->pHaving
= sqlite3ExprDup(db
, p
->pHaving
, flags
);
1459 pNew
->pOrderBy
= sqlite3ExprListDup(db
, p
->pOrderBy
, flags
);
1461 pNew
->pNext
= pNext
;
1463 pNew
->pLimit
= sqlite3ExprDup(db
, p
->pLimit
, flags
);
1466 pNew
->selFlags
= p
->selFlags
& ~SF_UsesEphemeral
;
1467 pNew
->addrOpenEphm
[0] = -1;
1468 pNew
->addrOpenEphm
[1] = -1;
1469 pNew
->nSelectRow
= p
->nSelectRow
;
1470 pNew
->pWith
= withDup(db
, p
->pWith
);
1471 sqlite3SelectSetName(pNew
, p
->zSelName
);
1480 Select
*sqlite3SelectDup(sqlite3
*db
, Select
*p
, int flags
){
1488 ** Add a new element to the end of an expression list. If pList is
1489 ** initially NULL, then create a new expression list.
1491 ** The pList argument must be either NULL or a pointer to an ExprList
1492 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1493 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1494 ** Reason: This routine assumes that the number of slots in pList->a[]
1495 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1496 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1498 ** If a memory allocation error occurs, the entire list is freed and
1499 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1500 ** that the new entry was successfully appended.
1502 ExprList
*sqlite3ExprListAppend(
1503 Parse
*pParse
, /* Parsing context */
1504 ExprList
*pList
, /* List to which to append. Might be NULL */
1505 Expr
*pExpr
/* Expression to be appended. Might be NULL */
1507 struct ExprList_item
*pItem
;
1508 sqlite3
*db
= pParse
->db
;
1511 pList
= sqlite3DbMallocRawNN(db
, sizeof(ExprList
) );
1516 }else if( (pList
->nExpr
& (pList
->nExpr
-1))==0 ){
1518 pNew
= sqlite3DbRealloc(db
, pList
,
1519 sizeof(*pList
)+(2*pList
->nExpr
- 1)*sizeof(pList
->a
[0]));
1525 pItem
= &pList
->a
[pList
->nExpr
++];
1526 assert( offsetof(struct ExprList_item
,zName
)==sizeof(pItem
->pExpr
) );
1527 assert( offsetof(struct ExprList_item
,pExpr
)==0 );
1528 memset(&pItem
->zName
,0,sizeof(*pItem
)-offsetof(struct ExprList_item
,zName
));
1529 pItem
->pExpr
= pExpr
;
1533 /* Avoid leaking memory if malloc has failed. */
1534 sqlite3ExprDelete(db
, pExpr
);
1535 sqlite3ExprListDelete(db
, pList
);
1540 ** pColumns and pExpr form a vector assignment which is part of the SET
1541 ** clause of an UPDATE statement. Like this:
1543 ** (a,b,c) = (expr1,expr2,expr3)
1544 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1546 ** For each term of the vector assignment, append new entries to the
1547 ** expression list pList. In the case of a subquery on the RHS, append
1548 ** TK_SELECT_COLUMN expressions.
1550 ExprList
*sqlite3ExprListAppendVector(
1551 Parse
*pParse
, /* Parsing context */
1552 ExprList
*pList
, /* List to which to append. Might be NULL */
1553 IdList
*pColumns
, /* List of names of LHS of the assignment */
1554 Expr
*pExpr
/* Vector expression to be appended. Might be NULL */
1556 sqlite3
*db
= pParse
->db
;
1559 int iFirst
= pList
? pList
->nExpr
: 0;
1560 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1561 ** exit prior to this routine being invoked */
1562 if( NEVER(pColumns
==0) ) goto vector_append_error
;
1563 if( pExpr
==0 ) goto vector_append_error
;
1565 /* If the RHS is a vector, then we can immediately check to see that
1566 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1567 ** wildcards ("*") in the result set of the SELECT must be expanded before
1568 ** we can do the size check, so defer the size check until code generation.
1570 if( pExpr
->op
!=TK_SELECT
&& pColumns
->nId
!=(n
=sqlite3ExprVectorSize(pExpr
)) ){
1571 sqlite3ErrorMsg(pParse
, "%d columns assigned %d values",
1573 goto vector_append_error
;
1576 for(i
=0; i
<pColumns
->nId
; i
++){
1577 Expr
*pSubExpr
= sqlite3ExprForVectorField(pParse
, pExpr
, i
);
1578 pList
= sqlite3ExprListAppend(pParse
, pList
, pSubExpr
);
1580 assert( pList
->nExpr
==iFirst
+i
+1 );
1581 pList
->a
[pList
->nExpr
-1].zName
= pColumns
->a
[i
].zName
;
1582 pColumns
->a
[i
].zName
= 0;
1586 if( !db
->mallocFailed
&& pExpr
->op
==TK_SELECT
&& ALWAYS(pList
!=0) ){
1587 Expr
*pFirst
= pList
->a
[iFirst
].pExpr
;
1588 assert( pFirst
!=0 );
1589 assert( pFirst
->op
==TK_SELECT_COLUMN
);
1591 /* Store the SELECT statement in pRight so it will be deleted when
1592 ** sqlite3ExprListDelete() is called */
1593 pFirst
->pRight
= pExpr
;
1596 /* Remember the size of the LHS in iTable so that we can check that
1597 ** the RHS and LHS sizes match during code generation. */
1598 pFirst
->iTable
= pColumns
->nId
;
1601 vector_append_error
:
1602 sqlite3ExprDelete(db
, pExpr
);
1603 sqlite3IdListDelete(db
, pColumns
);
1608 ** Set the sort order for the last element on the given ExprList.
1610 void sqlite3ExprListSetSortOrder(ExprList
*p
, int iSortOrder
){
1612 assert( SQLITE_SO_UNDEFINED
<0 && SQLITE_SO_ASC
>=0 && SQLITE_SO_DESC
>0 );
1613 assert( p
->nExpr
>0 );
1615 assert( p
->a
[p
->nExpr
-1].sortOrder
==SQLITE_SO_ASC
);
1618 p
->a
[p
->nExpr
-1].sortOrder
= (u8
)iSortOrder
;
1622 ** Set the ExprList.a[].zName element of the most recently added item
1623 ** on the expression list.
1625 ** pList might be NULL following an OOM error. But pName should never be
1626 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1629 void sqlite3ExprListSetName(
1630 Parse
*pParse
, /* Parsing context */
1631 ExprList
*pList
, /* List to which to add the span. */
1632 Token
*pName
, /* Name to be added */
1633 int dequote
/* True to cause the name to be dequoted */
1635 assert( pList
!=0 || pParse
->db
->mallocFailed
!=0 );
1637 struct ExprList_item
*pItem
;
1638 assert( pList
->nExpr
>0 );
1639 pItem
= &pList
->a
[pList
->nExpr
-1];
1640 assert( pItem
->zName
==0 );
1641 pItem
->zName
= sqlite3DbStrNDup(pParse
->db
, pName
->z
, pName
->n
);
1642 if( dequote
) sqlite3Dequote(pItem
->zName
);
1647 ** Set the ExprList.a[].zSpan element of the most recently added item
1648 ** on the expression list.
1650 ** pList might be NULL following an OOM error. But pSpan should never be
1651 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1654 void sqlite3ExprListSetSpan(
1655 Parse
*pParse
, /* Parsing context */
1656 ExprList
*pList
, /* List to which to add the span. */
1657 const char *zStart
, /* Start of the span */
1658 const char *zEnd
/* End of the span */
1660 sqlite3
*db
= pParse
->db
;
1661 assert( pList
!=0 || db
->mallocFailed
!=0 );
1663 struct ExprList_item
*pItem
= &pList
->a
[pList
->nExpr
-1];
1664 assert( pList
->nExpr
>0 );
1665 sqlite3DbFree(db
, pItem
->zSpan
);
1666 pItem
->zSpan
= sqlite3DbSpanDup(db
, zStart
, zEnd
);
1671 ** If the expression list pEList contains more than iLimit elements,
1672 ** leave an error message in pParse.
1674 void sqlite3ExprListCheckLength(
1679 int mx
= pParse
->db
->aLimit
[SQLITE_LIMIT_COLUMN
];
1680 testcase( pEList
&& pEList
->nExpr
==mx
);
1681 testcase( pEList
&& pEList
->nExpr
==mx
+1 );
1682 if( pEList
&& pEList
->nExpr
>mx
){
1683 sqlite3ErrorMsg(pParse
, "too many columns in %s", zObject
);
1688 ** Delete an entire expression list.
1690 static SQLITE_NOINLINE
void exprListDeleteNN(sqlite3
*db
, ExprList
*pList
){
1691 int i
= pList
->nExpr
;
1692 struct ExprList_item
*pItem
= pList
->a
;
1693 assert( pList
->nExpr
>0 );
1695 sqlite3ExprDelete(db
, pItem
->pExpr
);
1696 sqlite3DbFree(db
, pItem
->zName
);
1697 sqlite3DbFree(db
, pItem
->zSpan
);
1700 sqlite3DbFreeNN(db
, pList
);
1702 void sqlite3ExprListDelete(sqlite3
*db
, ExprList
*pList
){
1703 if( pList
) exprListDeleteNN(db
, pList
);
1707 ** Return the bitwise-OR of all Expr.flags fields in the given
1710 u32
sqlite3ExprListFlags(const ExprList
*pList
){
1714 for(i
=0; i
<pList
->nExpr
; i
++){
1715 Expr
*pExpr
= pList
->a
[i
].pExpr
;
1723 ** This is a SELECT-node callback for the expression walker that
1724 ** always "fails". By "fail" in this case, we mean set
1725 ** pWalker->eCode to zero and abort.
1727 ** This callback is used by multiple expression walkers.
1729 int sqlite3SelectWalkFail(Walker
*pWalker
, Select
*NotUsed
){
1730 UNUSED_PARAMETER(NotUsed
);
1736 ** If the input expression is an ID with the name "true" or "false"
1737 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
1738 ** the conversion happened, and zero if the expression is unaltered.
1740 int sqlite3ExprIdToTrueFalse(Expr
*pExpr
){
1741 assert( pExpr
->op
==TK_ID
|| pExpr
->op
==TK_STRING
);
1742 if( sqlite3StrICmp(pExpr
->u
.zToken
, "true")==0
1743 || sqlite3StrICmp(pExpr
->u
.zToken
, "false")==0
1745 pExpr
->op
= TK_TRUEFALSE
;
1752 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
1753 ** and 0 if it is FALSE.
1755 int sqlite3ExprTruthValue(const Expr
*pExpr
){
1756 assert( pExpr
->op
==TK_TRUEFALSE
);
1757 assert( sqlite3StrICmp(pExpr
->u
.zToken
,"true")==0
1758 || sqlite3StrICmp(pExpr
->u
.zToken
,"false")==0 );
1759 return pExpr
->u
.zToken
[4]==0;
1764 ** These routines are Walker callbacks used to check expressions to
1765 ** see if they are "constant" for some definition of constant. The
1766 ** Walker.eCode value determines the type of "constant" we are looking
1769 ** These callback routines are used to implement the following:
1771 ** sqlite3ExprIsConstant() pWalker->eCode==1
1772 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
1773 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
1774 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
1776 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
1777 ** is found to not be a constant.
1779 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating expressions
1780 ** in a CREATE TABLE statement. The Walker.eCode value is 5 when parsing
1781 ** an existing schema and 4 when processing a new statement. A bound
1782 ** parameter raises an error for new statements, but is silently converted
1783 ** to NULL for existing schemas. This allows sqlite_master tables that
1784 ** contain a bound parameter because they were generated by older versions
1785 ** of SQLite to be parsed by newer versions of SQLite without raising a
1786 ** malformed schema error.
1788 static int exprNodeIsConstant(Walker
*pWalker
, Expr
*pExpr
){
1790 /* If pWalker->eCode is 2 then any term of the expression that comes from
1791 ** the ON or USING clauses of a left join disqualifies the expression
1792 ** from being considered constant. */
1793 if( pWalker
->eCode
==2 && ExprHasProperty(pExpr
, EP_FromJoin
) ){
1798 switch( pExpr
->op
){
1799 /* Consider functions to be constant if all their arguments are constant
1800 ** and either pWalker->eCode==4 or 5 or the function has the
1801 ** SQLITE_FUNC_CONST flag. */
1803 if( pWalker
->eCode
>=4 || ExprHasProperty(pExpr
,EP_ConstFunc
) ){
1804 return WRC_Continue
;
1810 /* Convert "true" or "false" in a DEFAULT clause into the
1811 ** appropriate TK_TRUEFALSE operator */
1812 if( sqlite3ExprIdToTrueFalse(pExpr
) ){
1817 case TK_AGG_FUNCTION
:
1819 testcase( pExpr
->op
==TK_ID
);
1820 testcase( pExpr
->op
==TK_COLUMN
);
1821 testcase( pExpr
->op
==TK_AGG_FUNCTION
);
1822 testcase( pExpr
->op
==TK_AGG_COLUMN
);
1823 if( pWalker
->eCode
==3 && pExpr
->iTable
==pWalker
->u
.iCur
){
1824 return WRC_Continue
;
1827 case TK_IF_NULL_ROW
:
1828 testcase( pExpr
->op
==TK_IF_NULL_ROW
);
1832 if( pWalker
->eCode
==5 ){
1833 /* Silently convert bound parameters that appear inside of CREATE
1834 ** statements into a NULL when parsing the CREATE statement text out
1835 ** of the sqlite_master table */
1836 pExpr
->op
= TK_NULL
;
1837 }else if( pWalker
->eCode
==4 ){
1838 /* A bound parameter in a CREATE statement that originates from
1839 ** sqlite3_prepare() causes an error */
1845 testcase( pExpr
->op
==TK_SELECT
); /* sqlite3SelectWalkFail will disallow */
1846 testcase( pExpr
->op
==TK_EXISTS
); /* sqlite3SelectWalkFail will disallow */
1847 return WRC_Continue
;
1850 static int exprIsConst(Expr
*p
, int initFlag
, int iCur
){
1853 w
.xExprCallback
= exprNodeIsConstant
;
1854 w
.xSelectCallback
= sqlite3SelectWalkFail
;
1856 w
.xSelectCallback2
= sqlite3SelectWalkAssert2
;
1859 sqlite3WalkExpr(&w
, p
);
1864 ** Walk an expression tree. Return non-zero if the expression is constant
1865 ** and 0 if it involves variables or function calls.
1867 ** For the purposes of this function, a double-quoted string (ex: "abc")
1868 ** is considered a variable but a single-quoted string (ex: 'abc') is
1871 int sqlite3ExprIsConstant(Expr
*p
){
1872 return exprIsConst(p
, 1, 0);
1876 ** Walk an expression tree. Return non-zero if the expression is constant
1877 ** that does no originate from the ON or USING clauses of a join.
1878 ** Return 0 if it involves variables or function calls or terms from
1879 ** an ON or USING clause.
1881 int sqlite3ExprIsConstantNotJoin(Expr
*p
){
1882 return exprIsConst(p
, 2, 0);
1886 ** Walk an expression tree. Return non-zero if the expression is constant
1887 ** for any single row of the table with cursor iCur. In other words, the
1888 ** expression must not refer to any non-deterministic function nor any
1889 ** table other than iCur.
1891 int sqlite3ExprIsTableConstant(Expr
*p
, int iCur
){
1892 return exprIsConst(p
, 3, iCur
);
1897 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
1899 static int exprNodeIsConstantOrGroupBy(Walker
*pWalker
, Expr
*pExpr
){
1900 ExprList
*pGroupBy
= pWalker
->u
.pGroupBy
;
1903 /* Check if pExpr is identical to any GROUP BY term. If so, consider
1905 for(i
=0; i
<pGroupBy
->nExpr
; i
++){
1906 Expr
*p
= pGroupBy
->a
[i
].pExpr
;
1907 if( sqlite3ExprCompare(0, pExpr
, p
, -1)<2 ){
1908 CollSeq
*pColl
= sqlite3ExprNNCollSeq(pWalker
->pParse
, p
);
1909 if( sqlite3_stricmp("BINARY", pColl
->zName
)==0 ){
1915 /* Check if pExpr is a sub-select. If so, consider it variable. */
1916 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
1921 return exprNodeIsConstant(pWalker
, pExpr
);
1925 ** Walk the expression tree passed as the first argument. Return non-zero
1926 ** if the expression consists entirely of constants or copies of terms
1927 ** in pGroupBy that sort with the BINARY collation sequence.
1929 ** This routine is used to determine if a term of the HAVING clause can
1930 ** be promoted into the WHERE clause. In order for such a promotion to work,
1931 ** the value of the HAVING clause term must be the same for all members of
1932 ** a "group". The requirement that the GROUP BY term must be BINARY
1933 ** assumes that no other collating sequence will have a finer-grained
1934 ** grouping than binary. In other words (A=B COLLATE binary) implies
1935 ** A=B in every other collating sequence. The requirement that the
1936 ** GROUP BY be BINARY is stricter than necessary. It would also work
1937 ** to promote HAVING clauses that use the same alternative collating
1938 ** sequence as the GROUP BY term, but that is much harder to check,
1939 ** alternative collating sequences are uncommon, and this is only an
1940 ** optimization, so we take the easy way out and simply require the
1941 ** GROUP BY to use the BINARY collating sequence.
1943 int sqlite3ExprIsConstantOrGroupBy(Parse
*pParse
, Expr
*p
, ExprList
*pGroupBy
){
1946 w
.xExprCallback
= exprNodeIsConstantOrGroupBy
;
1947 w
.xSelectCallback
= 0;
1948 w
.u
.pGroupBy
= pGroupBy
;
1950 sqlite3WalkExpr(&w
, p
);
1955 ** Walk an expression tree. Return non-zero if the expression is constant
1956 ** or a function call with constant arguments. Return and 0 if there
1957 ** are any variables.
1959 ** For the purposes of this function, a double-quoted string (ex: "abc")
1960 ** is considered a variable but a single-quoted string (ex: 'abc') is
1963 int sqlite3ExprIsConstantOrFunction(Expr
*p
, u8 isInit
){
1964 assert( isInit
==0 || isInit
==1 );
1965 return exprIsConst(p
, 4+isInit
, 0);
1968 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1970 ** Walk an expression tree. Return 1 if the expression contains a
1971 ** subquery of some kind. Return 0 if there are no subqueries.
1973 int sqlite3ExprContainsSubquery(Expr
*p
){
1976 w
.xExprCallback
= sqlite3ExprWalkNoop
;
1977 w
.xSelectCallback
= sqlite3SelectWalkFail
;
1979 w
.xSelectCallback2
= sqlite3SelectWalkAssert2
;
1981 sqlite3WalkExpr(&w
, p
);
1987 ** If the expression p codes a constant integer that is small enough
1988 ** to fit in a 32-bit integer, return 1 and put the value of the integer
1989 ** in *pValue. If the expression is not an integer or if it is too big
1990 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
1992 int sqlite3ExprIsInteger(Expr
*p
, int *pValue
){
1994 if( p
==0 ) return 0; /* Can only happen following on OOM */
1996 /* If an expression is an integer literal that fits in a signed 32-bit
1997 ** integer, then the EP_IntValue flag will have already been set */
1998 assert( p
->op
!=TK_INTEGER
|| (p
->flags
& EP_IntValue
)!=0
1999 || sqlite3GetInt32(p
->u
.zToken
, &rc
)==0 );
2001 if( p
->flags
& EP_IntValue
){
2002 *pValue
= p
->u
.iValue
;
2007 rc
= sqlite3ExprIsInteger(p
->pLeft
, pValue
);
2012 if( sqlite3ExprIsInteger(p
->pLeft
, &v
) ){
2013 assert( v
!=(-2147483647-1) );
2025 ** Return FALSE if there is no chance that the expression can be NULL.
2027 ** If the expression might be NULL or if the expression is too complex
2028 ** to tell return TRUE.
2030 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2031 ** when we know that a value cannot be NULL. Hence, a false positive
2032 ** (returning TRUE when in fact the expression can never be NULL) might
2033 ** be a small performance hit but is otherwise harmless. On the other
2034 ** hand, a false negative (returning FALSE when the result could be NULL)
2035 ** will likely result in an incorrect answer. So when in doubt, return
2038 int sqlite3ExprCanBeNull(const Expr
*p
){
2040 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){ p
= p
->pLeft
; }
2042 if( op
==TK_REGISTER
) op
= p
->op2
;
2050 return ExprHasProperty(p
, EP_CanBeNull
) ||
2051 p
->pTab
==0 || /* Reference to column of index on expression */
2052 (p
->iColumn
>=0 && p
->pTab
->aCol
[p
->iColumn
].notNull
==0);
2059 ** Return TRUE if the given expression is a constant which would be
2060 ** unchanged by OP_Affinity with the affinity given in the second
2063 ** This routine is used to determine if the OP_Affinity operation
2064 ** can be omitted. When in doubt return FALSE. A false negative
2065 ** is harmless. A false positive, however, can result in the wrong
2068 int sqlite3ExprNeedsNoAffinityChange(const Expr
*p
, char aff
){
2070 if( aff
==SQLITE_AFF_BLOB
) return 1;
2071 while( p
->op
==TK_UPLUS
|| p
->op
==TK_UMINUS
){ p
= p
->pLeft
; }
2073 if( op
==TK_REGISTER
) op
= p
->op2
;
2076 return aff
==SQLITE_AFF_INTEGER
|| aff
==SQLITE_AFF_NUMERIC
;
2079 return aff
==SQLITE_AFF_REAL
|| aff
==SQLITE_AFF_NUMERIC
;
2082 return aff
==SQLITE_AFF_TEXT
;
2088 assert( p
->iTable
>=0 ); /* p cannot be part of a CHECK constraint */
2090 && (aff
==SQLITE_AFF_INTEGER
|| aff
==SQLITE_AFF_NUMERIC
);
2099 ** Return TRUE if the given string is a row-id column name.
2101 int sqlite3IsRowid(const char *z
){
2102 if( sqlite3StrICmp(z
, "_ROWID_")==0 ) return 1;
2103 if( sqlite3StrICmp(z
, "ROWID")==0 ) return 1;
2104 if( sqlite3StrICmp(z
, "OID")==0 ) return 1;
2109 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2110 ** that can be simplified to a direct table access, then return
2111 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2112 ** or if the SELECT statement needs to be manifested into a transient
2113 ** table, then return NULL.
2115 #ifndef SQLITE_OMIT_SUBQUERY
2116 static Select
*isCandidateForInOpt(Expr
*pX
){
2122 if( !ExprHasProperty(pX
, EP_xIsSelect
) ) return 0; /* Not a subquery */
2123 if( ExprHasProperty(pX
, EP_VarSelect
) ) return 0; /* Correlated subq */
2125 if( p
->pPrior
) return 0; /* Not a compound SELECT */
2126 if( p
->selFlags
& (SF_Distinct
|SF_Aggregate
) ){
2127 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Distinct
);
2128 testcase( (p
->selFlags
& (SF_Distinct
|SF_Aggregate
))==SF_Aggregate
);
2129 return 0; /* No DISTINCT keyword and no aggregate functions */
2131 assert( p
->pGroupBy
==0 ); /* Has no GROUP BY clause */
2132 if( p
->pLimit
) return 0; /* Has no LIMIT clause */
2133 if( p
->pWhere
) return 0; /* Has no WHERE clause */
2136 if( pSrc
->nSrc
!=1 ) return 0; /* Single term in FROM clause */
2137 if( pSrc
->a
[0].pSelect
) return 0; /* FROM is not a subquery or view */
2138 pTab
= pSrc
->a
[0].pTab
;
2140 assert( pTab
->pSelect
==0 ); /* FROM clause is not a view */
2141 if( IsVirtual(pTab
) ) return 0; /* FROM clause not a virtual table */
2143 assert( pEList
!=0 );
2144 /* All SELECT results must be columns. */
2145 for(i
=0; i
<pEList
->nExpr
; i
++){
2146 Expr
*pRes
= pEList
->a
[i
].pExpr
;
2147 if( pRes
->op
!=TK_COLUMN
) return 0;
2148 assert( pRes
->iTable
==pSrc
->a
[0].iCursor
); /* Not a correlated subquery */
2152 #endif /* SQLITE_OMIT_SUBQUERY */
2154 #ifndef SQLITE_OMIT_SUBQUERY
2156 ** Generate code that checks the left-most column of index table iCur to see if
2157 ** it contains any NULL entries. Cause the register at regHasNull to be set
2158 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2159 ** to be set to NULL if iCur contains one or more NULL values.
2161 static void sqlite3SetHasNullFlag(Vdbe
*v
, int iCur
, int regHasNull
){
2163 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regHasNull
);
2164 addr1
= sqlite3VdbeAddOp1(v
, OP_Rewind
, iCur
); VdbeCoverage(v
);
2165 sqlite3VdbeAddOp3(v
, OP_Column
, iCur
, 0, regHasNull
);
2166 sqlite3VdbeChangeP5(v
, OPFLAG_TYPEOFARG
);
2167 VdbeComment((v
, "first_entry_in(%d)", iCur
));
2168 sqlite3VdbeJumpHere(v
, addr1
);
2173 #ifndef SQLITE_OMIT_SUBQUERY
2175 ** The argument is an IN operator with a list (not a subquery) on the
2176 ** right-hand side. Return TRUE if that list is constant.
2178 static int sqlite3InRhsIsConstant(Expr
*pIn
){
2181 assert( !ExprHasProperty(pIn
, EP_xIsSelect
) );
2184 res
= sqlite3ExprIsConstant(pIn
);
2191 ** This function is used by the implementation of the IN (...) operator.
2192 ** The pX parameter is the expression on the RHS of the IN operator, which
2193 ** might be either a list of expressions or a subquery.
2195 ** The job of this routine is to find or create a b-tree object that can
2196 ** be used either to test for membership in the RHS set or to iterate through
2197 ** all members of the RHS set, skipping duplicates.
2199 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2200 ** and pX->iTable is set to the index of that cursor.
2202 ** The returned value of this function indicates the b-tree type, as follows:
2204 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2205 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2206 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2207 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2208 ** populated epheremal table.
2209 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2210 ** implemented as a sequence of comparisons.
2212 ** An existing b-tree might be used if the RHS expression pX is a simple
2213 ** subquery such as:
2215 ** SELECT <column1>, <column2>... FROM <table>
2217 ** If the RHS of the IN operator is a list or a more complex subquery, then
2218 ** an ephemeral table might need to be generated from the RHS and then
2219 ** pX->iTable made to point to the ephemeral table instead of an
2222 ** The inFlags parameter must contain, at a minimum, one of the bits
2223 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2224 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2225 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2226 ** be used to loop over all values of the RHS of the IN operator.
2228 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2229 ** through the set members) then the b-tree must not contain duplicates.
2230 ** An epheremal table will be created unless the selected columns are guaranteed
2231 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2232 ** a UNIQUE constraint or index.
2234 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2235 ** for fast set membership tests) then an epheremal table must
2236 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2237 ** index can be found with the specified <columns> as its left-most.
2239 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2240 ** if the RHS of the IN operator is a list (not a subquery) then this
2241 ** routine might decide that creating an ephemeral b-tree for membership
2242 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2243 ** calling routine should implement the IN operator using a sequence
2244 ** of Eq or Ne comparison operations.
2246 ** When the b-tree is being used for membership tests, the calling function
2247 ** might need to know whether or not the RHS side of the IN operator
2248 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2249 ** if there is any chance that the (...) might contain a NULL value at
2250 ** runtime, then a register is allocated and the register number written
2251 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2252 ** NULL value, then *prRhsHasNull is left unchanged.
2254 ** If a register is allocated and its location stored in *prRhsHasNull, then
2255 ** the value in that register will be NULL if the b-tree contains one or more
2256 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2259 ** If the aiMap parameter is not NULL, it must point to an array containing
2260 ** one element for each column returned by the SELECT statement on the RHS
2261 ** of the IN(...) operator. The i'th entry of the array is populated with the
2262 ** offset of the index column that matches the i'th column returned by the
2263 ** SELECT. For example, if the expression and selected index are:
2265 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2266 ** CREATE INDEX i1 ON t1(b, c, a);
2268 ** then aiMap[] is populated with {2, 0, 1}.
2270 #ifndef SQLITE_OMIT_SUBQUERY
2271 int sqlite3FindInIndex(
2272 Parse
*pParse
, /* Parsing context */
2273 Expr
*pX
, /* The right-hand side (RHS) of the IN operator */
2274 u32 inFlags
, /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */
2275 int *prRhsHasNull
, /* Register holding NULL status. See notes */
2276 int *aiMap
/* Mapping from Index fields to RHS fields */
2278 Select
*p
; /* SELECT to the right of IN operator */
2279 int eType
= 0; /* Type of RHS table. IN_INDEX_* */
2280 int iTab
= pParse
->nTab
++; /* Cursor of the RHS table */
2281 int mustBeUnique
; /* True if RHS must be unique */
2282 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Virtual machine being coded */
2284 assert( pX
->op
==TK_IN
);
2285 mustBeUnique
= (inFlags
& IN_INDEX_LOOP
)!=0;
2287 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2288 ** whether or not the SELECT result contains NULL values, check whether
2289 ** or not NULL is actually possible (it may not be, for example, due
2290 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2291 ** set prRhsHasNull to 0 before continuing. */
2292 if( prRhsHasNull
&& (pX
->flags
& EP_xIsSelect
) ){
2294 ExprList
*pEList
= pX
->x
.pSelect
->pEList
;
2295 for(i
=0; i
<pEList
->nExpr
; i
++){
2296 if( sqlite3ExprCanBeNull(pEList
->a
[i
].pExpr
) ) break;
2298 if( i
==pEList
->nExpr
){
2303 /* Check to see if an existing table or index can be used to
2304 ** satisfy the query. This is preferable to generating a new
2305 ** ephemeral table. */
2306 if( pParse
->nErr
==0 && (p
= isCandidateForInOpt(pX
))!=0 ){
2307 sqlite3
*db
= pParse
->db
; /* Database connection */
2308 Table
*pTab
; /* Table <table>. */
2309 i16 iDb
; /* Database idx for pTab */
2310 ExprList
*pEList
= p
->pEList
;
2311 int nExpr
= pEList
->nExpr
;
2313 assert( p
->pEList
!=0 ); /* Because of isCandidateForInOpt(p) */
2314 assert( p
->pEList
->a
[0].pExpr
!=0 ); /* Because of isCandidateForInOpt(p) */
2315 assert( p
->pSrc
!=0 ); /* Because of isCandidateForInOpt(p) */
2316 pTab
= p
->pSrc
->a
[0].pTab
;
2318 /* Code an OP_Transaction and OP_TableLock for <table>. */
2319 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
2320 sqlite3CodeVerifySchema(pParse
, iDb
);
2321 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
2323 assert(v
); /* sqlite3GetVdbe() has always been previously called */
2324 if( nExpr
==1 && pEList
->a
[0].pExpr
->iColumn
<0 ){
2325 /* The "x IN (SELECT rowid FROM table)" case */
2326 int iAddr
= sqlite3VdbeAddOp0(v
, OP_Once
);
2329 sqlite3OpenTable(pParse
, iTab
, iDb
, pTab
, OP_OpenRead
);
2330 eType
= IN_INDEX_ROWID
;
2332 sqlite3VdbeJumpHere(v
, iAddr
);
2334 Index
*pIdx
; /* Iterator variable */
2335 int affinity_ok
= 1;
2338 /* Check that the affinity that will be used to perform each
2339 ** comparison is the same as the affinity of each column in table
2340 ** on the RHS of the IN operator. If it not, it is not possible to
2341 ** use any index of the RHS table. */
2342 for(i
=0; i
<nExpr
&& affinity_ok
; i
++){
2343 Expr
*pLhs
= sqlite3VectorFieldSubexpr(pX
->pLeft
, i
);
2344 int iCol
= pEList
->a
[i
].pExpr
->iColumn
;
2345 char idxaff
= sqlite3TableColumnAffinity(pTab
,iCol
); /* RHS table */
2346 char cmpaff
= sqlite3CompareAffinity(pLhs
, idxaff
);
2347 testcase( cmpaff
==SQLITE_AFF_BLOB
);
2348 testcase( cmpaff
==SQLITE_AFF_TEXT
);
2350 case SQLITE_AFF_BLOB
:
2352 case SQLITE_AFF_TEXT
:
2353 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2354 ** other has no affinity and the other side is TEXT. Hence,
2355 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2356 ** and for the term on the LHS of the IN to have no affinity. */
2357 assert( idxaff
==SQLITE_AFF_TEXT
);
2360 affinity_ok
= sqlite3IsNumericAffinity(idxaff
);
2365 /* Search for an existing index that will work for this IN operator */
2366 for(pIdx
=pTab
->pIndex
; pIdx
&& eType
==0; pIdx
=pIdx
->pNext
){
2367 Bitmask colUsed
; /* Columns of the index used */
2368 Bitmask mCol
; /* Mask for the current column */
2369 if( pIdx
->nColumn
<nExpr
) continue;
2370 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2371 ** BITMASK(nExpr) without overflowing */
2372 testcase( pIdx
->nColumn
==BMS
-2 );
2373 testcase( pIdx
->nColumn
==BMS
-1 );
2374 if( pIdx
->nColumn
>=BMS
-1 ) continue;
2376 if( pIdx
->nKeyCol
>nExpr
2377 ||(pIdx
->nColumn
>nExpr
&& !IsUniqueIndex(pIdx
))
2379 continue; /* This index is not unique over the IN RHS columns */
2383 colUsed
= 0; /* Columns of index used so far */
2384 for(i
=0; i
<nExpr
; i
++){
2385 Expr
*pLhs
= sqlite3VectorFieldSubexpr(pX
->pLeft
, i
);
2386 Expr
*pRhs
= pEList
->a
[i
].pExpr
;
2387 CollSeq
*pReq
= sqlite3BinaryCompareCollSeq(pParse
, pLhs
, pRhs
);
2390 assert( pReq
!=0 || pRhs
->iColumn
==XN_ROWID
|| pParse
->nErr
);
2391 for(j
=0; j
<nExpr
; j
++){
2392 if( pIdx
->aiColumn
[j
]!=pRhs
->iColumn
) continue;
2393 assert( pIdx
->azColl
[j
] );
2394 if( pReq
!=0 && sqlite3StrICmp(pReq
->zName
, pIdx
->azColl
[j
])!=0 ){
2399 if( j
==nExpr
) break;
2401 if( mCol
& colUsed
) break; /* Each column used only once */
2403 if( aiMap
) aiMap
[i
] = j
;
2406 assert( i
==nExpr
|| colUsed
!=(MASKBIT(nExpr
)-1) );
2407 if( colUsed
==(MASKBIT(nExpr
)-1) ){
2408 /* If we reach this point, that means the index pIdx is usable */
2409 int iAddr
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
2410 #ifndef SQLITE_OMIT_EXPLAIN
2411 sqlite3VdbeAddOp4(v
, OP_Explain
, 0, 0, 0,
2412 sqlite3MPrintf(db
, "USING INDEX %s FOR IN-OPERATOR",pIdx
->zName
),
2415 sqlite3VdbeAddOp3(v
, OP_OpenRead
, iTab
, pIdx
->tnum
, iDb
);
2416 sqlite3VdbeSetP4KeyInfo(pParse
, pIdx
);
2417 VdbeComment((v
, "%s", pIdx
->zName
));
2418 assert( IN_INDEX_INDEX_DESC
== IN_INDEX_INDEX_ASC
+1 );
2419 eType
= IN_INDEX_INDEX_ASC
+ pIdx
->aSortOrder
[0];
2422 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2423 i64 mask
= (1<<nExpr
)-1;
2424 sqlite3VdbeAddOp4Dup8(v
, OP_ColumnsUsed
,
2425 iTab
, 0, 0, (u8
*)&mask
, P4_INT64
);
2427 *prRhsHasNull
= ++pParse
->nMem
;
2429 sqlite3SetHasNullFlag(v
, iTab
, *prRhsHasNull
);
2432 sqlite3VdbeJumpHere(v
, iAddr
);
2434 } /* End loop over indexes */
2435 } /* End if( affinity_ok ) */
2436 } /* End if not an rowid index */
2437 } /* End attempt to optimize using an index */
2439 /* If no preexisting index is available for the IN clause
2440 ** and IN_INDEX_NOOP is an allowed reply
2441 ** and the RHS of the IN operator is a list, not a subquery
2442 ** and the RHS is not constant or has two or fewer terms,
2443 ** then it is not worth creating an ephemeral table to evaluate
2444 ** the IN operator so return IN_INDEX_NOOP.
2447 && (inFlags
& IN_INDEX_NOOP_OK
)
2448 && !ExprHasProperty(pX
, EP_xIsSelect
)
2449 && (!sqlite3InRhsIsConstant(pX
) || pX
->x
.pList
->nExpr
<=2)
2451 eType
= IN_INDEX_NOOP
;
2455 /* Could not find an existing table or index to use as the RHS b-tree.
2456 ** We will have to generate an ephemeral table to do the job.
2458 u32 savedNQueryLoop
= pParse
->nQueryLoop
;
2459 int rMayHaveNull
= 0;
2460 eType
= IN_INDEX_EPH
;
2461 if( inFlags
& IN_INDEX_LOOP
){
2462 pParse
->nQueryLoop
= 0;
2463 if( pX
->pLeft
->iColumn
<0 && !ExprHasProperty(pX
, EP_xIsSelect
) ){
2464 eType
= IN_INDEX_ROWID
;
2466 }else if( prRhsHasNull
){
2467 *prRhsHasNull
= rMayHaveNull
= ++pParse
->nMem
;
2469 sqlite3CodeSubselect(pParse
, pX
, rMayHaveNull
, eType
==IN_INDEX_ROWID
);
2470 pParse
->nQueryLoop
= savedNQueryLoop
;
2475 if( aiMap
&& eType
!=IN_INDEX_INDEX_ASC
&& eType
!=IN_INDEX_INDEX_DESC
){
2477 n
= sqlite3ExprVectorSize(pX
->pLeft
);
2478 for(i
=0; i
<n
; i
++) aiMap
[i
] = i
;
2484 #ifndef SQLITE_OMIT_SUBQUERY
2486 ** Argument pExpr is an (?, ?...) IN(...) expression. This
2487 ** function allocates and returns a nul-terminated string containing
2488 ** the affinities to be used for each column of the comparison.
2490 ** It is the responsibility of the caller to ensure that the returned
2491 ** string is eventually freed using sqlite3DbFree().
2493 static char *exprINAffinity(Parse
*pParse
, Expr
*pExpr
){
2494 Expr
*pLeft
= pExpr
->pLeft
;
2495 int nVal
= sqlite3ExprVectorSize(pLeft
);
2496 Select
*pSelect
= (pExpr
->flags
& EP_xIsSelect
) ? pExpr
->x
.pSelect
: 0;
2499 assert( pExpr
->op
==TK_IN
);
2500 zRet
= sqlite3DbMallocRaw(pParse
->db
, nVal
+1);
2503 for(i
=0; i
<nVal
; i
++){
2504 Expr
*pA
= sqlite3VectorFieldSubexpr(pLeft
, i
);
2505 char a
= sqlite3ExprAffinity(pA
);
2507 zRet
[i
] = sqlite3CompareAffinity(pSelect
->pEList
->a
[i
].pExpr
, a
);
2518 #ifndef SQLITE_OMIT_SUBQUERY
2520 ** Load the Parse object passed as the first argument with an error
2521 ** message of the form:
2523 ** "sub-select returns N columns - expected M"
2525 void sqlite3SubselectError(Parse
*pParse
, int nActual
, int nExpect
){
2526 const char *zFmt
= "sub-select returns %d columns - expected %d";
2527 sqlite3ErrorMsg(pParse
, zFmt
, nActual
, nExpect
);
2532 ** Expression pExpr is a vector that has been used in a context where
2533 ** it is not permitted. If pExpr is a sub-select vector, this routine
2534 ** loads the Parse object with a message of the form:
2536 ** "sub-select returns N columns - expected 1"
2538 ** Or, if it is a regular scalar vector:
2540 ** "row value misused"
2542 void sqlite3VectorErrorMsg(Parse
*pParse
, Expr
*pExpr
){
2543 #ifndef SQLITE_OMIT_SUBQUERY
2544 if( pExpr
->flags
& EP_xIsSelect
){
2545 sqlite3SubselectError(pParse
, pExpr
->x
.pSelect
->pEList
->nExpr
, 1);
2549 sqlite3ErrorMsg(pParse
, "row value misused");
2554 ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
2555 ** or IN operators. Examples:
2557 ** (SELECT a FROM b) -- subquery
2558 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
2559 ** x IN (4,5,11) -- IN operator with list on right-hand side
2560 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
2562 ** The pExpr parameter describes the expression that contains the IN
2563 ** operator or subquery.
2565 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
2566 ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
2567 ** to some integer key column of a table B-Tree. In this case, use an
2568 ** intkey B-Tree to store the set of IN(...) values instead of the usual
2569 ** (slower) variable length keys B-Tree.
2571 ** If rMayHaveNull is non-zero, that means that the operation is an IN
2572 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
2573 ** All this routine does is initialize the register given by rMayHaveNull
2574 ** to NULL. Calling routines will take care of changing this register
2575 ** value to non-NULL if the RHS is NULL-free.
2577 ** For a SELECT or EXISTS operator, return the register that holds the
2578 ** result. For a multi-column SELECT, the result is stored in a contiguous
2579 ** array of registers and the return value is the register of the left-most
2580 ** result column. Return 0 for IN operators or if an error occurs.
2582 #ifndef SQLITE_OMIT_SUBQUERY
2583 int sqlite3CodeSubselect(
2584 Parse
*pParse
, /* Parsing context */
2585 Expr
*pExpr
, /* The IN, SELECT, or EXISTS operator */
2586 int rHasNullFlag
, /* Register that records whether NULLs exist in RHS */
2587 int isRowid
/* If true, LHS of IN operator is a rowid */
2589 int jmpIfDynamic
= -1; /* One-time test address */
2590 int rReg
= 0; /* Register storing resulting */
2591 Vdbe
*v
= sqlite3GetVdbe(pParse
);
2592 if( NEVER(v
==0) ) return 0;
2593 sqlite3ExprCachePush(pParse
);
2595 /* The evaluation of the IN/EXISTS/SELECT must be repeated every time it
2596 ** is encountered if any of the following is true:
2598 ** * The right-hand side is a correlated subquery
2599 ** * The right-hand side is an expression list containing variables
2600 ** * We are inside a trigger
2602 ** If all of the above are false, then we can run this code just once
2603 ** save the results, and reuse the same result on subsequent invocations.
2605 if( !ExprHasProperty(pExpr
, EP_VarSelect
) ){
2606 jmpIfDynamic
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
2609 #ifndef SQLITE_OMIT_EXPLAIN
2610 if( pParse
->explain
==2 ){
2611 char *zMsg
= sqlite3MPrintf(pParse
->db
, "EXECUTE %s%s SUBQUERY %d",
2612 jmpIfDynamic
>=0?"":"CORRELATED ",
2613 pExpr
->op
==TK_IN
?"LIST":"SCALAR",
2614 pParse
->iNextSelectId
2616 sqlite3VdbeAddOp4(v
, OP_Explain
, pParse
->iSelectId
, 0, 0, zMsg
, P4_DYNAMIC
);
2620 switch( pExpr
->op
){
2622 int addr
; /* Address of OP_OpenEphemeral instruction */
2623 Expr
*pLeft
= pExpr
->pLeft
; /* the LHS of the IN operator */
2624 KeyInfo
*pKeyInfo
= 0; /* Key information */
2625 int nVal
; /* Size of vector pLeft */
2627 nVal
= sqlite3ExprVectorSize(pLeft
);
2628 assert( !isRowid
|| nVal
==1 );
2630 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
2631 ** expression it is handled the same way. An ephemeral table is
2632 ** filled with index keys representing the results from the
2633 ** SELECT or the <exprlist>.
2635 ** If the 'x' expression is a column value, or the SELECT...
2636 ** statement returns a column value, then the affinity of that
2637 ** column is used to build the index keys. If both 'x' and the
2638 ** SELECT... statement are columns, then numeric affinity is used
2639 ** if either column has NUMERIC or INTEGER affinity. If neither
2640 ** 'x' nor the SELECT... statement are columns, then numeric affinity
2643 pExpr
->iTable
= pParse
->nTab
++;
2644 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
,
2645 pExpr
->iTable
, (isRowid
?0:nVal
));
2646 pKeyInfo
= isRowid
? 0 : sqlite3KeyInfoAlloc(pParse
->db
, nVal
, 1);
2648 if( ExprHasProperty(pExpr
, EP_xIsSelect
) ){
2649 /* Case 1: expr IN (SELECT ...)
2651 ** Generate code to write the results of the select into the temporary
2652 ** table allocated and opened above.
2654 Select
*pSelect
= pExpr
->x
.pSelect
;
2655 ExprList
*pEList
= pSelect
->pEList
;
2658 /* If the LHS and RHS of the IN operator do not match, that
2659 ** error will have been caught long before we reach this point. */
2660 if( ALWAYS(pEList
->nExpr
==nVal
) ){
2663 sqlite3SelectDestInit(&dest
, SRT_Set
, pExpr
->iTable
);
2664 dest
.zAffSdst
= exprINAffinity(pParse
, pExpr
);
2665 pSelect
->iLimit
= 0;
2666 testcase( pSelect
->selFlags
& SF_Distinct
);
2667 testcase( pKeyInfo
==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
2668 if( sqlite3Select(pParse
, pSelect
, &dest
) ){
2669 sqlite3DbFree(pParse
->db
, dest
.zAffSdst
);
2670 sqlite3KeyInfoUnref(pKeyInfo
);
2673 sqlite3DbFree(pParse
->db
, dest
.zAffSdst
);
2674 assert( pKeyInfo
!=0 ); /* OOM will cause exit after sqlite3Select() */
2675 assert( pEList
!=0 );
2676 assert( pEList
->nExpr
>0 );
2677 assert( sqlite3KeyInfoIsWriteable(pKeyInfo
) );
2678 for(i
=0; i
<nVal
; i
++){
2679 Expr
*p
= sqlite3VectorFieldSubexpr(pLeft
, i
);
2680 pKeyInfo
->aColl
[i
] = sqlite3BinaryCompareCollSeq(
2681 pParse
, p
, pEList
->a
[i
].pExpr
2685 }else if( ALWAYS(pExpr
->x
.pList
!=0) ){
2686 /* Case 2: expr IN (exprlist)
2688 ** For each expression, build an index key from the evaluation and
2689 ** store it in the temporary table. If <expr> is a column, then use
2690 ** that columns affinity when building index keys. If <expr> is not
2691 ** a column, use numeric affinity.
2693 char affinity
; /* Affinity of the LHS of the IN */
2695 ExprList
*pList
= pExpr
->x
.pList
;
2696 struct ExprList_item
*pItem
;
2699 affinity
= sqlite3ExprAffinity(pLeft
);
2701 affinity
= SQLITE_AFF_BLOB
;
2704 assert( sqlite3KeyInfoIsWriteable(pKeyInfo
) );
2705 pKeyInfo
->aColl
[0] = sqlite3ExprCollSeq(pParse
, pExpr
->pLeft
);
2708 /* Loop through each expression in <exprlist>. */
2709 r1
= sqlite3GetTempReg(pParse
);
2710 r2
= sqlite3GetTempReg(pParse
);
2711 if( isRowid
) sqlite3VdbeAddOp4(v
, OP_Blob
, 0, r2
, 0, "", P4_STATIC
);
2712 for(i
=pList
->nExpr
, pItem
=pList
->a
; i
>0; i
--, pItem
++){
2713 Expr
*pE2
= pItem
->pExpr
;
2716 /* If the expression is not constant then we will need to
2717 ** disable the test that was generated above that makes sure
2718 ** this code only executes once. Because for a non-constant
2719 ** expression we need to rerun this code each time.
2721 if( jmpIfDynamic
>=0 && !sqlite3ExprIsConstant(pE2
) ){
2722 sqlite3VdbeChangeToNoop(v
, jmpIfDynamic
);
2726 /* Evaluate the expression and insert it into the temp table */
2727 if( isRowid
&& sqlite3ExprIsInteger(pE2
, &iValToIns
) ){
2728 sqlite3VdbeAddOp3(v
, OP_InsertInt
, pExpr
->iTable
, r2
, iValToIns
);
2730 r3
= sqlite3ExprCodeTarget(pParse
, pE2
, r1
);
2732 sqlite3VdbeAddOp2(v
, OP_MustBeInt
, r3
,
2733 sqlite3VdbeCurrentAddr(v
)+2);
2735 sqlite3VdbeAddOp3(v
, OP_Insert
, pExpr
->iTable
, r2
, r3
);
2737 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, r3
, 1, r2
, &affinity
, 1);
2738 sqlite3ExprCacheAffinityChange(pParse
, r3
, 1);
2739 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, pExpr
->iTable
, r2
, r3
, 1);
2743 sqlite3ReleaseTempReg(pParse
, r1
);
2744 sqlite3ReleaseTempReg(pParse
, r2
);
2747 sqlite3VdbeChangeP4(v
, addr
, (void *)pKeyInfo
, P4_KEYINFO
);
2755 /* Case 3: (SELECT ... FROM ...)
2756 ** or: EXISTS(SELECT ... FROM ...)
2758 ** For a SELECT, generate code to put the values for all columns of
2759 ** the first row into an array of registers and return the index of
2760 ** the first register.
2762 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
2763 ** into a register and return that register number.
2765 ** In both cases, the query is augmented with "LIMIT 1". Any
2766 ** preexisting limit is discarded in place of the new LIMIT 1.
2768 Select
*pSel
; /* SELECT statement to encode */
2769 SelectDest dest
; /* How to deal with SELECT result */
2770 int nReg
; /* Registers to allocate */
2771 Expr
*pLimit
; /* New limit expression */
2773 testcase( pExpr
->op
==TK_EXISTS
);
2774 testcase( pExpr
->op
==TK_SELECT
);
2775 assert( pExpr
->op
==TK_EXISTS
|| pExpr
->op
==TK_SELECT
);
2776 assert( ExprHasProperty(pExpr
, EP_xIsSelect
) );
2778 pSel
= pExpr
->x
.pSelect
;
2779 nReg
= pExpr
->op
==TK_SELECT
? pSel
->pEList
->nExpr
: 1;
2780 sqlite3SelectDestInit(&dest
, 0, pParse
->nMem
+1);
2781 pParse
->nMem
+= nReg
;
2782 if( pExpr
->op
==TK_SELECT
){
2783 dest
.eDest
= SRT_Mem
;
2784 dest
.iSdst
= dest
.iSDParm
;
2786 sqlite3VdbeAddOp3(v
, OP_Null
, 0, dest
.iSDParm
, dest
.iSDParm
+nReg
-1);
2787 VdbeComment((v
, "Init subquery result"));
2789 dest
.eDest
= SRT_Exists
;
2790 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, dest
.iSDParm
);
2791 VdbeComment((v
, "Init EXISTS result"));
2793 pLimit
= sqlite3ExprAlloc(pParse
->db
, TK_INTEGER
,&sqlite3IntTokens
[1], 0);
2795 sqlite3ExprDelete(pParse
->db
, pSel
->pLimit
->pLeft
);
2796 pSel
->pLimit
->pLeft
= pLimit
;
2798 pSel
->pLimit
= sqlite3PExpr(pParse
, TK_LIMIT
, pLimit
, 0);
2801 if( sqlite3Select(pParse
, pSel
, &dest
) ){
2804 rReg
= dest
.iSDParm
;
2805 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
2811 sqlite3SetHasNullFlag(v
, pExpr
->iTable
, rHasNullFlag
);
2814 if( jmpIfDynamic
>=0 ){
2815 sqlite3VdbeJumpHere(v
, jmpIfDynamic
);
2817 sqlite3ExprCachePop(pParse
);
2821 #endif /* SQLITE_OMIT_SUBQUERY */
2823 #ifndef SQLITE_OMIT_SUBQUERY
2825 ** Expr pIn is an IN(...) expression. This function checks that the
2826 ** sub-select on the RHS of the IN() operator has the same number of
2827 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
2828 ** a sub-query, that the LHS is a vector of size 1.
2830 int sqlite3ExprCheckIN(Parse
*pParse
, Expr
*pIn
){
2831 int nVector
= sqlite3ExprVectorSize(pIn
->pLeft
);
2832 if( (pIn
->flags
& EP_xIsSelect
) ){
2833 if( nVector
!=pIn
->x
.pSelect
->pEList
->nExpr
){
2834 sqlite3SubselectError(pParse
, pIn
->x
.pSelect
->pEList
->nExpr
, nVector
);
2837 }else if( nVector
!=1 ){
2838 sqlite3VectorErrorMsg(pParse
, pIn
->pLeft
);
2845 #ifndef SQLITE_OMIT_SUBQUERY
2847 ** Generate code for an IN expression.
2849 ** x IN (SELECT ...)
2850 ** x IN (value, value, ...)
2852 ** The left-hand side (LHS) is a scalar or vector expression. The
2853 ** right-hand side (RHS) is an array of zero or more scalar values, or a
2854 ** subquery. If the RHS is a subquery, the number of result columns must
2855 ** match the number of columns in the vector on the LHS. If the RHS is
2856 ** a list of values, the LHS must be a scalar.
2858 ** The IN operator is true if the LHS value is contained within the RHS.
2859 ** The result is false if the LHS is definitely not in the RHS. The
2860 ** result is NULL if the presence of the LHS in the RHS cannot be
2861 ** determined due to NULLs.
2863 ** This routine generates code that jumps to destIfFalse if the LHS is not
2864 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
2865 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
2866 ** within the RHS then fall through.
2868 ** See the separate in-operator.md documentation file in the canonical
2869 ** SQLite source tree for additional information.
2871 static void sqlite3ExprCodeIN(
2872 Parse
*pParse
, /* Parsing and code generating context */
2873 Expr
*pExpr
, /* The IN expression */
2874 int destIfFalse
, /* Jump here if LHS is not contained in the RHS */
2875 int destIfNull
/* Jump here if the results are unknown due to NULLs */
2877 int rRhsHasNull
= 0; /* Register that is true if RHS contains NULL values */
2878 int eType
; /* Type of the RHS */
2879 int rLhs
; /* Register(s) holding the LHS values */
2880 int rLhsOrig
; /* LHS values prior to reordering by aiMap[] */
2881 Vdbe
*v
; /* Statement under construction */
2882 int *aiMap
= 0; /* Map from vector field to index column */
2883 char *zAff
= 0; /* Affinity string for comparisons */
2884 int nVector
; /* Size of vectors for this IN operator */
2885 int iDummy
; /* Dummy parameter to exprCodeVector() */
2886 Expr
*pLeft
; /* The LHS of the IN operator */
2887 int i
; /* loop counter */
2888 int destStep2
; /* Where to jump when NULLs seen in step 2 */
2889 int destStep6
= 0; /* Start of code for Step 6 */
2890 int addrTruthOp
; /* Address of opcode that determines the IN is true */
2891 int destNotNull
; /* Jump here if a comparison is not true in step 6 */
2892 int addrTop
; /* Top of the step-6 loop */
2894 pLeft
= pExpr
->pLeft
;
2895 if( sqlite3ExprCheckIN(pParse
, pExpr
) ) return;
2896 zAff
= exprINAffinity(pParse
, pExpr
);
2897 nVector
= sqlite3ExprVectorSize(pExpr
->pLeft
);
2898 aiMap
= (int*)sqlite3DbMallocZero(
2899 pParse
->db
, nVector
*(sizeof(int) + sizeof(char)) + 1
2901 if( pParse
->db
->mallocFailed
) goto sqlite3ExprCodeIN_oom_error
;
2903 /* Attempt to compute the RHS. After this step, if anything other than
2904 ** IN_INDEX_NOOP is returned, the table opened ith cursor pExpr->iTable
2905 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
2906 ** the RHS has not yet been coded. */
2908 assert( v
!=0 ); /* OOM detected prior to this routine */
2909 VdbeNoopComment((v
, "begin IN expr"));
2910 eType
= sqlite3FindInIndex(pParse
, pExpr
,
2911 IN_INDEX_MEMBERSHIP
| IN_INDEX_NOOP_OK
,
2912 destIfFalse
==destIfNull
? 0 : &rRhsHasNull
, aiMap
);
2914 assert( pParse
->nErr
|| nVector
==1 || eType
==IN_INDEX_EPH
2915 || eType
==IN_INDEX_INDEX_ASC
|| eType
==IN_INDEX_INDEX_DESC
2918 /* Confirm that aiMap[] contains nVector integer values between 0 and
2920 for(i
=0; i
<nVector
; i
++){
2922 for(cnt
=j
=0; j
<nVector
; j
++) if( aiMap
[j
]==i
) cnt
++;
2927 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
2928 ** vector, then it is stored in an array of nVector registers starting
2931 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
2932 ** so that the fields are in the same order as an existing index. The
2933 ** aiMap[] array contains a mapping from the original LHS field order to
2934 ** the field order that matches the RHS index.
2936 sqlite3ExprCachePush(pParse
);
2937 rLhsOrig
= exprCodeVector(pParse
, pLeft
, &iDummy
);
2938 for(i
=0; i
<nVector
&& aiMap
[i
]==i
; i
++){} /* Are LHS fields reordered? */
2940 /* LHS fields are not reordered */
2943 /* Need to reorder the LHS fields according to aiMap */
2944 rLhs
= sqlite3GetTempRange(pParse
, nVector
);
2945 for(i
=0; i
<nVector
; i
++){
2946 sqlite3VdbeAddOp3(v
, OP_Copy
, rLhsOrig
+i
, rLhs
+aiMap
[i
], 0);
2950 /* If sqlite3FindInIndex() did not find or create an index that is
2951 ** suitable for evaluating the IN operator, then evaluate using a
2952 ** sequence of comparisons.
2954 ** This is step (1) in the in-operator.md optimized algorithm.
2956 if( eType
==IN_INDEX_NOOP
){
2957 ExprList
*pList
= pExpr
->x
.pList
;
2958 CollSeq
*pColl
= sqlite3ExprCollSeq(pParse
, pExpr
->pLeft
);
2959 int labelOk
= sqlite3VdbeMakeLabel(v
);
2963 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
2964 if( destIfNull
!=destIfFalse
){
2965 regCkNull
= sqlite3GetTempReg(pParse
);
2966 sqlite3VdbeAddOp3(v
, OP_BitAnd
, rLhs
, rLhs
, regCkNull
);
2968 for(ii
=0; ii
<pList
->nExpr
; ii
++){
2969 r2
= sqlite3ExprCodeTemp(pParse
, pList
->a
[ii
].pExpr
, ®ToFree
);
2970 if( regCkNull
&& sqlite3ExprCanBeNull(pList
->a
[ii
].pExpr
) ){
2971 sqlite3VdbeAddOp3(v
, OP_BitAnd
, regCkNull
, r2
, regCkNull
);
2973 if( ii
<pList
->nExpr
-1 || destIfNull
!=destIfFalse
){
2974 sqlite3VdbeAddOp4(v
, OP_Eq
, rLhs
, labelOk
, r2
,
2975 (void*)pColl
, P4_COLLSEQ
);
2976 VdbeCoverageIf(v
, ii
<pList
->nExpr
-1);
2977 VdbeCoverageIf(v
, ii
==pList
->nExpr
-1);
2978 sqlite3VdbeChangeP5(v
, zAff
[0]);
2980 assert( destIfNull
==destIfFalse
);
2981 sqlite3VdbeAddOp4(v
, OP_Ne
, rLhs
, destIfFalse
, r2
,
2982 (void*)pColl
, P4_COLLSEQ
); VdbeCoverage(v
);
2983 sqlite3VdbeChangeP5(v
, zAff
[0] | SQLITE_JUMPIFNULL
);
2985 sqlite3ReleaseTempReg(pParse
, regToFree
);
2988 sqlite3VdbeAddOp2(v
, OP_IsNull
, regCkNull
, destIfNull
); VdbeCoverage(v
);
2989 sqlite3VdbeGoto(v
, destIfFalse
);
2991 sqlite3VdbeResolveLabel(v
, labelOk
);
2992 sqlite3ReleaseTempReg(pParse
, regCkNull
);
2993 goto sqlite3ExprCodeIN_finished
;
2996 /* Step 2: Check to see if the LHS contains any NULL columns. If the
2997 ** LHS does contain NULLs then the result must be either FALSE or NULL.
2998 ** We will then skip the binary search of the RHS.
3000 if( destIfNull
==destIfFalse
){
3001 destStep2
= destIfFalse
;
3003 destStep2
= destStep6
= sqlite3VdbeMakeLabel(v
);
3005 for(i
=0; i
<nVector
; i
++){
3006 Expr
*p
= sqlite3VectorFieldSubexpr(pExpr
->pLeft
, i
);
3007 if( sqlite3ExprCanBeNull(p
) ){
3008 sqlite3VdbeAddOp2(v
, OP_IsNull
, rLhs
+i
, destStep2
);
3013 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3014 ** of the RHS using the LHS as a probe. If found, the result is
3017 if( eType
==IN_INDEX_ROWID
){
3018 /* In this case, the RHS is the ROWID of table b-tree and so we also
3019 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3020 ** into a single opcode. */
3021 sqlite3VdbeAddOp3(v
, OP_SeekRowid
, pExpr
->iTable
, destIfFalse
, rLhs
);
3023 addrTruthOp
= sqlite3VdbeAddOp0(v
, OP_Goto
); /* Return True */
3025 sqlite3VdbeAddOp4(v
, OP_Affinity
, rLhs
, nVector
, 0, zAff
, nVector
);
3026 if( destIfFalse
==destIfNull
){
3027 /* Combine Step 3 and Step 5 into a single opcode */
3028 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, pExpr
->iTable
, destIfFalse
,
3029 rLhs
, nVector
); VdbeCoverage(v
);
3030 goto sqlite3ExprCodeIN_finished
;
3032 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3033 addrTruthOp
= sqlite3VdbeAddOp4Int(v
, OP_Found
, pExpr
->iTable
, 0,
3034 rLhs
, nVector
); VdbeCoverage(v
);
3037 /* Step 4. If the RHS is known to be non-NULL and we did not find
3038 ** an match on the search above, then the result must be FALSE.
3040 if( rRhsHasNull
&& nVector
==1 ){
3041 sqlite3VdbeAddOp2(v
, OP_NotNull
, rRhsHasNull
, destIfFalse
);
3045 /* Step 5. If we do not care about the difference between NULL and
3046 ** FALSE, then just return false.
3048 if( destIfFalse
==destIfNull
) sqlite3VdbeGoto(v
, destIfFalse
);
3050 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3051 ** If any comparison is NULL, then the result is NULL. If all
3052 ** comparisons are FALSE then the final result is FALSE.
3054 ** For a scalar LHS, it is sufficient to check just the first row
3057 if( destStep6
) sqlite3VdbeResolveLabel(v
, destStep6
);
3058 addrTop
= sqlite3VdbeAddOp2(v
, OP_Rewind
, pExpr
->iTable
, destIfFalse
);
3061 destNotNull
= sqlite3VdbeMakeLabel(v
);
3063 /* For nVector==1, combine steps 6 and 7 by immediately returning
3064 ** FALSE if the first comparison is not NULL */
3065 destNotNull
= destIfFalse
;
3067 for(i
=0; i
<nVector
; i
++){
3070 int r3
= sqlite3GetTempReg(pParse
);
3071 p
= sqlite3VectorFieldSubexpr(pLeft
, i
);
3072 pColl
= sqlite3ExprCollSeq(pParse
, p
);
3073 sqlite3VdbeAddOp3(v
, OP_Column
, pExpr
->iTable
, i
, r3
);
3074 sqlite3VdbeAddOp4(v
, OP_Ne
, rLhs
+i
, destNotNull
, r3
,
3075 (void*)pColl
, P4_COLLSEQ
);
3077 sqlite3ReleaseTempReg(pParse
, r3
);
3079 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfNull
);
3081 sqlite3VdbeResolveLabel(v
, destNotNull
);
3082 sqlite3VdbeAddOp2(v
, OP_Next
, pExpr
->iTable
, addrTop
+1);
3085 /* Step 7: If we reach this point, we know that the result must
3087 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, destIfFalse
);
3090 /* Jumps here in order to return true. */
3091 sqlite3VdbeJumpHere(v
, addrTruthOp
);
3093 sqlite3ExprCodeIN_finished
:
3094 if( rLhs
!=rLhsOrig
) sqlite3ReleaseTempReg(pParse
, rLhs
);
3095 sqlite3ExprCachePop(pParse
);
3096 VdbeComment((v
, "end IN expr"));
3097 sqlite3ExprCodeIN_oom_error
:
3098 sqlite3DbFree(pParse
->db
, aiMap
);
3099 sqlite3DbFree(pParse
->db
, zAff
);
3101 #endif /* SQLITE_OMIT_SUBQUERY */
3103 #ifndef SQLITE_OMIT_FLOATING_POINT
3105 ** Generate an instruction that will put the floating point
3106 ** value described by z[0..n-1] into register iMem.
3108 ** The z[] string will probably not be zero-terminated. But the
3109 ** z[n] character is guaranteed to be something that does not look
3110 ** like the continuation of the number.
3112 static void codeReal(Vdbe
*v
, const char *z
, int negateFlag
, int iMem
){
3115 sqlite3AtoF(z
, &value
, sqlite3Strlen30(z
), SQLITE_UTF8
);
3116 assert( !sqlite3IsNaN(value
) ); /* The new AtoF never returns NaN */
3117 if( negateFlag
) value
= -value
;
3118 sqlite3VdbeAddOp4Dup8(v
, OP_Real
, 0, iMem
, 0, (u8
*)&value
, P4_REAL
);
3125 ** Generate an instruction that will put the integer describe by
3126 ** text z[0..n-1] into register iMem.
3128 ** Expr.u.zToken is always UTF8 and zero-terminated.
3130 static void codeInteger(Parse
*pParse
, Expr
*pExpr
, int negFlag
, int iMem
){
3131 Vdbe
*v
= pParse
->pVdbe
;
3132 if( pExpr
->flags
& EP_IntValue
){
3133 int i
= pExpr
->u
.iValue
;
3135 if( negFlag
) i
= -i
;
3136 sqlite3VdbeAddOp2(v
, OP_Integer
, i
, iMem
);
3140 const char *z
= pExpr
->u
.zToken
;
3142 c
= sqlite3DecOrHexToI64(z
, &value
);
3143 if( (c
==3 && !negFlag
) || (c
==2) || (negFlag
&& value
==SMALLEST_INT64
)){
3144 #ifdef SQLITE_OMIT_FLOATING_POINT
3145 sqlite3ErrorMsg(pParse
, "oversized integer: %s%s", negFlag
? "-" : "", z
);
3147 #ifndef SQLITE_OMIT_HEX_INTEGER
3148 if( sqlite3_strnicmp(z
,"0x",2)==0 ){
3149 sqlite3ErrorMsg(pParse
, "hex literal too big: %s%s", negFlag
?"-":"",z
);
3153 codeReal(v
, z
, negFlag
, iMem
);
3157 if( negFlag
){ value
= c
==3 ? SMALLEST_INT64
: -value
; }
3158 sqlite3VdbeAddOp4Dup8(v
, OP_Int64
, 0, iMem
, 0, (u8
*)&value
, P4_INT64
);
3164 ** Erase column-cache entry number i
3166 static void cacheEntryClear(Parse
*pParse
, int i
){
3167 if( pParse
->aColCache
[i
].tempReg
){
3168 if( pParse
->nTempReg
<ArraySize(pParse
->aTempReg
) ){
3169 pParse
->aTempReg
[pParse
->nTempReg
++] = pParse
->aColCache
[i
].iReg
;
3172 pParse
->nColCache
--;
3173 if( i
<pParse
->nColCache
){
3174 pParse
->aColCache
[i
] = pParse
->aColCache
[pParse
->nColCache
];
3180 ** Record in the column cache that a particular column from a
3181 ** particular table is stored in a particular register.
3183 void sqlite3ExprCacheStore(Parse
*pParse
, int iTab
, int iCol
, int iReg
){
3187 struct yColCache
*p
;
3189 /* Unless an error has occurred, register numbers are always positive. */
3190 assert( iReg
>0 || pParse
->nErr
|| pParse
->db
->mallocFailed
);
3191 assert( iCol
>=-1 && iCol
<32768 ); /* Finite column numbers */
3193 /* The SQLITE_ColumnCache flag disables the column cache. This is used
3194 ** for testing only - to verify that SQLite always gets the same answer
3195 ** with and without the column cache.
3197 if( OptimizationDisabled(pParse
->db
, SQLITE_ColumnCache
) ) return;
3199 /* First replace any existing entry.
3201 ** Actually, the way the column cache is currently used, we are guaranteed
3202 ** that the object will never already be in cache. Verify this guarantee.
3205 for(i
=0, p
=pParse
->aColCache
; i
<pParse
->nColCache
; i
++, p
++){
3206 assert( p
->iTable
!=iTab
|| p
->iColumn
!=iCol
);
3210 /* If the cache is already full, delete the least recently used entry */
3211 if( pParse
->nColCache
>=SQLITE_N_COLCACHE
){
3212 minLru
= 0x7fffffff;
3214 for(i
=0, p
=pParse
->aColCache
; i
<SQLITE_N_COLCACHE
; i
++, p
++){
3215 if( p
->lru
<minLru
){
3220 p
= &pParse
->aColCache
[idxLru
];
3222 p
= &pParse
->aColCache
[pParse
->nColCache
++];
3225 /* Add the new entry to the end of the cache */
3226 p
->iLevel
= pParse
->iCacheLevel
;
3231 p
->lru
= pParse
->iCacheCnt
++;
3235 ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
3236 ** Purge the range of registers from the column cache.
3238 void sqlite3ExprCacheRemove(Parse
*pParse
, int iReg
, int nReg
){
3240 while( i
<pParse
->nColCache
){
3241 struct yColCache
*p
= &pParse
->aColCache
[i
];
3242 if( p
->iReg
>= iReg
&& p
->iReg
< iReg
+nReg
){
3243 cacheEntryClear(pParse
, i
);
3251 ** Remember the current column cache context. Any new entries added
3252 ** added to the column cache after this call are removed when the
3253 ** corresponding pop occurs.
3255 void sqlite3ExprCachePush(Parse
*pParse
){
3256 pParse
->iCacheLevel
++;
3258 if( pParse
->db
->flags
& SQLITE_VdbeAddopTrace
){
3259 printf("PUSH to %d\n", pParse
->iCacheLevel
);
3265 ** Remove from the column cache any entries that were added since the
3266 ** the previous sqlite3ExprCachePush operation. In other words, restore
3267 ** the cache to the state it was in prior the most recent Push.
3269 void sqlite3ExprCachePop(Parse
*pParse
){
3271 assert( pParse
->iCacheLevel
>=1 );
3272 pParse
->iCacheLevel
--;
3274 if( pParse
->db
->flags
& SQLITE_VdbeAddopTrace
){
3275 printf("POP to %d\n", pParse
->iCacheLevel
);
3278 while( i
<pParse
->nColCache
){
3279 if( pParse
->aColCache
[i
].iLevel
>pParse
->iCacheLevel
){
3280 cacheEntryClear(pParse
, i
);
3288 ** When a cached column is reused, make sure that its register is
3289 ** no longer available as a temp register. ticket #3879: that same
3290 ** register might be in the cache in multiple places, so be sure to
3293 static void sqlite3ExprCachePinRegister(Parse
*pParse
, int iReg
){
3295 struct yColCache
*p
;
3296 for(i
=0, p
=pParse
->aColCache
; i
<pParse
->nColCache
; i
++, p
++){
3297 if( p
->iReg
==iReg
){
3303 /* Generate code that will load into register regOut a value that is
3304 ** appropriate for the iIdxCol-th column of index pIdx.
3306 void sqlite3ExprCodeLoadIndexColumn(
3307 Parse
*pParse
, /* The parsing context */
3308 Index
*pIdx
, /* The index whose column is to be loaded */
3309 int iTabCur
, /* Cursor pointing to a table row */
3310 int iIdxCol
, /* The column of the index to be loaded */
3311 int regOut
/* Store the index column value in this register */
3313 i16 iTabCol
= pIdx
->aiColumn
[iIdxCol
];
3314 if( iTabCol
==XN_EXPR
){
3315 assert( pIdx
->aColExpr
);
3316 assert( pIdx
->aColExpr
->nExpr
>iIdxCol
);
3317 pParse
->iSelfTab
= iTabCur
+ 1;
3318 sqlite3ExprCodeCopy(pParse
, pIdx
->aColExpr
->a
[iIdxCol
].pExpr
, regOut
);
3319 pParse
->iSelfTab
= 0;
3321 sqlite3ExprCodeGetColumnOfTable(pParse
->pVdbe
, pIdx
->pTable
, iTabCur
,
3327 ** Generate code to extract the value of the iCol-th column of a table.
3329 void sqlite3ExprCodeGetColumnOfTable(
3330 Vdbe
*v
, /* The VDBE under construction */
3331 Table
*pTab
, /* The table containing the value */
3332 int iTabCur
, /* The table cursor. Or the PK cursor for WITHOUT ROWID */
3333 int iCol
, /* Index of the column to extract */
3334 int regOut
/* Extract the value into this register */
3337 sqlite3VdbeAddOp3(v
, OP_Column
, iTabCur
, iCol
, regOut
);
3340 if( iCol
<0 || iCol
==pTab
->iPKey
){
3341 sqlite3VdbeAddOp2(v
, OP_Rowid
, iTabCur
, regOut
);
3343 int op
= IsVirtual(pTab
) ? OP_VColumn
: OP_Column
;
3345 if( !HasRowid(pTab
) && !IsVirtual(pTab
) ){
3346 x
= sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab
), iCol
);
3348 sqlite3VdbeAddOp3(v
, op
, iTabCur
, x
, regOut
);
3351 sqlite3ColumnDefault(v
, pTab
, iCol
, regOut
);
3356 ** Generate code that will extract the iColumn-th column from
3357 ** table pTab and store the column value in a register.
3359 ** An effort is made to store the column value in register iReg. This
3360 ** is not garanteeed for GetColumn() - the result can be stored in
3361 ** any register. But the result is guaranteed to land in register iReg
3362 ** for GetColumnToReg().
3364 ** There must be an open cursor to pTab in iTable when this routine
3365 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3367 int sqlite3ExprCodeGetColumn(
3368 Parse
*pParse
, /* Parsing and code generating context */
3369 Table
*pTab
, /* Description of the table we are reading from */
3370 int iColumn
, /* Index of the table column */
3371 int iTable
, /* The cursor pointing to the table */
3372 int iReg
, /* Store results here */
3373 u8 p5
/* P5 value for OP_Column + FLAGS */
3375 Vdbe
*v
= pParse
->pVdbe
;
3377 struct yColCache
*p
;
3379 for(i
=0, p
=pParse
->aColCache
; i
<pParse
->nColCache
; i
++, p
++){
3380 if( p
->iTable
==iTable
&& p
->iColumn
==iColumn
){
3381 p
->lru
= pParse
->iCacheCnt
++;
3382 sqlite3ExprCachePinRegister(pParse
, p
->iReg
);
3387 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iTable
, iColumn
, iReg
);
3389 sqlite3VdbeChangeP5(v
, p5
);
3391 sqlite3ExprCacheStore(pParse
, iTable
, iColumn
, iReg
);
3395 void sqlite3ExprCodeGetColumnToReg(
3396 Parse
*pParse
, /* Parsing and code generating context */
3397 Table
*pTab
, /* Description of the table we are reading from */
3398 int iColumn
, /* Index of the table column */
3399 int iTable
, /* The cursor pointing to the table */
3400 int iReg
/* Store results here */
3402 int r1
= sqlite3ExprCodeGetColumn(pParse
, pTab
, iColumn
, iTable
, iReg
, 0);
3403 if( r1
!=iReg
) sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_SCopy
, r1
, iReg
);
3408 ** Clear all column cache entries.
3410 void sqlite3ExprCacheClear(Parse
*pParse
){
3414 if( pParse
->db
->flags
& SQLITE_VdbeAddopTrace
){
3418 for(i
=0; i
<pParse
->nColCache
; i
++){
3419 if( pParse
->aColCache
[i
].tempReg
3420 && pParse
->nTempReg
<ArraySize(pParse
->aTempReg
)
3422 pParse
->aTempReg
[pParse
->nTempReg
++] = pParse
->aColCache
[i
].iReg
;
3425 pParse
->nColCache
= 0;
3429 ** Record the fact that an affinity change has occurred on iCount
3430 ** registers starting with iStart.
3432 void sqlite3ExprCacheAffinityChange(Parse
*pParse
, int iStart
, int iCount
){
3433 sqlite3ExprCacheRemove(pParse
, iStart
, iCount
);
3437 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3438 ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
3440 void sqlite3ExprCodeMove(Parse
*pParse
, int iFrom
, int iTo
, int nReg
){
3441 assert( iFrom
>=iTo
+nReg
|| iFrom
+nReg
<=iTo
);
3442 sqlite3VdbeAddOp3(pParse
->pVdbe
, OP_Move
, iFrom
, iTo
, nReg
);
3443 sqlite3ExprCacheRemove(pParse
, iFrom
, nReg
);
3446 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
3448 ** Return true if any register in the range iFrom..iTo (inclusive)
3449 ** is used as part of the column cache.
3451 ** This routine is used within assert() and testcase() macros only
3452 ** and does not appear in a normal build.
3454 static int usedAsColumnCache(Parse
*pParse
, int iFrom
, int iTo
){
3456 struct yColCache
*p
;
3457 for(i
=0, p
=pParse
->aColCache
; i
<pParse
->nColCache
; i
++, p
++){
3459 if( r
>=iFrom
&& r
<=iTo
) return 1; /*NO_TEST*/
3463 #endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
3467 ** Convert a scalar expression node to a TK_REGISTER referencing
3468 ** register iReg. The caller must ensure that iReg already contains
3469 ** the correct value for the expression.
3471 static void exprToRegister(Expr
*p
, int iReg
){
3473 p
->op
= TK_REGISTER
;
3475 ExprClearProperty(p
, EP_Skip
);
3479 ** Evaluate an expression (either a vector or a scalar expression) and store
3480 ** the result in continguous temporary registers. Return the index of
3481 ** the first register used to store the result.
3483 ** If the returned result register is a temporary scalar, then also write
3484 ** that register number into *piFreeable. If the returned result register
3485 ** is not a temporary or if the expression is a vector set *piFreeable
3488 static int exprCodeVector(Parse
*pParse
, Expr
*p
, int *piFreeable
){
3490 int nResult
= sqlite3ExprVectorSize(p
);
3492 iResult
= sqlite3ExprCodeTemp(pParse
, p
, piFreeable
);
3495 if( p
->op
==TK_SELECT
){
3496 #if SQLITE_OMIT_SUBQUERY
3499 iResult
= sqlite3CodeSubselect(pParse
, p
, 0, 0);
3503 iResult
= pParse
->nMem
+1;
3504 pParse
->nMem
+= nResult
;
3505 for(i
=0; i
<nResult
; i
++){
3506 sqlite3ExprCodeFactorable(pParse
, p
->x
.pList
->a
[i
].pExpr
, i
+iResult
);
3515 ** Generate code into the current Vdbe to evaluate the given
3516 ** expression. Attempt to store the results in register "target".
3517 ** Return the register where results are stored.
3519 ** With this routine, there is no guarantee that results will
3520 ** be stored in target. The result might be stored in some other
3521 ** register if it is convenient to do so. The calling function
3522 ** must check the return code and move the results to the desired
3525 int sqlite3ExprCodeTarget(Parse
*pParse
, Expr
*pExpr
, int target
){
3526 Vdbe
*v
= pParse
->pVdbe
; /* The VM under construction */
3527 int op
; /* The opcode being coded */
3528 int inReg
= target
; /* Results stored in register inReg */
3529 int regFree1
= 0; /* If non-zero free this temporary register */
3530 int regFree2
= 0; /* If non-zero free this temporary register */
3531 int r1
, r2
; /* Various register numbers */
3532 Expr tempX
; /* Temporary expression node */
3535 assert( target
>0 && target
<=pParse
->nMem
);
3537 assert( pParse
->db
->mallocFailed
);
3547 case TK_AGG_COLUMN
: {
3548 AggInfo
*pAggInfo
= pExpr
->pAggInfo
;
3549 struct AggInfo_col
*pCol
= &pAggInfo
->aCol
[pExpr
->iAgg
];
3550 if( !pAggInfo
->directMode
){
3551 assert( pCol
->iMem
>0 );
3553 }else if( pAggInfo
->useSortingIdx
){
3554 sqlite3VdbeAddOp3(v
, OP_Column
, pAggInfo
->sortingIdxPTab
,
3555 pCol
->iSorterColumn
, target
);
3558 /* Otherwise, fall thru into the TK_COLUMN case */
3561 int iTab
= pExpr
->iTable
;
3563 if( pParse
->iSelfTab
<0 ){
3564 /* Generating CHECK constraints or inserting into partial index */
3565 return pExpr
->iColumn
- pParse
->iSelfTab
;
3567 /* Coding an expression that is part of an index where column names
3568 ** in the index refer to the table to which the index belongs */
3569 iTab
= pParse
->iSelfTab
- 1;
3572 return sqlite3ExprCodeGetColumn(pParse
, pExpr
->pTab
,
3573 pExpr
->iColumn
, iTab
, target
,
3577 codeInteger(pParse
, pExpr
, 0, target
);
3580 case TK_TRUEFALSE
: {
3581 sqlite3VdbeAddOp2(v
, OP_Integer
, sqlite3ExprTruthValue(pExpr
), target
);
3584 #ifndef SQLITE_OMIT_FLOATING_POINT
3586 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3587 codeReal(v
, pExpr
->u
.zToken
, 0, target
);
3592 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3593 sqlite3VdbeLoadString(v
, target
, pExpr
->u
.zToken
);
3597 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
3600 #ifndef SQLITE_OMIT_BLOB_LITERAL
3605 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3606 assert( pExpr
->u
.zToken
[0]=='x' || pExpr
->u
.zToken
[0]=='X' );
3607 assert( pExpr
->u
.zToken
[1]=='\'' );
3608 z
= &pExpr
->u
.zToken
[2];
3609 n
= sqlite3Strlen30(z
) - 1;
3610 assert( z
[n
]=='\'' );
3611 zBlob
= sqlite3HexToBlob(sqlite3VdbeDb(v
), z
, n
);
3612 sqlite3VdbeAddOp4(v
, OP_Blob
, n
/2, target
, 0, zBlob
, P4_DYNAMIC
);
3617 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3618 assert( pExpr
->u
.zToken
!=0 );
3619 assert( pExpr
->u
.zToken
[0]!=0 );
3620 sqlite3VdbeAddOp2(v
, OP_Variable
, pExpr
->iColumn
, target
);
3621 if( pExpr
->u
.zToken
[1]!=0 ){
3622 const char *z
= sqlite3VListNumToName(pParse
->pVList
, pExpr
->iColumn
);
3623 assert( pExpr
->u
.zToken
[0]=='?' || strcmp(pExpr
->u
.zToken
, z
)==0 );
3624 pParse
->pVList
[0] = 0; /* Indicate VList may no longer be enlarged */
3625 sqlite3VdbeAppendP4(v
, (char*)z
, P4_STATIC
);
3630 return pExpr
->iTable
;
3632 #ifndef SQLITE_OMIT_CAST
3634 /* Expressions of the form: CAST(pLeft AS token) */
3635 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
3636 if( inReg
!=target
){
3637 sqlite3VdbeAddOp2(v
, OP_SCopy
, inReg
, target
);
3640 sqlite3VdbeAddOp2(v
, OP_Cast
, target
,
3641 sqlite3AffinityType(pExpr
->u
.zToken
, 0));
3642 testcase( usedAsColumnCache(pParse
, inReg
, inReg
) );
3643 sqlite3ExprCacheAffinityChange(pParse
, inReg
, 1);
3646 #endif /* SQLITE_OMIT_CAST */
3649 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
3658 Expr
*pLeft
= pExpr
->pLeft
;
3659 if( sqlite3ExprIsVector(pLeft
) ){
3660 codeVectorCompare(pParse
, pExpr
, target
, op
, p5
);
3662 r1
= sqlite3ExprCodeTemp(pParse
, pLeft
, ®Free1
);
3663 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3664 codeCompare(pParse
, pLeft
, pExpr
->pRight
, op
,
3665 r1
, r2
, inReg
, SQLITE_STOREP2
| p5
);
3666 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
3667 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
3668 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
3669 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
3670 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
); VdbeCoverageIf(v
,op
==OP_Eq
);
3671 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
); VdbeCoverageIf(v
,op
==OP_Ne
);
3672 testcase( regFree1
==0 );
3673 testcase( regFree2
==0 );
3689 assert( TK_AND
==OP_And
); testcase( op
==TK_AND
);
3690 assert( TK_OR
==OP_Or
); testcase( op
==TK_OR
);
3691 assert( TK_PLUS
==OP_Add
); testcase( op
==TK_PLUS
);
3692 assert( TK_MINUS
==OP_Subtract
); testcase( op
==TK_MINUS
);
3693 assert( TK_REM
==OP_Remainder
); testcase( op
==TK_REM
);
3694 assert( TK_BITAND
==OP_BitAnd
); testcase( op
==TK_BITAND
);
3695 assert( TK_BITOR
==OP_BitOr
); testcase( op
==TK_BITOR
);
3696 assert( TK_SLASH
==OP_Divide
); testcase( op
==TK_SLASH
);
3697 assert( TK_LSHIFT
==OP_ShiftLeft
); testcase( op
==TK_LSHIFT
);
3698 assert( TK_RSHIFT
==OP_ShiftRight
); testcase( op
==TK_RSHIFT
);
3699 assert( TK_CONCAT
==OP_Concat
); testcase( op
==TK_CONCAT
);
3700 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3701 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
3702 sqlite3VdbeAddOp3(v
, op
, r2
, r1
, target
);
3703 testcase( regFree1
==0 );
3704 testcase( regFree2
==0 );
3708 Expr
*pLeft
= pExpr
->pLeft
;
3710 if( pLeft
->op
==TK_INTEGER
){
3711 codeInteger(pParse
, pLeft
, 1, target
);
3713 #ifndef SQLITE_OMIT_FLOATING_POINT
3714 }else if( pLeft
->op
==TK_FLOAT
){
3715 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3716 codeReal(v
, pLeft
->u
.zToken
, 1, target
);
3720 tempX
.op
= TK_INTEGER
;
3721 tempX
.flags
= EP_IntValue
|EP_TokenOnly
;
3723 r1
= sqlite3ExprCodeTemp(pParse
, &tempX
, ®Free1
);
3724 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free2
);
3725 sqlite3VdbeAddOp3(v
, OP_Subtract
, r2
, r1
, target
);
3726 testcase( regFree2
==0 );
3732 assert( TK_BITNOT
==OP_BitNot
); testcase( op
==TK_BITNOT
);
3733 assert( TK_NOT
==OP_Not
); testcase( op
==TK_NOT
);
3734 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3735 testcase( regFree1
==0 );
3736 sqlite3VdbeAddOp2(v
, op
, r1
, inReg
);
3740 int isTrue
; /* IS TRUE or IS NOT TRUE */
3741 int bNormal
; /* IS TRUE or IS FALSE */
3742 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3743 testcase( regFree1
==0 );
3744 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
3745 bNormal
= pExpr
->op2
==TK_IS
;
3746 testcase( isTrue
&& bNormal
);
3747 testcase( !isTrue
&& bNormal
);
3748 sqlite3VdbeAddOp4Int(v
, OP_IsTrue
, r1
, inReg
, !isTrue
, isTrue
^ bNormal
);
3754 assert( TK_ISNULL
==OP_IsNull
); testcase( op
==TK_ISNULL
);
3755 assert( TK_NOTNULL
==OP_NotNull
); testcase( op
==TK_NOTNULL
);
3756 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
3757 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
3758 testcase( regFree1
==0 );
3759 addr
= sqlite3VdbeAddOp1(v
, op
, r1
);
3760 VdbeCoverageIf(v
, op
==TK_ISNULL
);
3761 VdbeCoverageIf(v
, op
==TK_NOTNULL
);
3762 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, target
);
3763 sqlite3VdbeJumpHere(v
, addr
);
3766 case TK_AGG_FUNCTION
: {
3767 AggInfo
*pInfo
= pExpr
->pAggInfo
;
3769 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3770 sqlite3ErrorMsg(pParse
, "misuse of aggregate: %s()", pExpr
->u
.zToken
);
3772 return pInfo
->aFunc
[pExpr
->iAgg
].iMem
;
3777 ExprList
*pFarg
; /* List of function arguments */
3778 int nFarg
; /* Number of function arguments */
3779 FuncDef
*pDef
; /* The function definition object */
3780 const char *zId
; /* The function name */
3781 u32 constMask
= 0; /* Mask of function arguments that are constant */
3782 int i
; /* Loop counter */
3783 sqlite3
*db
= pParse
->db
; /* The database connection */
3784 u8 enc
= ENC(db
); /* The text encoding used by this database */
3785 CollSeq
*pColl
= 0; /* A collating sequence */
3787 if( ConstFactorOk(pParse
) && sqlite3ExprIsConstantNotJoin(pExpr
) ){
3788 /* SQL functions can be expensive. So try to move constant functions
3789 ** out of the inner loop, even if that means an extra OP_Copy. */
3790 return sqlite3ExprCodeAtInit(pParse
, pExpr
, -1);
3792 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
3793 if( ExprHasProperty(pExpr
, EP_TokenOnly
) ){
3796 pFarg
= pExpr
->x
.pList
;
3798 nFarg
= pFarg
? pFarg
->nExpr
: 0;
3799 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
3800 zId
= pExpr
->u
.zToken
;
3801 pDef
= sqlite3FindFunction(db
, zId
, nFarg
, enc
, 0);
3802 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
3803 if( pDef
==0 && pParse
->explain
){
3804 pDef
= sqlite3FindFunction(db
, "unknown", nFarg
, enc
, 0);
3807 if( pDef
==0 || pDef
->xFinalize
!=0 ){
3808 sqlite3ErrorMsg(pParse
, "unknown function: %s()", zId
);
3812 /* Attempt a direct implementation of the built-in COALESCE() and
3813 ** IFNULL() functions. This avoids unnecessary evaluation of
3814 ** arguments past the first non-NULL argument.
3816 if( pDef
->funcFlags
& SQLITE_FUNC_COALESCE
){
3817 int endCoalesce
= sqlite3VdbeMakeLabel(v
);
3819 sqlite3ExprCode(pParse
, pFarg
->a
[0].pExpr
, target
);
3820 for(i
=1; i
<nFarg
; i
++){
3821 sqlite3VdbeAddOp2(v
, OP_NotNull
, target
, endCoalesce
);
3823 sqlite3ExprCacheRemove(pParse
, target
, 1);
3824 sqlite3ExprCachePush(pParse
);
3825 sqlite3ExprCode(pParse
, pFarg
->a
[i
].pExpr
, target
);
3826 sqlite3ExprCachePop(pParse
);
3828 sqlite3VdbeResolveLabel(v
, endCoalesce
);
3832 /* The UNLIKELY() function is a no-op. The result is the value
3833 ** of the first argument.
3835 if( pDef
->funcFlags
& SQLITE_FUNC_UNLIKELY
){
3837 return sqlite3ExprCodeTarget(pParse
, pFarg
->a
[0].pExpr
, target
);
3841 /* The AFFINITY() function evaluates to a string that describes
3842 ** the type affinity of the argument. This is used for testing of
3843 ** the SQLite type logic.
3845 if( pDef
->funcFlags
& SQLITE_FUNC_AFFINITY
){
3846 const char *azAff
[] = { "blob", "text", "numeric", "integer", "real" };
3849 aff
= sqlite3ExprAffinity(pFarg
->a
[0].pExpr
);
3850 sqlite3VdbeLoadString(v
, target
,
3851 aff
? azAff
[aff
-SQLITE_AFF_BLOB
] : "none");
3856 for(i
=0; i
<nFarg
; i
++){
3857 if( i
<32 && sqlite3ExprIsConstant(pFarg
->a
[i
].pExpr
) ){
3859 constMask
|= MASKBIT32(i
);
3861 if( (pDef
->funcFlags
& SQLITE_FUNC_NEEDCOLL
)!=0 && !pColl
){
3862 pColl
= sqlite3ExprCollSeq(pParse
, pFarg
->a
[i
].pExpr
);
3867 r1
= pParse
->nMem
+1;
3868 pParse
->nMem
+= nFarg
;
3870 r1
= sqlite3GetTempRange(pParse
, nFarg
);
3873 /* For length() and typeof() functions with a column argument,
3874 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
3875 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
3878 if( (pDef
->funcFlags
& (SQLITE_FUNC_LENGTH
|SQLITE_FUNC_TYPEOF
))!=0 ){
3881 assert( pFarg
->a
[0].pExpr
!=0 );
3882 exprOp
= pFarg
->a
[0].pExpr
->op
;
3883 if( exprOp
==TK_COLUMN
|| exprOp
==TK_AGG_COLUMN
){
3884 assert( SQLITE_FUNC_LENGTH
==OPFLAG_LENGTHARG
);
3885 assert( SQLITE_FUNC_TYPEOF
==OPFLAG_TYPEOFARG
);
3886 testcase( pDef
->funcFlags
& OPFLAG_LENGTHARG
);
3887 pFarg
->a
[0].pExpr
->op2
=
3888 pDef
->funcFlags
& (OPFLAG_LENGTHARG
|OPFLAG_TYPEOFARG
);
3892 sqlite3ExprCachePush(pParse
); /* Ticket 2ea2425d34be */
3893 sqlite3ExprCodeExprList(pParse
, pFarg
, r1
, 0,
3894 SQLITE_ECEL_DUP
|SQLITE_ECEL_FACTOR
);
3895 sqlite3ExprCachePop(pParse
); /* Ticket 2ea2425d34be */
3899 #ifndef SQLITE_OMIT_VIRTUALTABLE
3900 /* Possibly overload the function if the first argument is
3901 ** a virtual table column.
3903 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
3904 ** second argument, not the first, as the argument to test to
3905 ** see if it is a column in a virtual table. This is done because
3906 ** the left operand of infix functions (the operand we want to
3907 ** control overloading) ends up as the second argument to the
3908 ** function. The expression "A glob B" is equivalent to
3909 ** "glob(B,A). We want to use the A in "A glob B" to test
3910 ** for function overloading. But we use the B term in "glob(B,A)".
3912 if( nFarg
>=2 && (pExpr
->flags
& EP_InfixFunc
) ){
3913 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[1].pExpr
);
3914 }else if( nFarg
>0 ){
3915 pDef
= sqlite3VtabOverloadFunction(db
, pDef
, nFarg
, pFarg
->a
[0].pExpr
);
3918 if( pDef
->funcFlags
& SQLITE_FUNC_NEEDCOLL
){
3919 if( !pColl
) pColl
= db
->pDfltColl
;
3920 sqlite3VdbeAddOp4(v
, OP_CollSeq
, 0, 0, 0, (char *)pColl
, P4_COLLSEQ
);
3922 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
3923 if( pDef
->funcFlags
& SQLITE_FUNC_OFFSET
){
3924 Expr
*pArg
= pFarg
->a
[0].pExpr
;
3925 if( pArg
->op
==TK_COLUMN
){
3926 sqlite3VdbeAddOp3(v
, OP_Offset
, pArg
->iTable
, pArg
->iColumn
, target
);
3928 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
3933 sqlite3VdbeAddOp4(v
, pParse
->iSelfTab
? OP_PureFunc0
: OP_Function0
,
3934 constMask
, r1
, target
, (char*)pDef
, P4_FUNCDEF
);
3935 sqlite3VdbeChangeP5(v
, (u8
)nFarg
);
3937 if( nFarg
&& constMask
==0 ){
3938 sqlite3ReleaseTempRange(pParse
, r1
, nFarg
);
3942 #ifndef SQLITE_OMIT_SUBQUERY
3946 testcase( op
==TK_EXISTS
);
3947 testcase( op
==TK_SELECT
);
3948 if( op
==TK_SELECT
&& (nCol
= pExpr
->x
.pSelect
->pEList
->nExpr
)!=1 ){
3949 sqlite3SubselectError(pParse
, nCol
, 1);
3951 return sqlite3CodeSubselect(pParse
, pExpr
, 0, 0);
3955 case TK_SELECT_COLUMN
: {
3957 if( pExpr
->pLeft
->iTable
==0 ){
3958 pExpr
->pLeft
->iTable
= sqlite3CodeSubselect(pParse
, pExpr
->pLeft
, 0, 0);
3960 assert( pExpr
->iTable
==0 || pExpr
->pLeft
->op
==TK_SELECT
);
3962 && pExpr
->iTable
!=(n
= sqlite3ExprVectorSize(pExpr
->pLeft
))
3964 sqlite3ErrorMsg(pParse
, "%d columns assigned %d values",
3967 return pExpr
->pLeft
->iTable
+ pExpr
->iColumn
;
3970 int destIfFalse
= sqlite3VdbeMakeLabel(v
);
3971 int destIfNull
= sqlite3VdbeMakeLabel(v
);
3972 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
3973 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
3974 sqlite3VdbeAddOp2(v
, OP_Integer
, 1, target
);
3975 sqlite3VdbeResolveLabel(v
, destIfFalse
);
3976 sqlite3VdbeAddOp2(v
, OP_AddImm
, target
, 0);
3977 sqlite3VdbeResolveLabel(v
, destIfNull
);
3980 #endif /* SQLITE_OMIT_SUBQUERY */
3984 ** x BETWEEN y AND z
3986 ** This is equivalent to
3990 ** X is stored in pExpr->pLeft.
3991 ** Y is stored in pExpr->pList->a[0].pExpr.
3992 ** Z is stored in pExpr->pList->a[1].pExpr.
3995 exprCodeBetween(pParse
, pExpr
, target
, 0, 0);
4001 return sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
4005 /* If the opcode is TK_TRIGGER, then the expression is a reference
4006 ** to a column in the new.* or old.* pseudo-tables available to
4007 ** trigger programs. In this case Expr.iTable is set to 1 for the
4008 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4009 ** is set to the column of the pseudo-table to read, or to -1 to
4010 ** read the rowid field.
4012 ** The expression is implemented using an OP_Param opcode. The p1
4013 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4014 ** to reference another column of the old.* pseudo-table, where
4015 ** i is the index of the column. For a new.rowid reference, p1 is
4016 ** set to (n+1), where n is the number of columns in each pseudo-table.
4017 ** For a reference to any other column in the new.* pseudo-table, p1
4018 ** is set to (n+2+i), where n and i are as defined previously. For
4019 ** example, if the table on which triggers are being fired is
4022 ** CREATE TABLE t1(a, b);
4024 ** Then p1 is interpreted as follows:
4026 ** p1==0 -> old.rowid p1==3 -> new.rowid
4027 ** p1==1 -> old.a p1==4 -> new.a
4028 ** p1==2 -> old.b p1==5 -> new.b
4030 Table
*pTab
= pExpr
->pTab
;
4031 int p1
= pExpr
->iTable
* (pTab
->nCol
+1) + 1 + pExpr
->iColumn
;
4033 assert( pExpr
->iTable
==0 || pExpr
->iTable
==1 );
4034 assert( pExpr
->iColumn
>=-1 && pExpr
->iColumn
<pTab
->nCol
);
4035 assert( pTab
->iPKey
<0 || pExpr
->iColumn
!=pTab
->iPKey
);
4036 assert( p1
>=0 && p1
<(pTab
->nCol
*2+2) );
4038 sqlite3VdbeAddOp2(v
, OP_Param
, p1
, target
);
4039 VdbeComment((v
, "%s.%s -> $%d",
4040 (pExpr
->iTable
? "new" : "old"),
4041 (pExpr
->iColumn
<0 ? "rowid" : pExpr
->pTab
->aCol
[pExpr
->iColumn
].zName
),
4045 #ifndef SQLITE_OMIT_FLOATING_POINT
4046 /* If the column has REAL affinity, it may currently be stored as an
4047 ** integer. Use OP_RealAffinity to make sure it is really real.
4049 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4050 ** floating point when extracting it from the record. */
4051 if( pExpr
->iColumn
>=0
4052 && pTab
->aCol
[pExpr
->iColumn
].affinity
==SQLITE_AFF_REAL
4054 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, target
);
4061 sqlite3ErrorMsg(pParse
, "row value misused");
4065 case TK_IF_NULL_ROW
: {
4067 addrINR
= sqlite3VdbeAddOp1(v
, OP_IfNullRow
, pExpr
->iTable
);
4068 sqlite3ExprCachePush(pParse
);
4069 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
->pLeft
, target
);
4070 sqlite3ExprCachePop(pParse
);
4071 sqlite3VdbeJumpHere(v
, addrINR
);
4072 sqlite3VdbeChangeP3(v
, addrINR
, inReg
);
4078 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4081 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4083 ** Form A is can be transformed into the equivalent form B as follows:
4084 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4085 ** WHEN x=eN THEN rN ELSE y END
4087 ** X (if it exists) is in pExpr->pLeft.
4088 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4089 ** odd. The Y is also optional. If the number of elements in x.pList
4090 ** is even, then Y is omitted and the "otherwise" result is NULL.
4091 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4093 ** The result of the expression is the Ri for the first matching Ei,
4094 ** or if there is no matching Ei, the ELSE term Y, or if there is
4095 ** no ELSE term, NULL.
4097 default: assert( op
==TK_CASE
); {
4098 int endLabel
; /* GOTO label for end of CASE stmt */
4099 int nextCase
; /* GOTO label for next WHEN clause */
4100 int nExpr
; /* 2x number of WHEN terms */
4101 int i
; /* Loop counter */
4102 ExprList
*pEList
; /* List of WHEN terms */
4103 struct ExprList_item
*aListelem
; /* Array of WHEN terms */
4104 Expr opCompare
; /* The X==Ei expression */
4105 Expr
*pX
; /* The X expression */
4106 Expr
*pTest
= 0; /* X==Ei (form A) or just Ei (form B) */
4107 VVA_ONLY( int iCacheLevel
= pParse
->iCacheLevel
; )
4109 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) && pExpr
->x
.pList
);
4110 assert(pExpr
->x
.pList
->nExpr
> 0);
4111 pEList
= pExpr
->x
.pList
;
4112 aListelem
= pEList
->a
;
4113 nExpr
= pEList
->nExpr
;
4114 endLabel
= sqlite3VdbeMakeLabel(v
);
4115 if( (pX
= pExpr
->pLeft
)!=0 ){
4117 testcase( pX
->op
==TK_COLUMN
);
4118 exprToRegister(&tempX
, exprCodeVector(pParse
, &tempX
, ®Free1
));
4119 testcase( regFree1
==0 );
4120 memset(&opCompare
, 0, sizeof(opCompare
));
4121 opCompare
.op
= TK_EQ
;
4122 opCompare
.pLeft
= &tempX
;
4124 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4125 ** The value in regFree1 might get SCopy-ed into the file result.
4126 ** So make sure that the regFree1 register is not reused for other
4127 ** purposes and possibly overwritten. */
4130 for(i
=0; i
<nExpr
-1; i
=i
+2){
4131 sqlite3ExprCachePush(pParse
);
4134 opCompare
.pRight
= aListelem
[i
].pExpr
;
4136 pTest
= aListelem
[i
].pExpr
;
4138 nextCase
= sqlite3VdbeMakeLabel(v
);
4139 testcase( pTest
->op
==TK_COLUMN
);
4140 sqlite3ExprIfFalse(pParse
, pTest
, nextCase
, SQLITE_JUMPIFNULL
);
4141 testcase( aListelem
[i
+1].pExpr
->op
==TK_COLUMN
);
4142 sqlite3ExprCode(pParse
, aListelem
[i
+1].pExpr
, target
);
4143 sqlite3VdbeGoto(v
, endLabel
);
4144 sqlite3ExprCachePop(pParse
);
4145 sqlite3VdbeResolveLabel(v
, nextCase
);
4148 sqlite3ExprCachePush(pParse
);
4149 sqlite3ExprCode(pParse
, pEList
->a
[nExpr
-1].pExpr
, target
);
4150 sqlite3ExprCachePop(pParse
);
4152 sqlite3VdbeAddOp2(v
, OP_Null
, 0, target
);
4154 assert( pParse
->db
->mallocFailed
|| pParse
->nErr
>0
4155 || pParse
->iCacheLevel
==iCacheLevel
);
4156 sqlite3VdbeResolveLabel(v
, endLabel
);
4159 #ifndef SQLITE_OMIT_TRIGGER
4161 assert( pExpr
->affinity
==OE_Rollback
4162 || pExpr
->affinity
==OE_Abort
4163 || pExpr
->affinity
==OE_Fail
4164 || pExpr
->affinity
==OE_Ignore
4166 if( !pParse
->pTriggerTab
){
4167 sqlite3ErrorMsg(pParse
,
4168 "RAISE() may only be used within a trigger-program");
4171 if( pExpr
->affinity
==OE_Abort
){
4172 sqlite3MayAbort(pParse
);
4174 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
4175 if( pExpr
->affinity
==OE_Ignore
){
4177 v
, OP_Halt
, SQLITE_OK
, OE_Ignore
, 0, pExpr
->u
.zToken
,0);
4180 sqlite3HaltConstraint(pParse
, SQLITE_CONSTRAINT_TRIGGER
,
4181 pExpr
->affinity
, pExpr
->u
.zToken
, 0, 0);
4188 sqlite3ReleaseTempReg(pParse
, regFree1
);
4189 sqlite3ReleaseTempReg(pParse
, regFree2
);
4194 ** Factor out the code of the given expression to initialization time.
4196 ** If regDest>=0 then the result is always stored in that register and the
4197 ** result is not reusable. If regDest<0 then this routine is free to
4198 ** store the value whereever it wants. The register where the expression
4199 ** is stored is returned. When regDest<0, two identical expressions will
4200 ** code to the same register.
4202 int sqlite3ExprCodeAtInit(
4203 Parse
*pParse
, /* Parsing context */
4204 Expr
*pExpr
, /* The expression to code when the VDBE initializes */
4205 int regDest
/* Store the value in this register */
4208 assert( ConstFactorOk(pParse
) );
4209 p
= pParse
->pConstExpr
;
4210 if( regDest
<0 && p
){
4211 struct ExprList_item
*pItem
;
4213 for(pItem
=p
->a
, i
=p
->nExpr
; i
>0; pItem
++, i
--){
4214 if( pItem
->reusable
&& sqlite3ExprCompare(0,pItem
->pExpr
,pExpr
,-1)==0 ){
4215 return pItem
->u
.iConstExprReg
;
4219 pExpr
= sqlite3ExprDup(pParse
->db
, pExpr
, 0);
4220 p
= sqlite3ExprListAppend(pParse
, p
, pExpr
);
4222 struct ExprList_item
*pItem
= &p
->a
[p
->nExpr
-1];
4223 pItem
->reusable
= regDest
<0;
4224 if( regDest
<0 ) regDest
= ++pParse
->nMem
;
4225 pItem
->u
.iConstExprReg
= regDest
;
4227 pParse
->pConstExpr
= p
;
4232 ** Generate code to evaluate an expression and store the results
4233 ** into a register. Return the register number where the results
4236 ** If the register is a temporary register that can be deallocated,
4237 ** then write its number into *pReg. If the result register is not
4238 ** a temporary, then set *pReg to zero.
4240 ** If pExpr is a constant, then this routine might generate this
4241 ** code to fill the register in the initialization section of the
4242 ** VDBE program, in order to factor it out of the evaluation loop.
4244 int sqlite3ExprCodeTemp(Parse
*pParse
, Expr
*pExpr
, int *pReg
){
4246 pExpr
= sqlite3ExprSkipCollate(pExpr
);
4247 if( ConstFactorOk(pParse
)
4248 && pExpr
->op
!=TK_REGISTER
4249 && sqlite3ExprIsConstantNotJoin(pExpr
)
4252 r2
= sqlite3ExprCodeAtInit(pParse
, pExpr
, -1);
4254 int r1
= sqlite3GetTempReg(pParse
);
4255 r2
= sqlite3ExprCodeTarget(pParse
, pExpr
, r1
);
4259 sqlite3ReleaseTempReg(pParse
, r1
);
4267 ** Generate code that will evaluate expression pExpr and store the
4268 ** results in register target. The results are guaranteed to appear
4269 ** in register target.
4271 void sqlite3ExprCode(Parse
*pParse
, Expr
*pExpr
, int target
){
4274 assert( target
>0 && target
<=pParse
->nMem
);
4275 if( pExpr
&& pExpr
->op
==TK_REGISTER
){
4276 sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_Copy
, pExpr
->iTable
, target
);
4278 inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
);
4279 assert( pParse
->pVdbe
!=0 || pParse
->db
->mallocFailed
);
4280 if( inReg
!=target
&& pParse
->pVdbe
){
4281 sqlite3VdbeAddOp2(pParse
->pVdbe
, OP_SCopy
, inReg
, target
);
4287 ** Make a transient copy of expression pExpr and then code it using
4288 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
4289 ** except that the input expression is guaranteed to be unchanged.
4291 void sqlite3ExprCodeCopy(Parse
*pParse
, Expr
*pExpr
, int target
){
4292 sqlite3
*db
= pParse
->db
;
4293 pExpr
= sqlite3ExprDup(db
, pExpr
, 0);
4294 if( !db
->mallocFailed
) sqlite3ExprCode(pParse
, pExpr
, target
);
4295 sqlite3ExprDelete(db
, pExpr
);
4299 ** Generate code that will evaluate expression pExpr and store the
4300 ** results in register target. The results are guaranteed to appear
4301 ** in register target. If the expression is constant, then this routine
4302 ** might choose to code the expression at initialization time.
4304 void sqlite3ExprCodeFactorable(Parse
*pParse
, Expr
*pExpr
, int target
){
4305 if( pParse
->okConstFactor
&& sqlite3ExprIsConstant(pExpr
) ){
4306 sqlite3ExprCodeAtInit(pParse
, pExpr
, target
);
4308 sqlite3ExprCode(pParse
, pExpr
, target
);
4313 ** Generate code that evaluates the given expression and puts the result
4314 ** in register target.
4316 ** Also make a copy of the expression results into another "cache" register
4317 ** and modify the expression so that the next time it is evaluated,
4318 ** the result is a copy of the cache register.
4320 ** This routine is used for expressions that are used multiple
4321 ** times. They are evaluated once and the results of the expression
4324 void sqlite3ExprCodeAndCache(Parse
*pParse
, Expr
*pExpr
, int target
){
4325 Vdbe
*v
= pParse
->pVdbe
;
4329 assert( pExpr
->op
!=TK_REGISTER
);
4330 sqlite3ExprCode(pParse
, pExpr
, target
);
4331 iMem
= ++pParse
->nMem
;
4332 sqlite3VdbeAddOp2(v
, OP_Copy
, target
, iMem
);
4333 exprToRegister(pExpr
, iMem
);
4337 ** Generate code that pushes the value of every element of the given
4338 ** expression list into a sequence of registers beginning at target.
4340 ** Return the number of elements evaluated. The number returned will
4341 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
4344 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
4345 ** filled using OP_SCopy. OP_Copy must be used instead.
4347 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
4348 ** factored out into initialization code.
4350 ** The SQLITE_ECEL_REF flag means that expressions in the list with
4351 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
4352 ** in registers at srcReg, and so the value can be copied from there.
4353 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
4354 ** are simply omitted rather than being copied from srcReg.
4356 int sqlite3ExprCodeExprList(
4357 Parse
*pParse
, /* Parsing context */
4358 ExprList
*pList
, /* The expression list to be coded */
4359 int target
, /* Where to write results */
4360 int srcReg
, /* Source registers if SQLITE_ECEL_REF */
4361 u8 flags
/* SQLITE_ECEL_* flags */
4363 struct ExprList_item
*pItem
;
4365 u8 copyOp
= (flags
& SQLITE_ECEL_DUP
) ? OP_Copy
: OP_SCopy
;
4366 Vdbe
*v
= pParse
->pVdbe
;
4369 assert( pParse
->pVdbe
!=0 ); /* Never gets this far otherwise */
4371 if( !ConstFactorOk(pParse
) ) flags
&= ~SQLITE_ECEL_FACTOR
;
4372 for(pItem
=pList
->a
, i
=0; i
<n
; i
++, pItem
++){
4373 Expr
*pExpr
= pItem
->pExpr
;
4374 if( (flags
& SQLITE_ECEL_REF
)!=0 && (j
= pItem
->u
.x
.iOrderByCol
)>0 ){
4375 if( flags
& SQLITE_ECEL_OMITREF
){
4379 sqlite3VdbeAddOp2(v
, copyOp
, j
+srcReg
-1, target
+i
);
4381 }else if( (flags
& SQLITE_ECEL_FACTOR
)!=0 && sqlite3ExprIsConstant(pExpr
) ){
4382 sqlite3ExprCodeAtInit(pParse
, pExpr
, target
+i
);
4384 int inReg
= sqlite3ExprCodeTarget(pParse
, pExpr
, target
+i
);
4385 if( inReg
!=target
+i
){
4388 && (pOp
=sqlite3VdbeGetOp(v
, -1))->opcode
==OP_Copy
4389 && pOp
->p1
+pOp
->p3
+1==inReg
4390 && pOp
->p2
+pOp
->p3
+1==target
+i
4394 sqlite3VdbeAddOp2(v
, copyOp
, inReg
, target
+i
);
4403 ** Generate code for a BETWEEN operator.
4405 ** x BETWEEN y AND z
4407 ** The above is equivalent to
4411 ** Code it as such, taking care to do the common subexpression
4412 ** elimination of x.
4414 ** The xJumpIf parameter determines details:
4416 ** NULL: Store the boolean result in reg[dest]
4417 ** sqlite3ExprIfTrue: Jump to dest if true
4418 ** sqlite3ExprIfFalse: Jump to dest if false
4420 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
4422 static void exprCodeBetween(
4423 Parse
*pParse
, /* Parsing and code generating context */
4424 Expr
*pExpr
, /* The BETWEEN expression */
4425 int dest
, /* Jump destination or storage location */
4426 void (*xJump
)(Parse
*,Expr
*,int,int), /* Action to take */
4427 int jumpIfNull
/* Take the jump if the BETWEEN is NULL */
4429 Expr exprAnd
; /* The AND operator in x>=y AND x<=z */
4430 Expr compLeft
; /* The x>=y term */
4431 Expr compRight
; /* The x<=z term */
4432 Expr exprX
; /* The x subexpression */
4433 int regFree1
= 0; /* Temporary use register */
4436 memset(&compLeft
, 0, sizeof(Expr
));
4437 memset(&compRight
, 0, sizeof(Expr
));
4438 memset(&exprAnd
, 0, sizeof(Expr
));
4440 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
4441 exprX
= *pExpr
->pLeft
;
4442 exprAnd
.op
= TK_AND
;
4443 exprAnd
.pLeft
= &compLeft
;
4444 exprAnd
.pRight
= &compRight
;
4445 compLeft
.op
= TK_GE
;
4446 compLeft
.pLeft
= &exprX
;
4447 compLeft
.pRight
= pExpr
->x
.pList
->a
[0].pExpr
;
4448 compRight
.op
= TK_LE
;
4449 compRight
.pLeft
= &exprX
;
4450 compRight
.pRight
= pExpr
->x
.pList
->a
[1].pExpr
;
4451 exprToRegister(&exprX
, exprCodeVector(pParse
, &exprX
, ®Free1
));
4453 xJump(pParse
, &exprAnd
, dest
, jumpIfNull
);
4455 /* Mark the expression is being from the ON or USING clause of a join
4456 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
4457 ** it into the Parse.pConstExpr list. We should use a new bit for this,
4458 ** for clarity, but we are out of bits in the Expr.flags field so we
4459 ** have to reuse the EP_FromJoin bit. Bummer. */
4460 exprX
.flags
|= EP_FromJoin
;
4461 sqlite3ExprCodeTarget(pParse
, &exprAnd
, dest
);
4463 sqlite3ReleaseTempReg(pParse
, regFree1
);
4465 /* Ensure adequate test coverage */
4466 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
==0 && regFree1
==0 );
4467 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
==0 && regFree1
!=0 );
4468 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
!=0 && regFree1
==0 );
4469 testcase( xJump
==sqlite3ExprIfTrue
&& jumpIfNull
!=0 && regFree1
!=0 );
4470 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
==0 && regFree1
==0 );
4471 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
==0 && regFree1
!=0 );
4472 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
!=0 && regFree1
==0 );
4473 testcase( xJump
==sqlite3ExprIfFalse
&& jumpIfNull
!=0 && regFree1
!=0 );
4474 testcase( xJump
==0 );
4478 ** Generate code for a boolean expression such that a jump is made
4479 ** to the label "dest" if the expression is true but execution
4480 ** continues straight thru if the expression is false.
4482 ** If the expression evaluates to NULL (neither true nor false), then
4483 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
4485 ** This code depends on the fact that certain token values (ex: TK_EQ)
4486 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
4487 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
4488 ** the make process cause these values to align. Assert()s in the code
4489 ** below verify that the numbers are aligned correctly.
4491 void sqlite3ExprIfTrue(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
4492 Vdbe
*v
= pParse
->pVdbe
;
4498 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
4499 if( NEVER(v
==0) ) return; /* Existence of VDBE checked by caller */
4500 if( NEVER(pExpr
==0) ) return; /* No way this can happen */
4504 int d2
= sqlite3VdbeMakeLabel(v
);
4505 testcase( jumpIfNull
==0 );
4506 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, d2
,jumpIfNull
^SQLITE_JUMPIFNULL
);
4507 sqlite3ExprCachePush(pParse
);
4508 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
4509 sqlite3VdbeResolveLabel(v
, d2
);
4510 sqlite3ExprCachePop(pParse
);
4514 testcase( jumpIfNull
==0 );
4515 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
4516 sqlite3ExprCachePush(pParse
);
4517 sqlite3ExprIfTrue(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
4518 sqlite3ExprCachePop(pParse
);
4522 testcase( jumpIfNull
==0 );
4523 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
4527 int isNot
; /* IS NOT TRUE or IS NOT FALSE */
4528 int isTrue
; /* IS TRUE or IS NOT TRUE */
4529 testcase( jumpIfNull
==0 );
4530 isNot
= pExpr
->op2
==TK_ISNOT
;
4531 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
4532 testcase( isTrue
&& isNot
);
4533 testcase( !isTrue
&& isNot
);
4534 if( isTrue
^ isNot
){
4535 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
,
4536 isNot
? SQLITE_JUMPIFNULL
: 0);
4538 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
,
4539 isNot
? SQLITE_JUMPIFNULL
: 0);
4545 testcase( op
==TK_IS
);
4546 testcase( op
==TK_ISNOT
);
4547 op
= (op
==TK_IS
) ? TK_EQ
: TK_NE
;
4548 jumpIfNull
= SQLITE_NULLEQ
;
4556 if( sqlite3ExprIsVector(pExpr
->pLeft
) ) goto default_expr
;
4557 testcase( jumpIfNull
==0 );
4558 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4559 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
4560 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
4561 r1
, r2
, dest
, jumpIfNull
);
4562 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
4563 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
4564 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
4565 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
4566 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
);
4567 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
==SQLITE_NULLEQ
);
4568 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
!=SQLITE_NULLEQ
);
4569 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
);
4570 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
==SQLITE_NULLEQ
);
4571 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
!=SQLITE_NULLEQ
);
4572 testcase( regFree1
==0 );
4573 testcase( regFree2
==0 );
4578 assert( TK_ISNULL
==OP_IsNull
); testcase( op
==TK_ISNULL
);
4579 assert( TK_NOTNULL
==OP_NotNull
); testcase( op
==TK_NOTNULL
);
4580 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4581 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
4582 VdbeCoverageIf(v
, op
==TK_ISNULL
);
4583 VdbeCoverageIf(v
, op
==TK_NOTNULL
);
4584 testcase( regFree1
==0 );
4588 testcase( jumpIfNull
==0 );
4589 exprCodeBetween(pParse
, pExpr
, dest
, sqlite3ExprIfTrue
, jumpIfNull
);
4592 #ifndef SQLITE_OMIT_SUBQUERY
4594 int destIfFalse
= sqlite3VdbeMakeLabel(v
);
4595 int destIfNull
= jumpIfNull
? dest
: destIfFalse
;
4596 sqlite3ExprCodeIN(pParse
, pExpr
, destIfFalse
, destIfNull
);
4597 sqlite3VdbeGoto(v
, dest
);
4598 sqlite3VdbeResolveLabel(v
, destIfFalse
);
4604 if( exprAlwaysTrue(pExpr
) ){
4605 sqlite3VdbeGoto(v
, dest
);
4606 }else if( exprAlwaysFalse(pExpr
) ){
4609 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
4610 sqlite3VdbeAddOp3(v
, OP_If
, r1
, dest
, jumpIfNull
!=0);
4612 testcase( regFree1
==0 );
4613 testcase( jumpIfNull
==0 );
4618 sqlite3ReleaseTempReg(pParse
, regFree1
);
4619 sqlite3ReleaseTempReg(pParse
, regFree2
);
4623 ** Generate code for a boolean expression such that a jump is made
4624 ** to the label "dest" if the expression is false but execution
4625 ** continues straight thru if the expression is true.
4627 ** If the expression evaluates to NULL (neither true nor false) then
4628 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
4631 void sqlite3ExprIfFalse(Parse
*pParse
, Expr
*pExpr
, int dest
, int jumpIfNull
){
4632 Vdbe
*v
= pParse
->pVdbe
;
4638 assert( jumpIfNull
==SQLITE_JUMPIFNULL
|| jumpIfNull
==0 );
4639 if( NEVER(v
==0) ) return; /* Existence of VDBE checked by caller */
4640 if( pExpr
==0 ) return;
4642 /* The value of pExpr->op and op are related as follows:
4645 ** --------- ----------
4646 ** TK_ISNULL OP_NotNull
4647 ** TK_NOTNULL OP_IsNull
4655 ** For other values of pExpr->op, op is undefined and unused.
4656 ** The value of TK_ and OP_ constants are arranged such that we
4657 ** can compute the mapping above using the following expression.
4658 ** Assert()s verify that the computation is correct.
4660 op
= ((pExpr
->op
+(TK_ISNULL
&1))^1)-(TK_ISNULL
&1);
4662 /* Verify correct alignment of TK_ and OP_ constants
4664 assert( pExpr
->op
!=TK_ISNULL
|| op
==OP_NotNull
);
4665 assert( pExpr
->op
!=TK_NOTNULL
|| op
==OP_IsNull
);
4666 assert( pExpr
->op
!=TK_NE
|| op
==OP_Eq
);
4667 assert( pExpr
->op
!=TK_EQ
|| op
==OP_Ne
);
4668 assert( pExpr
->op
!=TK_LT
|| op
==OP_Ge
);
4669 assert( pExpr
->op
!=TK_LE
|| op
==OP_Gt
);
4670 assert( pExpr
->op
!=TK_GT
|| op
==OP_Le
);
4671 assert( pExpr
->op
!=TK_GE
|| op
==OP_Lt
);
4673 switch( pExpr
->op
){
4675 testcase( jumpIfNull
==0 );
4676 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
4677 sqlite3ExprCachePush(pParse
);
4678 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
4679 sqlite3ExprCachePop(pParse
);
4683 int d2
= sqlite3VdbeMakeLabel(v
);
4684 testcase( jumpIfNull
==0 );
4685 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, d2
, jumpIfNull
^SQLITE_JUMPIFNULL
);
4686 sqlite3ExprCachePush(pParse
);
4687 sqlite3ExprIfFalse(pParse
, pExpr
->pRight
, dest
, jumpIfNull
);
4688 sqlite3VdbeResolveLabel(v
, d2
);
4689 sqlite3ExprCachePop(pParse
);
4693 testcase( jumpIfNull
==0 );
4694 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
, jumpIfNull
);
4698 int isNot
; /* IS NOT TRUE or IS NOT FALSE */
4699 int isTrue
; /* IS TRUE or IS NOT TRUE */
4700 testcase( jumpIfNull
==0 );
4701 isNot
= pExpr
->op2
==TK_ISNOT
;
4702 isTrue
= sqlite3ExprTruthValue(pExpr
->pRight
);
4703 testcase( isTrue
&& isNot
);
4704 testcase( !isTrue
&& isNot
);
4705 if( isTrue
^ isNot
){
4706 /* IS TRUE and IS NOT FALSE */
4707 sqlite3ExprIfFalse(pParse
, pExpr
->pLeft
, dest
,
4708 isNot
? 0 : SQLITE_JUMPIFNULL
);
4711 /* IS FALSE and IS NOT TRUE */
4712 sqlite3ExprIfTrue(pParse
, pExpr
->pLeft
, dest
,
4713 isNot
? 0 : SQLITE_JUMPIFNULL
);
4719 testcase( pExpr
->op
==TK_IS
);
4720 testcase( pExpr
->op
==TK_ISNOT
);
4721 op
= (pExpr
->op
==TK_IS
) ? TK_NE
: TK_EQ
;
4722 jumpIfNull
= SQLITE_NULLEQ
;
4730 if( sqlite3ExprIsVector(pExpr
->pLeft
) ) goto default_expr
;
4731 testcase( jumpIfNull
==0 );
4732 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4733 r2
= sqlite3ExprCodeTemp(pParse
, pExpr
->pRight
, ®Free2
);
4734 codeCompare(pParse
, pExpr
->pLeft
, pExpr
->pRight
, op
,
4735 r1
, r2
, dest
, jumpIfNull
);
4736 assert(TK_LT
==OP_Lt
); testcase(op
==OP_Lt
); VdbeCoverageIf(v
,op
==OP_Lt
);
4737 assert(TK_LE
==OP_Le
); testcase(op
==OP_Le
); VdbeCoverageIf(v
,op
==OP_Le
);
4738 assert(TK_GT
==OP_Gt
); testcase(op
==OP_Gt
); VdbeCoverageIf(v
,op
==OP_Gt
);
4739 assert(TK_GE
==OP_Ge
); testcase(op
==OP_Ge
); VdbeCoverageIf(v
,op
==OP_Ge
);
4740 assert(TK_EQ
==OP_Eq
); testcase(op
==OP_Eq
);
4741 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
!=SQLITE_NULLEQ
);
4742 VdbeCoverageIf(v
, op
==OP_Eq
&& jumpIfNull
==SQLITE_NULLEQ
);
4743 assert(TK_NE
==OP_Ne
); testcase(op
==OP_Ne
);
4744 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
!=SQLITE_NULLEQ
);
4745 VdbeCoverageIf(v
, op
==OP_Ne
&& jumpIfNull
==SQLITE_NULLEQ
);
4746 testcase( regFree1
==0 );
4747 testcase( regFree2
==0 );
4752 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
->pLeft
, ®Free1
);
4753 sqlite3VdbeAddOp2(v
, op
, r1
, dest
);
4754 testcase( op
==TK_ISNULL
); VdbeCoverageIf(v
, op
==TK_ISNULL
);
4755 testcase( op
==TK_NOTNULL
); VdbeCoverageIf(v
, op
==TK_NOTNULL
);
4756 testcase( regFree1
==0 );
4760 testcase( jumpIfNull
==0 );
4761 exprCodeBetween(pParse
, pExpr
, dest
, sqlite3ExprIfFalse
, jumpIfNull
);
4764 #ifndef SQLITE_OMIT_SUBQUERY
4767 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, dest
);
4769 int destIfNull
= sqlite3VdbeMakeLabel(v
);
4770 sqlite3ExprCodeIN(pParse
, pExpr
, dest
, destIfNull
);
4771 sqlite3VdbeResolveLabel(v
, destIfNull
);
4778 if( exprAlwaysFalse(pExpr
) ){
4779 sqlite3VdbeGoto(v
, dest
);
4780 }else if( exprAlwaysTrue(pExpr
) ){
4783 r1
= sqlite3ExprCodeTemp(pParse
, pExpr
, ®Free1
);
4784 sqlite3VdbeAddOp3(v
, OP_IfNot
, r1
, dest
, jumpIfNull
!=0);
4786 testcase( regFree1
==0 );
4787 testcase( jumpIfNull
==0 );
4792 sqlite3ReleaseTempReg(pParse
, regFree1
);
4793 sqlite3ReleaseTempReg(pParse
, regFree2
);
4797 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
4798 ** code generation, and that copy is deleted after code generation. This
4799 ** ensures that the original pExpr is unchanged.
4801 void sqlite3ExprIfFalseDup(Parse
*pParse
, Expr
*pExpr
, int dest
,int jumpIfNull
){
4802 sqlite3
*db
= pParse
->db
;
4803 Expr
*pCopy
= sqlite3ExprDup(db
, pExpr
, 0);
4804 if( db
->mallocFailed
==0 ){
4805 sqlite3ExprIfFalse(pParse
, pCopy
, dest
, jumpIfNull
);
4807 sqlite3ExprDelete(db
, pCopy
);
4811 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
4812 ** type of expression.
4814 ** If pExpr is a simple SQL value - an integer, real, string, blob
4815 ** or NULL value - then the VDBE currently being prepared is configured
4816 ** to re-prepare each time a new value is bound to variable pVar.
4818 ** Additionally, if pExpr is a simple SQL value and the value is the
4819 ** same as that currently bound to variable pVar, non-zero is returned.
4820 ** Otherwise, if the values are not the same or if pExpr is not a simple
4821 ** SQL value, zero is returned.
4823 static int exprCompareVariable(Parse
*pParse
, Expr
*pVar
, Expr
*pExpr
){
4826 sqlite3_value
*pL
, *pR
= 0;
4828 sqlite3ValueFromExpr(pParse
->db
, pExpr
, SQLITE_UTF8
, SQLITE_AFF_BLOB
, &pR
);
4830 iVar
= pVar
->iColumn
;
4831 sqlite3VdbeSetVarmask(pParse
->pVdbe
, iVar
);
4832 pL
= sqlite3VdbeGetBoundValue(pParse
->pReprepare
, iVar
, SQLITE_AFF_BLOB
);
4834 if( sqlite3_value_type(pL
)==SQLITE_TEXT
){
4835 sqlite3_value_text(pL
); /* Make sure the encoding is UTF-8 */
4837 res
= 0==sqlite3MemCompare(pL
, pR
, 0);
4839 sqlite3ValueFree(pR
);
4840 sqlite3ValueFree(pL
);
4847 ** Do a deep comparison of two expression trees. Return 0 if the two
4848 ** expressions are completely identical. Return 1 if they differ only
4849 ** by a COLLATE operator at the top level. Return 2 if there are differences
4850 ** other than the top-level COLLATE operator.
4852 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
4853 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
4855 ** The pA side might be using TK_REGISTER. If that is the case and pB is
4856 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
4858 ** Sometimes this routine will return 2 even if the two expressions
4859 ** really are equivalent. If we cannot prove that the expressions are
4860 ** identical, we return 2 just to be safe. So if this routine
4861 ** returns 2, then you do not really know for certain if the two
4862 ** expressions are the same. But if you get a 0 or 1 return, then you
4863 ** can be sure the expressions are the same. In the places where
4864 ** this routine is used, it does not hurt to get an extra 2 - that
4865 ** just might result in some slightly slower code. But returning
4866 ** an incorrect 0 or 1 could lead to a malfunction.
4868 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
4869 ** pParse->pReprepare can be matched against literals in pB. The
4870 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
4871 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
4872 ** Argument pParse should normally be NULL. If it is not NULL and pA or
4873 ** pB causes a return value of 2.
4875 int sqlite3ExprCompare(Parse
*pParse
, Expr
*pA
, Expr
*pB
, int iTab
){
4877 if( pA
==0 || pB
==0 ){
4878 return pB
==pA
? 0 : 2;
4880 if( pParse
&& pA
->op
==TK_VARIABLE
&& exprCompareVariable(pParse
, pA
, pB
) ){
4883 combinedFlags
= pA
->flags
| pB
->flags
;
4884 if( combinedFlags
& EP_IntValue
){
4885 if( (pA
->flags
&pB
->flags
&EP_IntValue
)!=0 && pA
->u
.iValue
==pB
->u
.iValue
){
4890 if( pA
->op
!=pB
->op
){
4891 if( pA
->op
==TK_COLLATE
&& sqlite3ExprCompare(pParse
, pA
->pLeft
,pB
,iTab
)<2 ){
4894 if( pB
->op
==TK_COLLATE
&& sqlite3ExprCompare(pParse
, pA
,pB
->pLeft
,iTab
)<2 ){
4899 if( pA
->op
!=TK_COLUMN
&& pA
->op
!=TK_AGG_COLUMN
&& pA
->u
.zToken
){
4900 if( pA
->op
==TK_FUNCTION
){
4901 if( sqlite3StrICmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0 ) return 2;
4902 }else if( strcmp(pA
->u
.zToken
,pB
->u
.zToken
)!=0 ){
4903 return pA
->op
==TK_COLLATE
? 1 : 2;
4906 if( (pA
->flags
& EP_Distinct
)!=(pB
->flags
& EP_Distinct
) ) return 2;
4907 if( ALWAYS((combinedFlags
& EP_TokenOnly
)==0) ){
4908 if( combinedFlags
& EP_xIsSelect
) return 2;
4909 if( sqlite3ExprCompare(pParse
, pA
->pLeft
, pB
->pLeft
, iTab
) ) return 2;
4910 if( sqlite3ExprCompare(pParse
, pA
->pRight
, pB
->pRight
, iTab
) ) return 2;
4911 if( sqlite3ExprListCompare(pA
->x
.pList
, pB
->x
.pList
, iTab
) ) return 2;
4912 if( ALWAYS((combinedFlags
& EP_Reduced
)==0) && pA
->op
!=TK_STRING
){
4913 if( pA
->iColumn
!=pB
->iColumn
) return 2;
4914 if( pA
->iTable
!=pB
->iTable
4915 && (pA
->iTable
!=iTab
|| NEVER(pB
->iTable
>=0)) ) return 2;
4922 ** Compare two ExprList objects. Return 0 if they are identical and
4923 ** non-zero if they differ in any way.
4925 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
4926 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
4928 ** This routine might return non-zero for equivalent ExprLists. The
4929 ** only consequence will be disabled optimizations. But this routine
4930 ** must never return 0 if the two ExprList objects are different, or
4931 ** a malfunction will result.
4933 ** Two NULL pointers are considered to be the same. But a NULL pointer
4934 ** always differs from a non-NULL pointer.
4936 int sqlite3ExprListCompare(ExprList
*pA
, ExprList
*pB
, int iTab
){
4938 if( pA
==0 && pB
==0 ) return 0;
4939 if( pA
==0 || pB
==0 ) return 1;
4940 if( pA
->nExpr
!=pB
->nExpr
) return 1;
4941 for(i
=0; i
<pA
->nExpr
; i
++){
4942 Expr
*pExprA
= pA
->a
[i
].pExpr
;
4943 Expr
*pExprB
= pB
->a
[i
].pExpr
;
4944 if( pA
->a
[i
].sortOrder
!=pB
->a
[i
].sortOrder
) return 1;
4945 if( sqlite3ExprCompare(0, pExprA
, pExprB
, iTab
) ) return 1;
4951 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
4954 int sqlite3ExprCompareSkip(Expr
*pA
, Expr
*pB
, int iTab
){
4955 return sqlite3ExprCompare(0,
4956 sqlite3ExprSkipCollate(pA
),
4957 sqlite3ExprSkipCollate(pB
),
4962 ** Return true if we can prove the pE2 will always be true if pE1 is
4963 ** true. Return false if we cannot complete the proof or if pE2 might
4964 ** be false. Examples:
4966 ** pE1: x==5 pE2: x==5 Result: true
4967 ** pE1: x>0 pE2: x==5 Result: false
4968 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
4969 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
4970 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
4971 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
4972 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
4974 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
4975 ** Expr.iTable<0 then assume a table number given by iTab.
4977 ** If pParse is not NULL, then the values of bound variables in pE1 are
4978 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
4979 ** modified to record which bound variables are referenced. If pParse
4980 ** is NULL, then false will be returned if pE1 contains any bound variables.
4982 ** When in doubt, return false. Returning true might give a performance
4983 ** improvement. Returning false might cause a performance reduction, but
4984 ** it will always give the correct answer and is hence always safe.
4986 int sqlite3ExprImpliesExpr(Parse
*pParse
, Expr
*pE1
, Expr
*pE2
, int iTab
){
4987 if( sqlite3ExprCompare(pParse
, pE1
, pE2
, iTab
)==0 ){
4991 && (sqlite3ExprImpliesExpr(pParse
, pE1
, pE2
->pLeft
, iTab
)
4992 || sqlite3ExprImpliesExpr(pParse
, pE1
, pE2
->pRight
, iTab
) )
4996 if( pE2
->op
==TK_NOTNULL
&& pE1
->op
!=TK_ISNULL
&& pE1
->op
!=TK_IS
){
4997 Expr
*pX
= sqlite3ExprSkipCollate(pE1
->pLeft
);
4998 testcase( pX
!=pE1
->pLeft
);
4999 if( sqlite3ExprCompare(pParse
, pX
, pE2
->pLeft
, iTab
)==0 ) return 1;
5005 ** This is the Expr node callback for sqlite3ExprImpliesNotNullRow().
5006 ** If the expression node requires that the table at pWalker->iCur
5007 ** have a non-NULL column, then set pWalker->eCode to 1 and abort.
5009 static int impliesNotNullRow(Walker
*pWalker
, Expr
*pExpr
){
5010 /* This routine is only called for WHERE clause expressions and so it
5011 ** cannot have any TK_AGG_COLUMN entries because those are only found
5012 ** in HAVING clauses. We can get a TK_AGG_FUNCTION in a WHERE clause,
5013 ** but that is an illegal construct and the query will be rejected at
5014 ** a later stage of processing, so the TK_AGG_FUNCTION case does not
5015 ** need to be considered here. */
5016 assert( pExpr
->op
!=TK_AGG_COLUMN
);
5017 testcase( pExpr
->op
==TK_AGG_FUNCTION
);
5019 if( ExprHasProperty(pExpr
, EP_FromJoin
) ) return WRC_Prune
;
5020 switch( pExpr
->op
){
5027 testcase( pExpr
->op
==TK_ISNULL
);
5028 testcase( pExpr
->op
==TK_IS
);
5029 testcase( pExpr
->op
==TK_OR
);
5030 testcase( pExpr
->op
==TK_CASE
);
5031 testcase( pExpr
->op
==TK_IN
);
5032 testcase( pExpr
->op
==TK_FUNCTION
);
5035 if( pWalker
->u
.iCur
==pExpr
->iTable
){
5041 return WRC_Continue
;
5046 ** Return true (non-zero) if expression p can only be true if at least
5047 ** one column of table iTab is non-null. In other words, return true
5048 ** if expression p will always be NULL or false if every column of iTab
5051 ** False negatives are acceptable. In other words, it is ok to return
5052 ** zero even if expression p will never be true of every column of iTab
5053 ** is NULL. A false negative is merely a missed optimization opportunity.
5055 ** False positives are not allowed, however. A false positive may result
5056 ** in an incorrect answer.
5058 ** Terms of p that are marked with EP_FromJoin (and hence that come from
5059 ** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
5061 ** This routine is used to check if a LEFT JOIN can be converted into
5062 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
5063 ** clause requires that some column of the right table of the LEFT JOIN
5064 ** be non-NULL, then the LEFT JOIN can be safely converted into an
5067 int sqlite3ExprImpliesNonNullRow(Expr
*p
, int iTab
){
5069 w
.xExprCallback
= impliesNotNullRow
;
5070 w
.xSelectCallback
= 0;
5071 w
.xSelectCallback2
= 0;
5074 sqlite3WalkExpr(&w
, p
);
5079 ** An instance of the following structure is used by the tree walker
5080 ** to determine if an expression can be evaluated by reference to the
5081 ** index only, without having to do a search for the corresponding
5082 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
5083 ** is the cursor for the table.
5086 Index
*pIdx
; /* The index to be tested for coverage */
5087 int iCur
; /* Cursor number for the table corresponding to the index */
5091 ** Check to see if there are references to columns in table
5092 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
5093 ** pWalker->u.pIdxCover->pIdx.
5095 static int exprIdxCover(Walker
*pWalker
, Expr
*pExpr
){
5096 if( pExpr
->op
==TK_COLUMN
5097 && pExpr
->iTable
==pWalker
->u
.pIdxCover
->iCur
5098 && sqlite3ColumnOfIndex(pWalker
->u
.pIdxCover
->pIdx
, pExpr
->iColumn
)<0
5103 return WRC_Continue
;
5107 ** Determine if an index pIdx on table with cursor iCur contains will
5108 ** the expression pExpr. Return true if the index does cover the
5109 ** expression and false if the pExpr expression references table columns
5110 ** that are not found in the index pIdx.
5112 ** An index covering an expression means that the expression can be
5113 ** evaluated using only the index and without having to lookup the
5114 ** corresponding table entry.
5116 int sqlite3ExprCoveredByIndex(
5117 Expr
*pExpr
, /* The index to be tested */
5118 int iCur
, /* The cursor number for the corresponding table */
5119 Index
*pIdx
/* The index that might be used for coverage */
5122 struct IdxCover xcov
;
5123 memset(&w
, 0, sizeof(w
));
5126 w
.xExprCallback
= exprIdxCover
;
5127 w
.u
.pIdxCover
= &xcov
;
5128 sqlite3WalkExpr(&w
, pExpr
);
5134 ** An instance of the following structure is used by the tree walker
5135 ** to count references to table columns in the arguments of an
5136 ** aggregate function, in order to implement the
5137 ** sqlite3FunctionThisSrc() routine.
5140 SrcList
*pSrc
; /* One particular FROM clause in a nested query */
5141 int nThis
; /* Number of references to columns in pSrcList */
5142 int nOther
; /* Number of references to columns in other FROM clauses */
5146 ** Count the number of references to columns.
5148 static int exprSrcCount(Walker
*pWalker
, Expr
*pExpr
){
5149 /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc()
5150 ** is always called before sqlite3ExprAnalyzeAggregates() and so the
5151 ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN. If
5152 ** sqlite3FunctionUsesThisSrc() is used differently in the future, the
5153 ** NEVER() will need to be removed. */
5154 if( pExpr
->op
==TK_COLUMN
|| NEVER(pExpr
->op
==TK_AGG_COLUMN
) ){
5156 struct SrcCount
*p
= pWalker
->u
.pSrcCount
;
5157 SrcList
*pSrc
= p
->pSrc
;
5158 int nSrc
= pSrc
? pSrc
->nSrc
: 0;
5159 for(i
=0; i
<nSrc
; i
++){
5160 if( pExpr
->iTable
==pSrc
->a
[i
].iCursor
) break;
5168 return WRC_Continue
;
5172 ** Determine if any of the arguments to the pExpr Function reference
5173 ** pSrcList. Return true if they do. Also return true if the function
5174 ** has no arguments or has only constant arguments. Return false if pExpr
5175 ** references columns but not columns of tables found in pSrcList.
5177 int sqlite3FunctionUsesThisSrc(Expr
*pExpr
, SrcList
*pSrcList
){
5179 struct SrcCount cnt
;
5180 assert( pExpr
->op
==TK_AGG_FUNCTION
);
5181 w
.xExprCallback
= exprSrcCount
;
5182 w
.xSelectCallback
= 0;
5183 w
.u
.pSrcCount
= &cnt
;
5184 cnt
.pSrc
= pSrcList
;
5187 sqlite3WalkExprList(&w
, pExpr
->x
.pList
);
5188 return cnt
.nThis
>0 || cnt
.nOther
==0;
5192 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
5193 ** the new element. Return a negative number if malloc fails.
5195 static int addAggInfoColumn(sqlite3
*db
, AggInfo
*pInfo
){
5197 pInfo
->aCol
= sqlite3ArrayAllocate(
5200 sizeof(pInfo
->aCol
[0]),
5208 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
5209 ** the new element. Return a negative number if malloc fails.
5211 static int addAggInfoFunc(sqlite3
*db
, AggInfo
*pInfo
){
5213 pInfo
->aFunc
= sqlite3ArrayAllocate(
5216 sizeof(pInfo
->aFunc
[0]),
5224 ** This is the xExprCallback for a tree walker. It is used to
5225 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
5226 ** for additional information.
5228 static int analyzeAggregate(Walker
*pWalker
, Expr
*pExpr
){
5230 NameContext
*pNC
= pWalker
->u
.pNC
;
5231 Parse
*pParse
= pNC
->pParse
;
5232 SrcList
*pSrcList
= pNC
->pSrcList
;
5233 AggInfo
*pAggInfo
= pNC
->pAggInfo
;
5235 switch( pExpr
->op
){
5238 testcase( pExpr
->op
==TK_AGG_COLUMN
);
5239 testcase( pExpr
->op
==TK_COLUMN
);
5240 /* Check to see if the column is in one of the tables in the FROM
5241 ** clause of the aggregate query */
5242 if( ALWAYS(pSrcList
!=0) ){
5243 struct SrcList_item
*pItem
= pSrcList
->a
;
5244 for(i
=0; i
<pSrcList
->nSrc
; i
++, pItem
++){
5245 struct AggInfo_col
*pCol
;
5246 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
5247 if( pExpr
->iTable
==pItem
->iCursor
){
5248 /* If we reach this point, it means that pExpr refers to a table
5249 ** that is in the FROM clause of the aggregate query.
5251 ** Make an entry for the column in pAggInfo->aCol[] if there
5252 ** is not an entry there already.
5255 pCol
= pAggInfo
->aCol
;
5256 for(k
=0; k
<pAggInfo
->nColumn
; k
++, pCol
++){
5257 if( pCol
->iTable
==pExpr
->iTable
&&
5258 pCol
->iColumn
==pExpr
->iColumn
){
5262 if( (k
>=pAggInfo
->nColumn
)
5263 && (k
= addAggInfoColumn(pParse
->db
, pAggInfo
))>=0
5265 pCol
= &pAggInfo
->aCol
[k
];
5266 pCol
->pTab
= pExpr
->pTab
;
5267 pCol
->iTable
= pExpr
->iTable
;
5268 pCol
->iColumn
= pExpr
->iColumn
;
5269 pCol
->iMem
= ++pParse
->nMem
;
5270 pCol
->iSorterColumn
= -1;
5271 pCol
->pExpr
= pExpr
;
5272 if( pAggInfo
->pGroupBy
){
5274 ExprList
*pGB
= pAggInfo
->pGroupBy
;
5275 struct ExprList_item
*pTerm
= pGB
->a
;
5277 for(j
=0; j
<n
; j
++, pTerm
++){
5278 Expr
*pE
= pTerm
->pExpr
;
5279 if( pE
->op
==TK_COLUMN
&& pE
->iTable
==pExpr
->iTable
&&
5280 pE
->iColumn
==pExpr
->iColumn
){
5281 pCol
->iSorterColumn
= j
;
5286 if( pCol
->iSorterColumn
<0 ){
5287 pCol
->iSorterColumn
= pAggInfo
->nSortingColumn
++;
5290 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
5291 ** because it was there before or because we just created it).
5292 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
5293 ** pAggInfo->aCol[] entry.
5295 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
5296 pExpr
->pAggInfo
= pAggInfo
;
5297 pExpr
->op
= TK_AGG_COLUMN
;
5298 pExpr
->iAgg
= (i16
)k
;
5300 } /* endif pExpr->iTable==pItem->iCursor */
5301 } /* end loop over pSrcList */
5305 case TK_AGG_FUNCTION
: {
5306 if( (pNC
->ncFlags
& NC_InAggFunc
)==0
5307 && pWalker
->walkerDepth
==pExpr
->op2
5309 /* Check to see if pExpr is a duplicate of another aggregate
5310 ** function that is already in the pAggInfo structure
5312 struct AggInfo_func
*pItem
= pAggInfo
->aFunc
;
5313 for(i
=0; i
<pAggInfo
->nFunc
; i
++, pItem
++){
5314 if( sqlite3ExprCompare(0, pItem
->pExpr
, pExpr
, -1)==0 ){
5318 if( i
>=pAggInfo
->nFunc
){
5319 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
5321 u8 enc
= ENC(pParse
->db
);
5322 i
= addAggInfoFunc(pParse
->db
, pAggInfo
);
5324 assert( !ExprHasProperty(pExpr
, EP_xIsSelect
) );
5325 pItem
= &pAggInfo
->aFunc
[i
];
5326 pItem
->pExpr
= pExpr
;
5327 pItem
->iMem
= ++pParse
->nMem
;
5328 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
5329 pItem
->pFunc
= sqlite3FindFunction(pParse
->db
,
5331 pExpr
->x
.pList
? pExpr
->x
.pList
->nExpr
: 0, enc
, 0);
5332 if( pExpr
->flags
& EP_Distinct
){
5333 pItem
->iDistinct
= pParse
->nTab
++;
5335 pItem
->iDistinct
= -1;
5339 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
5341 assert( !ExprHasProperty(pExpr
, EP_TokenOnly
|EP_Reduced
) );
5342 ExprSetVVAProperty(pExpr
, EP_NoReduce
);
5343 pExpr
->iAgg
= (i16
)i
;
5344 pExpr
->pAggInfo
= pAggInfo
;
5347 return WRC_Continue
;
5351 return WRC_Continue
;
5353 static int analyzeAggregatesInSelect(Walker
*pWalker
, Select
*pSelect
){
5354 UNUSED_PARAMETER(pSelect
);
5355 pWalker
->walkerDepth
++;
5356 return WRC_Continue
;
5358 static void analyzeAggregatesInSelectEnd(Walker
*pWalker
, Select
*pSelect
){
5359 UNUSED_PARAMETER(pSelect
);
5360 pWalker
->walkerDepth
--;
5364 ** Analyze the pExpr expression looking for aggregate functions and
5365 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
5366 ** points to. Additional entries are made on the AggInfo object as
5369 ** This routine should only be called after the expression has been
5370 ** analyzed by sqlite3ResolveExprNames().
5372 void sqlite3ExprAnalyzeAggregates(NameContext
*pNC
, Expr
*pExpr
){
5374 w
.xExprCallback
= analyzeAggregate
;
5375 w
.xSelectCallback
= analyzeAggregatesInSelect
;
5376 w
.xSelectCallback2
= analyzeAggregatesInSelectEnd
;
5379 assert( pNC
->pSrcList
!=0 );
5380 sqlite3WalkExpr(&w
, pExpr
);
5384 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
5385 ** expression list. Return the number of errors.
5387 ** If an error is found, the analysis is cut short.
5389 void sqlite3ExprAnalyzeAggList(NameContext
*pNC
, ExprList
*pList
){
5390 struct ExprList_item
*pItem
;
5393 for(pItem
=pList
->a
, i
=0; i
<pList
->nExpr
; i
++, pItem
++){
5394 sqlite3ExprAnalyzeAggregates(pNC
, pItem
->pExpr
);
5400 ** Allocate a single new register for use to hold some intermediate result.
5402 int sqlite3GetTempReg(Parse
*pParse
){
5403 if( pParse
->nTempReg
==0 ){
5404 return ++pParse
->nMem
;
5406 return pParse
->aTempReg
[--pParse
->nTempReg
];
5410 ** Deallocate a register, making available for reuse for some other
5413 ** If a register is currently being used by the column cache, then
5414 ** the deallocation is deferred until the column cache line that uses
5415 ** the register becomes stale.
5417 void sqlite3ReleaseTempReg(Parse
*pParse
, int iReg
){
5418 if( iReg
&& pParse
->nTempReg
<ArraySize(pParse
->aTempReg
) ){
5420 struct yColCache
*p
;
5421 for(i
=0, p
=pParse
->aColCache
; i
<pParse
->nColCache
; i
++, p
++){
5422 if( p
->iReg
==iReg
){
5427 pParse
->aTempReg
[pParse
->nTempReg
++] = iReg
;
5432 ** Allocate or deallocate a block of nReg consecutive registers.
5434 int sqlite3GetTempRange(Parse
*pParse
, int nReg
){
5436 if( nReg
==1 ) return sqlite3GetTempReg(pParse
);
5437 i
= pParse
->iRangeReg
;
5438 n
= pParse
->nRangeReg
;
5440 assert( !usedAsColumnCache(pParse
, i
, i
+n
-1) );
5441 pParse
->iRangeReg
+= nReg
;
5442 pParse
->nRangeReg
-= nReg
;
5445 pParse
->nMem
+= nReg
;
5449 void sqlite3ReleaseTempRange(Parse
*pParse
, int iReg
, int nReg
){
5451 sqlite3ReleaseTempReg(pParse
, iReg
);
5454 sqlite3ExprCacheRemove(pParse
, iReg
, nReg
);
5455 if( nReg
>pParse
->nRangeReg
){
5456 pParse
->nRangeReg
= nReg
;
5457 pParse
->iRangeReg
= iReg
;
5462 ** Mark all temporary registers as being unavailable for reuse.
5464 void sqlite3ClearTempRegCache(Parse
*pParse
){
5465 pParse
->nTempReg
= 0;
5466 pParse
->nRangeReg
= 0;
5470 ** Validate that no temporary register falls within the range of
5471 ** iFirst..iLast, inclusive. This routine is only call from within assert()
5475 int sqlite3NoTempsInRange(Parse
*pParse
, int iFirst
, int iLast
){
5477 if( pParse
->nRangeReg
>0
5478 && pParse
->iRangeReg
+pParse
->nRangeReg
> iFirst
5479 && pParse
->iRangeReg
<= iLast
5483 for(i
=0; i
<pParse
->nTempReg
; i
++){
5484 if( pParse
->aTempReg
[i
]>=iFirst
&& pParse
->aTempReg
[i
]<=iLast
){
5490 #endif /* SQLITE_DEBUG */