Symaptic: os/persistentdata/persistentstorage/sqlite3api/SQLite/expr.c@bde4ae8d615e (annotated)

sl@0	1	/*
sl@0	2	** 2001 September 15
sl@0	3	**
sl@0	4	** The author disclaims copyright to this source code. In place of
sl@0	5	** a legal notice, here is a blessing:
sl@0	6	**
sl@0	7	** May you do good and not evil.
sl@0	8	** May you find forgiveness for yourself and forgive others.
sl@0	9	** May you share freely, never taking more than you give.
sl@0	10	**
sl@0	11	*************************************************************************
sl@0	12	** This file contains routines used for analyzing expressions and
sl@0	13	** for generating VDBE code that evaluates expressions in SQLite.
sl@0	14	**
sl@0	15	** $Id: expr.c,v 1.395 2008/10/02 13:50:56 danielk1977 Exp $
sl@0	16	*/
sl@0	17	#include "sqliteInt.h"
sl@0	18	#include <ctype.h>
sl@0	19
sl@0	20	/*
sl@0	21	** Return the 'affinity' of the expression pExpr if any.
sl@0	22	**
sl@0	23	** If pExpr is a column, a reference to a column via an 'AS' alias,
sl@0	24	** or a sub-select with a column as the return value, then the
sl@0	25	** affinity of that column is returned. Otherwise, 0x00 is returned,
sl@0	26	** indicating no affinity for the expression.
sl@0	27	**
sl@0	28	** i.e. the WHERE clause expresssions in the following statements all
sl@0	29	** have an affinity:
sl@0	30	**
sl@0	31	** CREATE TABLE t1(a);
sl@0	32	** SELECT * FROM t1 WHERE a;
sl@0	33	** SELECT a AS b FROM t1 WHERE b;
sl@0	34	** SELECT * FROM t1 WHERE (select a from t1);
sl@0	35	*/
sl@0	36	char sqlite3ExprAffinity(Expr *pExpr){
sl@0	37	int op = pExpr->op;
sl@0	38	if( op==TK_SELECT ){
sl@0	39	return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr);
sl@0	40	}
sl@0	41	#ifndef SQLITE_OMIT_CAST
sl@0	42	if( op==TK_CAST ){
sl@0	43	return sqlite3AffinityType(&pExpr->token);
sl@0	44	}
sl@0	45	#endif
sl@0	46	if( (op==TK_COLUMN \|\| op==TK_REGISTER) && pExpr->pTab!=0 ){
sl@0	47	/* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
sl@0	48	** a TK_COLUMN but was previously evaluated and cached in a register */
sl@0	49	int j = pExpr->iColumn;
sl@0	50	if( j<0 ) return SQLITE_AFF_INTEGER;
sl@0	51	assert( pExpr->pTab && j<pExpr->pTab->nCol );
sl@0	52	return pExpr->pTab->aCol[j].affinity;
sl@0	53	}
sl@0	54	return pExpr->affinity;
sl@0	55	}
sl@0	56
sl@0	57	/*
sl@0	58	** Set the collating sequence for expression pExpr to be the collating
sl@0	59	** sequence named by pToken. Return a pointer to the revised expression.
sl@0	60	** The collating sequence is marked as "explicit" using the EP_ExpCollate
sl@0	61	** flag. An explicit collating sequence will override implicit
sl@0	62	** collating sequences.
sl@0	63	*/
sl@0	64	Expr sqlite3ExprSetColl(Parse pParse, Expr pExpr, Token pCollName){
sl@0	65	char zColl = 0; / Dequoted name of collation sequence */
sl@0	66	CollSeq *pColl;
sl@0	67	sqlite3 *db = pParse->db;
sl@0	68	zColl = sqlite3NameFromToken(db, pCollName);
sl@0	69	if( pExpr && zColl ){
sl@0	70	pColl = sqlite3LocateCollSeq(pParse, zColl, -1);
sl@0	71	if( pColl ){
sl@0	72	pExpr->pColl = pColl;
sl@0	73	pExpr->flags \|= EP_ExpCollate;
sl@0	74	}
sl@0	75	}
sl@0	76	sqlite3DbFree(db, zColl);
sl@0	77	return pExpr;
sl@0	78	}
sl@0	79
sl@0	80	/*
sl@0	81	** Return the default collation sequence for the expression pExpr. If
sl@0	82	** there is no default collation type, return 0.
sl@0	83	*/
sl@0	84	CollSeq sqlite3ExprCollSeq(Parse pParse, Expr *pExpr){
sl@0	85	CollSeq *pColl = 0;
sl@0	86	Expr *p = pExpr;
sl@0	87	while( p ){
sl@0	88	int op;
sl@0	89	pColl = p->pColl;
sl@0	90	if( pColl ) break;
sl@0	91	op = p->op;
sl@0	92	if( (op==TK_COLUMN \|\| op==TK_REGISTER) && p->pTab!=0 ){
sl@0	93	/* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
sl@0	94	** a TK_COLUMN but was previously evaluated and cached in a register */
sl@0	95	const char *zColl;
sl@0	96	int j = p->iColumn;
sl@0	97	if( j>=0 ){
sl@0	98	sqlite3 *db = pParse->db;
sl@0	99	zColl = p->pTab->aCol[j].zColl;
sl@0	100	pColl = sqlite3FindCollSeq(db, ENC(db), zColl, -1, 0);
sl@0	101	pExpr->pColl = pColl;
sl@0	102	}
sl@0	103	break;
sl@0	104	}
sl@0	105	if( op!=TK_CAST && op!=TK_UPLUS ){
sl@0	106	break;
sl@0	107	}
sl@0	108	p = p->pLeft;
sl@0	109	}
sl@0	110	if( sqlite3CheckCollSeq(pParse, pColl) ){
sl@0	111	pColl = 0;
sl@0	112	}
sl@0	113	return pColl;
sl@0	114	}
sl@0	115
sl@0	116	/*
sl@0	117	** pExpr is an operand of a comparison operator. aff2 is the
sl@0	118	** type affinity of the other operand. This routine returns the
sl@0	119	** type affinity that should be used for the comparison operator.
sl@0	120	*/
sl@0	121	char sqlite3CompareAffinity(Expr *pExpr, char aff2){
sl@0	122	char aff1 = sqlite3ExprAffinity(pExpr);
sl@0	123	if( aff1 && aff2 ){
sl@0	124	/* Both sides of the comparison are columns. If one has numeric
sl@0	125	** affinity, use that. Otherwise use no affinity.
sl@0	126	*/
sl@0	127	if( sqlite3IsNumericAffinity(aff1) \|\| sqlite3IsNumericAffinity(aff2) ){
sl@0	128	return SQLITE_AFF_NUMERIC;
sl@0	129	}else{
sl@0	130	return SQLITE_AFF_NONE;
sl@0	131	}
sl@0	132	}else if( !aff1 && !aff2 ){
sl@0	133	/* Neither side of the comparison is a column. Compare the
sl@0	134	** results directly.
sl@0	135	*/
sl@0	136	return SQLITE_AFF_NONE;
sl@0	137	}else{
sl@0	138	/* One side is a column, the other is not. Use the columns affinity. */
sl@0	139	assert( aff1==0 \|\| aff2==0 );
sl@0	140	return (aff1 + aff2);
sl@0	141	}
sl@0	142	}
sl@0	143
sl@0	144	/*
sl@0	145	** pExpr is a comparison operator. Return the type affinity that should
sl@0	146	** be applied to both operands prior to doing the comparison.
sl@0	147	*/
sl@0	148	static char comparisonAffinity(Expr *pExpr){
sl@0	149	char aff;
sl@0	150	assert( pExpr->op==TK_EQ \|\| pExpr->op==TK_IN \|\| pExpr->op==TK_LT \|\|
sl@0	151	pExpr->op==TK_GT \|\| pExpr->op==TK_GE \|\| pExpr->op==TK_LE \|\|
sl@0	152	pExpr->op==TK_NE );
sl@0	153	assert( pExpr->pLeft );
sl@0	154	aff = sqlite3ExprAffinity(pExpr->pLeft);
sl@0	155	if( pExpr->pRight ){
sl@0	156	aff = sqlite3CompareAffinity(pExpr->pRight, aff);
sl@0	157	}
sl@0	158	else if( pExpr->pSelect ){
sl@0	159	aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff);
sl@0	160	}
sl@0	161	else if( !aff ){
sl@0	162	aff = SQLITE_AFF_NONE;
sl@0	163	}
sl@0	164	return aff;
sl@0	165	}
sl@0	166
sl@0	167	/*
sl@0	168	** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
sl@0	169	** idx_affinity is the affinity of an indexed column. Return true
sl@0	170	** if the index with affinity idx_affinity may be used to implement
sl@0	171	** the comparison in pExpr.
sl@0	172	*/
sl@0	173	int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
sl@0	174	char aff = comparisonAffinity(pExpr);
sl@0	175	switch( aff ){
sl@0	176	case SQLITE_AFF_NONE:
sl@0	177	return 1;
sl@0	178	case SQLITE_AFF_TEXT:
sl@0	179	return idx_affinity==SQLITE_AFF_TEXT;
sl@0	180	default:
sl@0	181	return sqlite3IsNumericAffinity(idx_affinity);
sl@0	182	}
sl@0	183	}
sl@0	184
sl@0	185	/*
sl@0	186	** Return the P5 value that should be used for a binary comparison
sl@0	187	** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
sl@0	188	*/
sl@0	189	static u8 binaryCompareP5(Expr pExpr1, Expr pExpr2, int jumpIfNull){
sl@0	190	u8 aff = (char)sqlite3ExprAffinity(pExpr2);
sl@0	191	aff = sqlite3CompareAffinity(pExpr1, aff) \| jumpIfNull;
sl@0	192	return aff;
sl@0	193	}
sl@0	194
sl@0	195	/*
sl@0	196	** Return a pointer to the collation sequence that should be used by
sl@0	197	** a binary comparison operator comparing pLeft and pRight.
sl@0	198	**
sl@0	199	** If the left hand expression has a collating sequence type, then it is
sl@0	200	** used. Otherwise the collation sequence for the right hand expression
sl@0	201	** is used, or the default (BINARY) if neither expression has a collating
sl@0	202	** type.
sl@0	203	**
sl@0	204	** Argument pRight (but not pLeft) may be a null pointer. In this case,
sl@0	205	** it is not considered.
sl@0	206	*/
sl@0	207	CollSeq *sqlite3BinaryCompareCollSeq(
sl@0	208	Parse *pParse,
sl@0	209	Expr *pLeft,
sl@0	210	Expr *pRight
sl@0	211	){
sl@0	212	CollSeq *pColl;
sl@0	213	assert( pLeft );
sl@0	214	if( pLeft->flags & EP_ExpCollate ){
sl@0	215	assert( pLeft->pColl );
sl@0	216	pColl = pLeft->pColl;
sl@0	217	}else if( pRight && pRight->flags & EP_ExpCollate ){
sl@0	218	assert( pRight->pColl );
sl@0	219	pColl = pRight->pColl;
sl@0	220	}else{
sl@0	221	pColl = sqlite3ExprCollSeq(pParse, pLeft);
sl@0	222	if( !pColl ){
sl@0	223	pColl = sqlite3ExprCollSeq(pParse, pRight);
sl@0	224	}
sl@0	225	}
sl@0	226	return pColl;
sl@0	227	}
sl@0	228
sl@0	229	/*
sl@0	230	** Generate the operands for a comparison operation. Before
sl@0	231	** generating the code for each operand, set the EP_AnyAff
sl@0	232	** flag on the expression so that it will be able to used a
sl@0	233	** cached column value that has previously undergone an
sl@0	234	** affinity change.
sl@0	235	*/
sl@0	236	static void codeCompareOperands(
sl@0	237	Parse pParse, / Parsing and code generating context */
sl@0	238	Expr pLeft, / The left operand */
sl@0	239	int pRegLeft, / Register where left operand is stored */
sl@0	240	int pFreeLeft, / Free this register when done */
sl@0	241	Expr pRight, / The right operand */
sl@0	242	int pRegRight, / Register where right operand is stored */
sl@0	243	int pFreeRight / Write temp register for right operand there */
sl@0	244	){
sl@0	245	while( pLeft->op==TK_UPLUS ) pLeft = pLeft->pLeft;
sl@0	246	pLeft->flags \|= EP_AnyAff;
sl@0	247	*pRegLeft = sqlite3ExprCodeTemp(pParse, pLeft, pFreeLeft);
sl@0	248	while( pRight->op==TK_UPLUS ) pRight = pRight->pLeft;
sl@0	249	pRight->flags \|= EP_AnyAff;
sl@0	250	*pRegRight = sqlite3ExprCodeTemp(pParse, pRight, pFreeRight);
sl@0	251	}
sl@0	252
sl@0	253	/*
sl@0	254	** Generate code for a comparison operator.
sl@0	255	*/
sl@0	256	static int codeCompare(
sl@0	257	Parse pParse, / The parsing (and code generating) context */
sl@0	258	Expr pLeft, / The left operand */
sl@0	259	Expr pRight, / The right operand */
sl@0	260	int opcode, /* The comparison opcode */
sl@0	261	int in1, int in2, /* Register holding operands */
sl@0	262	int dest, /* Jump here if true. */
sl@0	263	int jumpIfNull /* If true, jump if either operand is NULL */
sl@0	264	){
sl@0	265	int p5;
sl@0	266	int addr;
sl@0	267	CollSeq *p4;
sl@0	268
sl@0	269	p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
sl@0	270	p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
sl@0	271	addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
sl@0	272	(void*)p4, P4_COLLSEQ);
sl@0	273	sqlite3VdbeChangeP5(pParse->pVdbe, p5);
sl@0	274	if( (p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_NONE ){
sl@0	275	sqlite3ExprCacheAffinityChange(pParse, in1, 1);
sl@0	276	sqlite3ExprCacheAffinityChange(pParse, in2, 1);
sl@0	277	}
sl@0	278	return addr;
sl@0	279	}
sl@0	280
sl@0	281	#if SQLITE_MAX_EXPR_DEPTH>0
sl@0	282	/*
sl@0	283	** Check that argument nHeight is less than or equal to the maximum
sl@0	284	** expression depth allowed. If it is not, leave an error message in
sl@0	285	** pParse.
sl@0	286	*/
sl@0	287	int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
sl@0	288	int rc = SQLITE_OK;
sl@0	289	int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
sl@0	290	if( nHeight>mxHeight ){
sl@0	291	sqlite3ErrorMsg(pParse,
sl@0	292	"Expression tree is too large (maximum depth %d)", mxHeight
sl@0	293	);
sl@0	294	rc = SQLITE_ERROR;
sl@0	295	}
sl@0	296	return rc;
sl@0	297	}
sl@0	298
sl@0	299	/* The following three functions, heightOfExpr(), heightOfExprList()
sl@0	300	** and heightOfSelect(), are used to determine the maximum height
sl@0	301	** of any expression tree referenced by the structure passed as the
sl@0	302	** first argument.
sl@0	303	**
sl@0	304	** If this maximum height is greater than the current value pointed
sl@0	305	** to by pnHeight, the second parameter, then set *pnHeight to that
sl@0	306	** value.
sl@0	307	*/
sl@0	308	static void heightOfExpr(Expr p, int pnHeight){
sl@0	309	if( p ){
sl@0	310	if( p->nHeight>*pnHeight ){
sl@0	311	*pnHeight = p->nHeight;
sl@0	312	}
sl@0	313	}
sl@0	314	}
sl@0	315	static void heightOfExprList(ExprList p, int pnHeight){
sl@0	316	if( p ){
sl@0	317	int i;
sl@0	318	for(i=0; i<p->nExpr; i++){
sl@0	319	heightOfExpr(p->a[i].pExpr, pnHeight);
sl@0	320	}
sl@0	321	}
sl@0	322	}
sl@0	323	static void heightOfSelect(Select p, int pnHeight){
sl@0	324	if( p ){
sl@0	325	heightOfExpr(p->pWhere, pnHeight);
sl@0	326	heightOfExpr(p->pHaving, pnHeight);
sl@0	327	heightOfExpr(p->pLimit, pnHeight);
sl@0	328	heightOfExpr(p->pOffset, pnHeight);
sl@0	329	heightOfExprList(p->pEList, pnHeight);
sl@0	330	heightOfExprList(p->pGroupBy, pnHeight);
sl@0	331	heightOfExprList(p->pOrderBy, pnHeight);
sl@0	332	heightOfSelect(p->pPrior, pnHeight);
sl@0	333	}
sl@0	334	}
sl@0	335
sl@0	336	/*
sl@0	337	** Set the Expr.nHeight variable in the structure passed as an
sl@0	338	** argument. An expression with no children, Expr.pList or
sl@0	339	** Expr.pSelect member has a height of 1. Any other expression
sl@0	340	** has a height equal to the maximum height of any other
sl@0	341	** referenced Expr plus one.
sl@0	342	*/
sl@0	343	static void exprSetHeight(Expr *p){
sl@0	344	int nHeight = 0;
sl@0	345	heightOfExpr(p->pLeft, &nHeight);
sl@0	346	heightOfExpr(p->pRight, &nHeight);
sl@0	347	heightOfExprList(p->pList, &nHeight);
sl@0	348	heightOfSelect(p->pSelect, &nHeight);
sl@0	349	p->nHeight = nHeight + 1;
sl@0	350	}
sl@0	351
sl@0	352	/*
sl@0	353	** Set the Expr.nHeight variable using the exprSetHeight() function. If
sl@0	354	** the height is greater than the maximum allowed expression depth,
sl@0	355	** leave an error in pParse.
sl@0	356	*/
sl@0	357	void sqlite3ExprSetHeight(Parse pParse, Expr p){
sl@0	358	exprSetHeight(p);
sl@0	359	sqlite3ExprCheckHeight(pParse, p->nHeight);
sl@0	360	}
sl@0	361
sl@0	362	/*
sl@0	363	** Return the maximum height of any expression tree referenced
sl@0	364	** by the select statement passed as an argument.
sl@0	365	*/
sl@0	366	int sqlite3SelectExprHeight(Select *p){
sl@0	367	int nHeight = 0;
sl@0	368	heightOfSelect(p, &nHeight);
sl@0	369	return nHeight;
sl@0	370	}
sl@0	371	#else
sl@0	372	#define exprSetHeight(y)
sl@0	373	#endif /* SQLITE_MAX_EXPR_DEPTH>0 */
sl@0	374
sl@0	375	/*
sl@0	376	** Construct a new expression node and return a pointer to it. Memory
sl@0	377	** for this node is obtained from sqlite3_malloc(). The calling function
sl@0	378	** is responsible for making sure the node eventually gets freed.
sl@0	379	*/
sl@0	380	Expr *sqlite3Expr(
sl@0	381	sqlite3 db, / Handle for sqlite3DbMallocZero() (may be null) */
sl@0	382	int op, /* Expression opcode */
sl@0	383	Expr pLeft, / Left operand */
sl@0	384	Expr pRight, / Right operand */
sl@0	385	const Token pToken / Argument token */
sl@0	386	){
sl@0	387	Expr *pNew;
sl@0	388	pNew = sqlite3DbMallocZero(db, sizeof(Expr));
sl@0	389	if( pNew==0 ){
sl@0	390	/* When malloc fails, delete pLeft and pRight. Expressions passed to
sl@0	391	** this function must always be allocated with sqlite3Expr() for this
sl@0	392	** reason.
sl@0	393	*/
sl@0	394	sqlite3ExprDelete(db, pLeft);
sl@0	395	sqlite3ExprDelete(db, pRight);
sl@0	396	return 0;
sl@0	397	}
sl@0	398	pNew->op = op;
sl@0	399	pNew->pLeft = pLeft;
sl@0	400	pNew->pRight = pRight;
sl@0	401	pNew->iAgg = -1;
sl@0	402	pNew->span.z = (u8*)"";
sl@0	403	if( pToken ){
sl@0	404	assert( pToken->dyn==0 );
sl@0	405	pNew->span = pNew->token = *pToken;
sl@0	406	}else if( pLeft ){
sl@0	407	if( pRight ){
sl@0	408	if( pRight->span.dyn==0 && pLeft->span.dyn==0 ){
sl@0	409	sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span);
sl@0	410	}
sl@0	411	if( pRight->flags & EP_ExpCollate ){
sl@0	412	pNew->flags \|= EP_ExpCollate;
sl@0	413	pNew->pColl = pRight->pColl;
sl@0	414	}
sl@0	415	}
sl@0	416	if( pLeft->flags & EP_ExpCollate ){
sl@0	417	pNew->flags \|= EP_ExpCollate;
sl@0	418	pNew->pColl = pLeft->pColl;
sl@0	419	}
sl@0	420	}
sl@0	421
sl@0	422	exprSetHeight(pNew);
sl@0	423	return pNew;
sl@0	424	}
sl@0	425
sl@0	426	/*
sl@0	427	** Works like sqlite3Expr() except that it takes an extra Parse*
sl@0	428	** argument and notifies the associated connection object if malloc fails.
sl@0	429	*/
sl@0	430	Expr *sqlite3PExpr(
sl@0	431	Parse pParse, / Parsing context */
sl@0	432	int op, /* Expression opcode */
sl@0	433	Expr pLeft, / Left operand */
sl@0	434	Expr pRight, / Right operand */
sl@0	435	const Token pToken / Argument token */
sl@0	436	){
sl@0	437	Expr *p = sqlite3Expr(pParse->db, op, pLeft, pRight, pToken);
sl@0	438	if( p ){
sl@0	439	sqlite3ExprCheckHeight(pParse, p->nHeight);
sl@0	440	}
sl@0	441	return p;
sl@0	442	}
sl@0	443
sl@0	444	/*
sl@0	445	** When doing a nested parse, you can include terms in an expression
sl@0	446	** that look like this: #1 #2 ... These terms refer to registers
sl@0	447	** in the virtual machine. #N is the N-th register.
sl@0	448	**
sl@0	449	** This routine is called by the parser to deal with on of those terms.
sl@0	450	** It immediately generates code to store the value in a memory location.
sl@0	451	** The returns an expression that will code to extract the value from
sl@0	452	** that memory location as needed.
sl@0	453	*/
sl@0	454	Expr sqlite3RegisterExpr(Parse pParse, Token *pToken){
sl@0	455	Vdbe *v = pParse->pVdbe;
sl@0	456	Expr *p;
sl@0	457	if( pParse->nested==0 ){
sl@0	458	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken);
sl@0	459	return sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
sl@0	460	}
sl@0	461	if( v==0 ) return 0;
sl@0	462	p = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, pToken);
sl@0	463	if( p==0 ){
sl@0	464	return 0; /* Malloc failed */
sl@0	465	}
sl@0	466	p->iTable = atoi((char*)&pToken->z[1]);
sl@0	467	return p;
sl@0	468	}
sl@0	469
sl@0	470	/*
sl@0	471	** Join two expressions using an AND operator. If either expression is
sl@0	472	** NULL, then just return the other expression.
sl@0	473	*/
sl@0	474	Expr sqlite3ExprAnd(sqlite3 db, Expr pLeft, Expr pRight){
sl@0	475	if( pLeft==0 ){
sl@0	476	return pRight;
sl@0	477	}else if( pRight==0 ){
sl@0	478	return pLeft;
sl@0	479	}else{
sl@0	480	return sqlite3Expr(db, TK_AND, pLeft, pRight, 0);
sl@0	481	}
sl@0	482	}
sl@0	483
sl@0	484	/*
sl@0	485	** Set the Expr.span field of the given expression to span all
sl@0	486	** text between the two given tokens. Both tokens must be pointing
sl@0	487	** at the same string.
sl@0	488	*/
sl@0	489	void sqlite3ExprSpan(Expr pExpr, Token pLeft, Token *pRight){
sl@0	490	assert( pRight!=0 );
sl@0	491	assert( pLeft!=0 );
sl@0	492	if( pExpr ){
sl@0	493	pExpr->span.z = pLeft->z;
sl@0	494	pExpr->span.n = pRight->n + (pRight->z - pLeft->z);
sl@0	495	}
sl@0	496	}
sl@0	497
sl@0	498	/*
sl@0	499	** Construct a new expression node for a function with multiple
sl@0	500	** arguments.
sl@0	501	*/
sl@0	502	Expr sqlite3ExprFunction(Parse pParse, ExprList pList, Token pToken){
sl@0	503	Expr *pNew;
sl@0	504	sqlite3 *db = pParse->db;
sl@0	505	assert( pToken );
sl@0	506	pNew = sqlite3DbMallocZero(db, sizeof(Expr) );
sl@0	507	if( pNew==0 ){
sl@0	508	sqlite3ExprListDelete(db, pList); /* Avoid leaking memory when malloc fails */
sl@0	509	return 0;
sl@0	510	}
sl@0	511	pNew->op = TK_FUNCTION;
sl@0	512	pNew->pList = pList;
sl@0	513	assert( pToken->dyn==0 );
sl@0	514	pNew->token = *pToken;
sl@0	515	pNew->span = pNew->token;
sl@0	516
sl@0	517	sqlite3ExprSetHeight(pParse, pNew);
sl@0	518	return pNew;
sl@0	519	}
sl@0	520
sl@0	521	/*
sl@0	522	** Assign a variable number to an expression that encodes a wildcard
sl@0	523	** in the original SQL statement.
sl@0	524	**
sl@0	525	** Wildcards consisting of a single "?" are assigned the next sequential
sl@0	526	** variable number.
sl@0	527	**
sl@0	528	** Wildcards of the form "?nnn" are assigned the number "nnn". We make
sl@0	529	** sure "nnn" is not too be to avoid a denial of service attack when
sl@0	530	** the SQL statement comes from an external source.
sl@0	531	**
sl@0	532	** Wildcards of the form ":aaa" or "$aaa" are assigned the same number
sl@0	533	** as the previous instance of the same wildcard. Or if this is the first
sl@0	534	** instance of the wildcard, the next sequenial variable number is
sl@0	535	** assigned.
sl@0	536	*/
sl@0	537	void sqlite3ExprAssignVarNumber(Parse pParse, Expr pExpr){
sl@0	538	Token *pToken;
sl@0	539	sqlite3 *db = pParse->db;
sl@0	540
sl@0	541	if( pExpr==0 ) return;
sl@0	542	pToken = &pExpr->token;
sl@0	543	assert( pToken->n>=1 );
sl@0	544	assert( pToken->z!=0 );
sl@0	545	assert( pToken->z[0]!=0 );
sl@0	546	if( pToken->n==1 ){
sl@0	547	/* Wildcard of the form "?". Assign the next variable number */
sl@0	548	pExpr->iTable = ++pParse->nVar;
sl@0	549	}else if( pToken->z[0]=='?' ){
sl@0	550	/* Wildcard of the form "?nnn". Convert "nnn" to an integer and
sl@0	551	** use it as the variable number */
sl@0	552	int i;
sl@0	553	pExpr->iTable = i = atoi((char*)&pToken->z[1]);
sl@0	554	testcase( i==0 );
sl@0	555	testcase( i==1 );
sl@0	556	testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
sl@0	557	testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
sl@0	558	if( i<1 \|\| i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
sl@0	559	sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
sl@0	560	db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
sl@0	561	}
sl@0	562	if( i>pParse->nVar ){
sl@0	563	pParse->nVar = i;
sl@0	564	}
sl@0	565	}else{
sl@0	566	/* Wildcards of the form ":aaa" or "$aaa". Reuse the same variable
sl@0	567	** number as the prior appearance of the same name, or if the name
sl@0	568	** has never appeared before, reuse the same variable number
sl@0	569	*/
sl@0	570	int i, n;
sl@0	571	n = pToken->n;
sl@0	572	for(i=0; i<pParse->nVarExpr; i++){
sl@0	573	Expr *pE;
sl@0	574	if( (pE = pParse->apVarExpr[i])!=0
sl@0	575	&& pE->token.n==n
sl@0	576	&& memcmp(pE->token.z, pToken->z, n)==0 ){
sl@0	577	pExpr->iTable = pE->iTable;
sl@0	578	break;
sl@0	579	}
sl@0	580	}
sl@0	581	if( i>=pParse->nVarExpr ){
sl@0	582	pExpr->iTable = ++pParse->nVar;
sl@0	583	if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
sl@0	584	pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
sl@0	585	pParse->apVarExpr =
sl@0	586	sqlite3DbReallocOrFree(
sl@0	587	db,
sl@0	588	pParse->apVarExpr,
sl@0	589	pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
sl@0	590	);
sl@0	591	}
sl@0	592	if( !db->mallocFailed ){
sl@0	593	assert( pParse->apVarExpr!=0 );
sl@0	594	pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
sl@0	595	}
sl@0	596	}
sl@0	597	}
sl@0	598	if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
sl@0	599	sqlite3ErrorMsg(pParse, "too many SQL variables");
sl@0	600	}
sl@0	601	}
sl@0	602
sl@0	603	/*
sl@0	604	** Recursively delete an expression tree.
sl@0	605	*/
sl@0	606	void sqlite3ExprDelete(sqlite3 db, Expr p){
sl@0	607	if( p==0 ) return;
sl@0	608	if( p->span.dyn ) sqlite3DbFree(db, (char*)p->span.z);
sl@0	609	if( p->token.dyn ) sqlite3DbFree(db, (char*)p->token.z);
sl@0	610	sqlite3ExprDelete(db, p->pLeft);
sl@0	611	sqlite3ExprDelete(db, p->pRight);
sl@0	612	sqlite3ExprListDelete(db, p->pList);
sl@0	613	sqlite3SelectDelete(db, p->pSelect);
sl@0	614	sqlite3DbFree(db, p);
sl@0	615	}
sl@0	616
sl@0	617	/*
sl@0	618	** The Expr.token field might be a string literal that is quoted.
sl@0	619	** If so, remove the quotation marks.
sl@0	620	*/
sl@0	621	void sqlite3DequoteExpr(sqlite3 db, Expr p){
sl@0	622	if( ExprHasAnyProperty(p, EP_Dequoted) ){
sl@0	623	return;
sl@0	624	}
sl@0	625	ExprSetProperty(p, EP_Dequoted);
sl@0	626	if( p->token.dyn==0 ){
sl@0	627	sqlite3TokenCopy(db, &p->token, &p->token);
sl@0	628	}
sl@0	629	sqlite3Dequote((char*)p->token.z);
sl@0	630	}
sl@0	631
sl@0	632	/*
sl@0	633	** The following group of routines make deep copies of expressions,
sl@0	634	** expression lists, ID lists, and select statements. The copies can
sl@0	635	** be deleted (by being passed to their respective ...Delete() routines)
sl@0	636	** without effecting the originals.
sl@0	637	**
sl@0	638	** The expression list, ID, and source lists return by sqlite3ExprListDup(),
sl@0	639	** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
sl@0	640	** by subsequent calls to sqlite*ListAppend() routines.
sl@0	641	**
sl@0	642	** Any tables that the SrcList might point to are not duplicated.
sl@0	643	*/
sl@0	644	Expr sqlite3ExprDup(sqlite3 db, Expr *p){
sl@0	645	Expr *pNew;
sl@0	646	if( p==0 ) return 0;
sl@0	647	pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
sl@0	648	if( pNew==0 ) return 0;
sl@0	649	memcpy(pNew, p, sizeof(*pNew));
sl@0	650	if( p->token.z!=0 ){
sl@0	651	pNew->token.z = (u8)sqlite3DbStrNDup(db, (char)p->token.z, p->token.n);
sl@0	652	pNew->token.dyn = 1;
sl@0	653	}else{
sl@0	654	assert( pNew->token.z==0 );
sl@0	655	}
sl@0	656	pNew->span.z = 0;
sl@0	657	pNew->pLeft = sqlite3ExprDup(db, p->pLeft);
sl@0	658	pNew->pRight = sqlite3ExprDup(db, p->pRight);
sl@0	659	pNew->pList = sqlite3ExprListDup(db, p->pList);
sl@0	660	pNew->pSelect = sqlite3SelectDup(db, p->pSelect);
sl@0	661	return pNew;
sl@0	662	}
sl@0	663	void sqlite3TokenCopy(sqlite3 db, Token pTo, Token *pFrom){
sl@0	664	if( pTo->dyn ) sqlite3DbFree(db, (char*)pTo->z);
sl@0	665	if( pFrom->z ){
sl@0	666	pTo->n = pFrom->n;
sl@0	667	pTo->z = (u8)sqlite3DbStrNDup(db, (char)pFrom->z, pFrom->n);
sl@0	668	pTo->dyn = 1;
sl@0	669	}else{
sl@0	670	pTo->z = 0;
sl@0	671	}
sl@0	672	}
sl@0	673	ExprList sqlite3ExprListDup(sqlite3 db, ExprList *p){
sl@0	674	ExprList *pNew;
sl@0	675	struct ExprList_item pItem, pOldItem;
sl@0	676	int i;
sl@0	677	if( p==0 ) return 0;
sl@0	678	pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
sl@0	679	if( pNew==0 ) return 0;
sl@0	680	pNew->iECursor = 0;
sl@0	681	pNew->nExpr = pNew->nAlloc = p->nExpr;
sl@0	682	pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
sl@0	683	if( pItem==0 ){
sl@0	684	sqlite3DbFree(db, pNew);
sl@0	685	return 0;
sl@0	686	}
sl@0	687	pOldItem = p->a;
sl@0	688	for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
sl@0	689	Expr pNewExpr, pOldExpr;
sl@0	690	pItem->pExpr = pNewExpr = sqlite3ExprDup(db, pOldExpr = pOldItem->pExpr);
sl@0	691	if( pOldExpr->span.z!=0 && pNewExpr ){
sl@0	692	/* Always make a copy of the span for top-level expressions in the
sl@0	693	** expression list. The logic in SELECT processing that determines
sl@0	694	** the names of columns in the result set needs this information */
sl@0	695	sqlite3TokenCopy(db, &pNewExpr->span, &pOldExpr->span);
sl@0	696	}
sl@0	697	assert( pNewExpr==0 \|\| pNewExpr->span.z!=0
sl@0	698	\|\| pOldExpr->span.z==0
sl@0	699	\|\| db->mallocFailed );
sl@0	700	pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
sl@0	701	pItem->sortOrder = pOldItem->sortOrder;
sl@0	702	pItem->done = 0;
sl@0	703	pItem->iCol = pOldItem->iCol;
sl@0	704	pItem->iAlias = pOldItem->iAlias;
sl@0	705	}
sl@0	706	return pNew;
sl@0	707	}
sl@0	708
sl@0	709	/*
sl@0	710	** If cursors, triggers, views and subqueries are all omitted from
sl@0	711	** the build, then none of the following routines, except for
sl@0	712	** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
sl@0	713	** called with a NULL argument.
sl@0	714	*/
sl@0	715	#if !defined(SQLITE_OMIT_VIEW) \|\| !defined(SQLITE_OMIT_TRIGGER) \
sl@0	716	\|\| !defined(SQLITE_OMIT_SUBQUERY)
sl@0	717	SrcList sqlite3SrcListDup(sqlite3 db, SrcList *p){
sl@0	718	SrcList *pNew;
sl@0	719	int i;
sl@0	720	int nByte;
sl@0	721	if( p==0 ) return 0;
sl@0	722	nByte = sizeof(p) + (p->nSrc>0 ? sizeof(p->a[0]) (p->nSrc-1) : 0);
sl@0	723	pNew = sqlite3DbMallocRaw(db, nByte );
sl@0	724	if( pNew==0 ) return 0;
sl@0	725	pNew->nSrc = pNew->nAlloc = p->nSrc;
sl@0	726	for(i=0; i<p->nSrc; i++){
sl@0	727	struct SrcList_item *pNewItem = &pNew->a[i];
sl@0	728	struct SrcList_item *pOldItem = &p->a[i];
sl@0	729	Table *pTab;
sl@0	730	pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
sl@0	731	pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
sl@0	732	pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
sl@0	733	pNewItem->jointype = pOldItem->jointype;
sl@0	734	pNewItem->iCursor = pOldItem->iCursor;
sl@0	735	pNewItem->isPopulated = pOldItem->isPopulated;
sl@0	736	pTab = pNewItem->pTab = pOldItem->pTab;
sl@0	737	if( pTab ){
sl@0	738	pTab->nRef++;
sl@0	739	}
sl@0	740	pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect);
sl@0	741	pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn);
sl@0	742	pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
sl@0	743	pNewItem->colUsed = pOldItem->colUsed;
sl@0	744	}
sl@0	745	return pNew;
sl@0	746	}
sl@0	747	IdList sqlite3IdListDup(sqlite3 db, IdList *p){
sl@0	748	IdList *pNew;
sl@0	749	int i;
sl@0	750	if( p==0 ) return 0;
sl@0	751	pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
sl@0	752	if( pNew==0 ) return 0;
sl@0	753	pNew->nId = pNew->nAlloc = p->nId;
sl@0	754	pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
sl@0	755	if( pNew->a==0 ){
sl@0	756	sqlite3DbFree(db, pNew);
sl@0	757	return 0;
sl@0	758	}
sl@0	759	for(i=0; i<p->nId; i++){
sl@0	760	struct IdList_item *pNewItem = &pNew->a[i];
sl@0	761	struct IdList_item *pOldItem = &p->a[i];
sl@0	762	pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
sl@0	763	pNewItem->idx = pOldItem->idx;
sl@0	764	}
sl@0	765	return pNew;
sl@0	766	}
sl@0	767	Select sqlite3SelectDup(sqlite3 db, Select *p){
sl@0	768	Select *pNew;
sl@0	769	if( p==0 ) return 0;
sl@0	770	pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
sl@0	771	if( pNew==0 ) return 0;
sl@0	772	pNew->pEList = sqlite3ExprListDup(db, p->pEList);
sl@0	773	pNew->pSrc = sqlite3SrcListDup(db, p->pSrc);
sl@0	774	pNew->pWhere = sqlite3ExprDup(db, p->pWhere);
sl@0	775	pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy);
sl@0	776	pNew->pHaving = sqlite3ExprDup(db, p->pHaving);
sl@0	777	pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy);
sl@0	778	pNew->op = p->op;
sl@0	779	pNew->pPrior = sqlite3SelectDup(db, p->pPrior);
sl@0	780	pNew->pLimit = sqlite3ExprDup(db, p->pLimit);
sl@0	781	pNew->pOffset = sqlite3ExprDup(db, p->pOffset);
sl@0	782	pNew->iLimit = 0;
sl@0	783	pNew->iOffset = 0;
sl@0	784	pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
sl@0	785	pNew->pRightmost = 0;
sl@0	786	pNew->addrOpenEphm[0] = -1;
sl@0	787	pNew->addrOpenEphm[1] = -1;
sl@0	788	pNew->addrOpenEphm[2] = -1;
sl@0	789	return pNew;
sl@0	790	}
sl@0	791	#else
sl@0	792	Select sqlite3SelectDup(sqlite3 db, Select *p){
sl@0	793	assert( p==0 );
sl@0	794	return 0;
sl@0	795	}
sl@0	796	#endif
sl@0	797
sl@0	798
sl@0	799	/*
sl@0	800	** Add a new element to the end of an expression list. If pList is
sl@0	801	** initially NULL, then create a new expression list.
sl@0	802	*/
sl@0	803	ExprList *sqlite3ExprListAppend(
sl@0	804	Parse pParse, / Parsing context */
sl@0	805	ExprList pList, / List to which to append. Might be NULL */
sl@0	806	Expr pExpr, / Expression to be appended */
sl@0	807	Token pName / AS keyword for the expression */
sl@0	808	){
sl@0	809	sqlite3 *db = pParse->db;
sl@0	810	if( pList==0 ){
sl@0	811	pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
sl@0	812	if( pList==0 ){
sl@0	813	goto no_mem;
sl@0	814	}
sl@0	815	assert( pList->nAlloc==0 );
sl@0	816	}
sl@0	817	if( pList->nAlloc<=pList->nExpr ){
sl@0	818	struct ExprList_item *a;
sl@0	819	int n = pList->nAlloc*2 + 4;
sl@0	820	a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
sl@0	821	if( a==0 ){
sl@0	822	goto no_mem;
sl@0	823	}
sl@0	824	pList->a = a;
sl@0	825	pList->nAlloc = n;
sl@0	826	}
sl@0	827	assert( pList->a!=0 );
sl@0	828	if( pExpr \|\| pName ){
sl@0	829	struct ExprList_item *pItem = &pList->a[pList->nExpr++];
sl@0	830	memset(pItem, 0, sizeof(*pItem));
sl@0	831	pItem->zName = sqlite3NameFromToken(db, pName);
sl@0	832	pItem->pExpr = pExpr;
sl@0	833	pItem->iAlias = 0;
sl@0	834	}
sl@0	835	return pList;
sl@0	836
sl@0	837	no_mem:
sl@0	838	/* Avoid leaking memory if malloc has failed. */
sl@0	839	sqlite3ExprDelete(db, pExpr);
sl@0	840	sqlite3ExprListDelete(db, pList);
sl@0	841	return 0;
sl@0	842	}
sl@0	843
sl@0	844	/*
sl@0	845	** If the expression list pEList contains more than iLimit elements,
sl@0	846	** leave an error message in pParse.
sl@0	847	*/
sl@0	848	void sqlite3ExprListCheckLength(
sl@0	849	Parse *pParse,
sl@0	850	ExprList *pEList,
sl@0	851	const char *zObject
sl@0	852	){
sl@0	853	int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
sl@0	854	testcase( pEList && pEList->nExpr==mx );
sl@0	855	testcase( pEList && pEList->nExpr==mx+1 );
sl@0	856	if( pEList && pEList->nExpr>mx ){
sl@0	857	sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
sl@0	858	}
sl@0	859	}
sl@0	860
sl@0	861	/*
sl@0	862	** Delete an entire expression list.
sl@0	863	*/
sl@0	864	void sqlite3ExprListDelete(sqlite3 db, ExprList pList){
sl@0	865	int i;
sl@0	866	struct ExprList_item *pItem;
sl@0	867	if( pList==0 ) return;
sl@0	868	assert( pList->a!=0 \|\| (pList->nExpr==0 && pList->nAlloc==0) );
sl@0	869	assert( pList->nExpr<=pList->nAlloc );
sl@0	870	for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
sl@0	871	sqlite3ExprDelete(db, pItem->pExpr);
sl@0	872	sqlite3DbFree(db, pItem->zName);
sl@0	873	}
sl@0	874	sqlite3DbFree(db, pList->a);
sl@0	875	sqlite3DbFree(db, pList);
sl@0	876	}
sl@0	877
sl@0	878	/*
sl@0	879	** These routines are Walker callbacks. Walker.u.pi is a pointer
sl@0	880	** to an integer. These routines are checking an expression to see
sl@0	881	** if it is a constant. Set *Walker.u.pi to 0 if the expression is
sl@0	882	** not constant.
sl@0	883	**
sl@0	884	** These callback routines are used to implement the following:
sl@0	885	**
sl@0	886	** sqlite3ExprIsConstant()
sl@0	887	** sqlite3ExprIsConstantNotJoin()
sl@0	888	** sqlite3ExprIsConstantOrFunction()
sl@0	889	**
sl@0	890	*/
sl@0	891	static int exprNodeIsConstant(Walker pWalker, Expr pExpr){
sl@0	892
sl@0	893	/* If pWalker->u.i is 3 then any term of the expression that comes from
sl@0	894	** the ON or USING clauses of a join disqualifies the expression
sl@0	895	** from being considered constant. */
sl@0	896	if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
sl@0	897	pWalker->u.i = 0;
sl@0	898	return WRC_Abort;
sl@0	899	}
sl@0	900
sl@0	901	switch( pExpr->op ){
sl@0	902	/* Consider functions to be constant if all their arguments are constant
sl@0	903	** and pWalker->u.i==2 */
sl@0	904	case TK_FUNCTION:
sl@0	905	if( pWalker->u.i==2 ) return 0;
sl@0	906	/* Fall through */
sl@0	907	case TK_ID:
sl@0	908	case TK_COLUMN:
sl@0	909	case TK_DOT:
sl@0	910	case TK_AGG_FUNCTION:
sl@0	911	case TK_AGG_COLUMN:
sl@0	912	#ifndef SQLITE_OMIT_SUBQUERY
sl@0	913	case TK_SELECT:
sl@0	914	case TK_EXISTS:
sl@0	915	testcase( pExpr->op==TK_SELECT );
sl@0	916	testcase( pExpr->op==TK_EXISTS );
sl@0	917	#endif
sl@0	918	testcase( pExpr->op==TK_ID );
sl@0	919	testcase( pExpr->op==TK_COLUMN );
sl@0	920	testcase( pExpr->op==TK_DOT );
sl@0	921	testcase( pExpr->op==TK_AGG_FUNCTION );
sl@0	922	testcase( pExpr->op==TK_AGG_COLUMN );
sl@0	923	pWalker->u.i = 0;
sl@0	924	return WRC_Abort;
sl@0	925	default:
sl@0	926	return WRC_Continue;
sl@0	927	}
sl@0	928	}
sl@0	929	static int selectNodeIsConstant(Walker pWalker, Select pSelect){
sl@0	930	pWalker->u.i = 0;
sl@0	931	return WRC_Abort;
sl@0	932	}
sl@0	933	static int exprIsConst(Expr *p, int initFlag){
sl@0	934	Walker w;
sl@0	935	w.u.i = initFlag;
sl@0	936	w.xExprCallback = exprNodeIsConstant;
sl@0	937	w.xSelectCallback = selectNodeIsConstant;
sl@0	938	sqlite3WalkExpr(&w, p);
sl@0	939	return w.u.i;
sl@0	940	}
sl@0	941
sl@0	942	/*
sl@0	943	** Walk an expression tree. Return 1 if the expression is constant
sl@0	944	** and 0 if it involves variables or function calls.
sl@0	945	**
sl@0	946	** For the purposes of this function, a double-quoted string (ex: "abc")
sl@0	947	** is considered a variable but a single-quoted string (ex: 'abc') is
sl@0	948	** a constant.
sl@0	949	*/
sl@0	950	int sqlite3ExprIsConstant(Expr *p){
sl@0	951	return exprIsConst(p, 1);
sl@0	952	}
sl@0	953
sl@0	954	/*
sl@0	955	** Walk an expression tree. Return 1 if the expression is constant
sl@0	956	** that does no originate from the ON or USING clauses of a join.
sl@0	957	** Return 0 if it involves variables or function calls or terms from
sl@0	958	** an ON or USING clause.
sl@0	959	*/
sl@0	960	int sqlite3ExprIsConstantNotJoin(Expr *p){
sl@0	961	return exprIsConst(p, 3);
sl@0	962	}
sl@0	963
sl@0	964	/*
sl@0	965	** Walk an expression tree. Return 1 if the expression is constant
sl@0	966	** or a function call with constant arguments. Return and 0 if there
sl@0	967	** are any variables.
sl@0	968	**
sl@0	969	** For the purposes of this function, a double-quoted string (ex: "abc")
sl@0	970	** is considered a variable but a single-quoted string (ex: 'abc') is
sl@0	971	** a constant.
sl@0	972	*/
sl@0	973	int sqlite3ExprIsConstantOrFunction(Expr *p){
sl@0	974	return exprIsConst(p, 2);
sl@0	975	}
sl@0	976
sl@0	977	/*
sl@0	978	** If the expression p codes a constant integer that is small enough
sl@0	979	** to fit in a 32-bit integer, return 1 and put the value of the integer
sl@0	980	** in *pValue. If the expression is not an integer or if it is too big
sl@0	981	** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
sl@0	982	*/
sl@0	983	int sqlite3ExprIsInteger(Expr p, int pValue){
sl@0	984	int rc = 0;
sl@0	985	if( p->flags & EP_IntValue ){
sl@0	986	*pValue = p->iTable;
sl@0	987	return 1;
sl@0	988	}
sl@0	989	switch( p->op ){
sl@0	990	case TK_INTEGER: {
sl@0	991	rc = sqlite3GetInt32((char*)p->token.z, pValue);
sl@0	992	break;
sl@0	993	}
sl@0	994	case TK_UPLUS: {
sl@0	995	rc = sqlite3ExprIsInteger(p->pLeft, pValue);
sl@0	996	break;
sl@0	997	}
sl@0	998	case TK_UMINUS: {
sl@0	999	int v;
sl@0	1000	if( sqlite3ExprIsInteger(p->pLeft, &v) ){
sl@0	1001	*pValue = -v;
sl@0	1002	rc = 1;
sl@0	1003	}
sl@0	1004	break;
sl@0	1005	}
sl@0	1006	default: break;
sl@0	1007	}
sl@0	1008	if( rc ){
sl@0	1009	p->op = TK_INTEGER;
sl@0	1010	p->flags \|= EP_IntValue;
sl@0	1011	p->iTable = *pValue;
sl@0	1012	}
sl@0	1013	return rc;
sl@0	1014	}
sl@0	1015
sl@0	1016	/*
sl@0	1017	** Return TRUE if the given string is a row-id column name.
sl@0	1018	*/
sl@0	1019	int sqlite3IsRowid(const char *z){
sl@0	1020	if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
sl@0	1021	if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
sl@0	1022	if( sqlite3StrICmp(z, "OID")==0 ) return 1;
sl@0	1023	return 0;
sl@0	1024	}
sl@0	1025
sl@0	1026	#ifdef SQLITE_TEST
sl@0	1027	int sqlite3_enable_in_opt = 1;
sl@0	1028	#else
sl@0	1029	#define sqlite3_enable_in_opt 1
sl@0	1030	#endif
sl@0	1031
sl@0	1032	/*
sl@0	1033	** Return true if the IN operator optimization is enabled and
sl@0	1034	** the SELECT statement p exists and is of the
sl@0	1035	** simple form:
sl@0	1036	**
sl@0	1037	** SELECT <column> FROM <table>
sl@0	1038	**
sl@0	1039	** If this is the case, it may be possible to use an existing table
sl@0	1040	** or index instead of generating an epheremal table.
sl@0	1041	*/
sl@0	1042	#ifndef SQLITE_OMIT_SUBQUERY
sl@0	1043	static int isCandidateForInOpt(Select *p){
sl@0	1044	SrcList *pSrc;
sl@0	1045	ExprList *pEList;
sl@0	1046	Table *pTab;
sl@0	1047	if( !sqlite3_enable_in_opt ) return 0; /* IN optimization must be enabled */
sl@0	1048	if( p==0 ) return 0; /* right-hand side of IN is SELECT */
sl@0	1049	if( p->pPrior ) return 0; /* Not a compound SELECT */
sl@0	1050	if( p->selFlags & (SF_Distinct\|SF_Aggregate) ){
sl@0	1051	return 0; /* No DISTINCT keyword and no aggregate functions */
sl@0	1052	}
sl@0	1053	if( p->pGroupBy ) return 0; /* Has no GROUP BY clause */
sl@0	1054	if( p->pLimit ) return 0; /* Has no LIMIT clause */
sl@0	1055	if( p->pOffset ) return 0;
sl@0	1056	if( p->pWhere ) return 0; /* Has no WHERE clause */
sl@0	1057	pSrc = p->pSrc;
sl@0	1058	if( pSrc==0 ) return 0; /* A single table in the FROM clause */
sl@0	1059	if( pSrc->nSrc!=1 ) return 0;
sl@0	1060	if( pSrc->a[0].pSelect ) return 0; /* FROM clause is not a subquery */
sl@0	1061	pTab = pSrc->a[0].pTab;
sl@0	1062	if( pTab==0 ) return 0;
sl@0	1063	if( pTab->pSelect ) return 0; /* FROM clause is not a view */
sl@0	1064	if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
sl@0	1065	pEList = p->pEList;
sl@0	1066	if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
sl@0	1067	if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
sl@0	1068	return 1;
sl@0	1069	}
sl@0	1070	#endif /* SQLITE_OMIT_SUBQUERY */
sl@0	1071
sl@0	1072	/*
sl@0	1073	** This function is used by the implementation of the IN (...) operator.
sl@0	1074	** It's job is to find or create a b-tree structure that may be used
sl@0	1075	** either to test for membership of the (...) set or to iterate through
sl@0	1076	** its members, skipping duplicates.
sl@0	1077	**
sl@0	1078	** The cursor opened on the structure (database table, database index
sl@0	1079	** or ephermal table) is stored in pX->iTable before this function returns.
sl@0	1080	** The returned value indicates the structure type, as follows:
sl@0	1081	**
sl@0	1082	** IN_INDEX_ROWID - The cursor was opened on a database table.
sl@0	1083	** IN_INDEX_INDEX - The cursor was opened on a database index.
sl@0	1084	** IN_INDEX_EPH - The cursor was opened on a specially created and
sl@0	1085	** populated epheremal table.
sl@0	1086	**
sl@0	1087	** An existing structure may only be used if the SELECT is of the simple
sl@0	1088	** form:
sl@0	1089	**
sl@0	1090	** SELECT <column> FROM <table>
sl@0	1091	**
sl@0	1092	** If prNotFound parameter is 0, then the structure will be used to iterate
sl@0	1093	** through the set members, skipping any duplicates. In this case an
sl@0	1094	** epheremal table must be used unless the selected <column> is guaranteed
sl@0	1095	** to be unique - either because it is an INTEGER PRIMARY KEY or it
sl@0	1096	** is unique by virtue of a constraint or implicit index.
sl@0	1097	**
sl@0	1098	** If the prNotFound parameter is not 0, then the structure will be used
sl@0	1099	** for fast set membership tests. In this case an epheremal table must
sl@0	1100	** be used unless <column> is an INTEGER PRIMARY KEY or an index can
sl@0	1101	** be found with <column> as its left-most column.
sl@0	1102	**
sl@0	1103	** When the structure is being used for set membership tests, the user
sl@0	1104	** needs to know whether or not the structure contains an SQL NULL
sl@0	1105	** value in order to correctly evaluate expressions like "X IN (Y, Z)".
sl@0	1106	** If there is a chance that the structure may contain a NULL value at
sl@0	1107	** runtime, then a register is allocated and the register number written
sl@0	1108	** to *prNotFound. If there is no chance that the structure contains a
sl@0	1109	** NULL value, then *prNotFound is left unchanged.
sl@0	1110	**
sl@0	1111	** If a register is allocated and its location stored in *prNotFound, then
sl@0	1112	** its initial value is NULL. If the structure does not remain constant
sl@0	1113	** for the duration of the query (i.e. the set is a correlated sub-select),
sl@0	1114	** the value of the allocated register is reset to NULL each time the
sl@0	1115	** structure is repopulated. This allows the caller to use vdbe code
sl@0	1116	** equivalent to the following:
sl@0	1117	**
sl@0	1118	** if( register==NULL ){
sl@0	1119	** has_null = <test if data structure contains null>
sl@0	1120	** register = 1
sl@0	1121	** }
sl@0	1122	**
sl@0	1123	** in order to avoid running the <test if data structure contains null>
sl@0	1124	** test more often than is necessary.
sl@0	1125	*/
sl@0	1126	#ifndef SQLITE_OMIT_SUBQUERY
sl@0	1127	int sqlite3FindInIndex(Parse pParse, Expr pX, int *prNotFound){
sl@0	1128	Select *p;
sl@0	1129	int eType = 0;
sl@0	1130	int iTab = pParse->nTab++;
sl@0	1131	int mustBeUnique = !prNotFound;
sl@0	1132
sl@0	1133	/* The follwing if(...) expression is true if the SELECT is of the
sl@0	1134	** simple form:
sl@0	1135	**
sl@0	1136	** SELECT <column> FROM <table>
sl@0	1137	**
sl@0	1138	** If this is the case, it may be possible to use an existing table
sl@0	1139	** or index instead of generating an epheremal table.
sl@0	1140	*/
sl@0	1141	p = pX->pSelect;
sl@0	1142	if( isCandidateForInOpt(p) ){
sl@0	1143	sqlite3 *db = pParse->db;
sl@0	1144	Index *pIdx;
sl@0	1145	Expr *pExpr = p->pEList->a[0].pExpr;
sl@0	1146	int iCol = pExpr->iColumn;
sl@0	1147	Vdbe *v = sqlite3GetVdbe(pParse);
sl@0	1148
sl@0	1149	/* This function is only called from two places. In both cases the vdbe
sl@0	1150	** has already been allocated. So assume sqlite3GetVdbe() is always
sl@0	1151	** successful here.
sl@0	1152	*/
sl@0	1153	assert(v);
sl@0	1154	if( iCol<0 ){
sl@0	1155	int iMem = ++pParse->nMem;
sl@0	1156	int iAddr;
sl@0	1157	Table *pTab = p->pSrc->a[0].pTab;
sl@0	1158	int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
sl@0	1159	sqlite3VdbeUsesBtree(v, iDb);
sl@0	1160
sl@0	1161	iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
sl@0	1162	sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
sl@0	1163
sl@0	1164	sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
sl@0	1165	eType = IN_INDEX_ROWID;
sl@0	1166
sl@0	1167	sqlite3VdbeJumpHere(v, iAddr);
sl@0	1168	}else{
sl@0	1169	/* The collation sequence used by the comparison. If an index is to
sl@0	1170	** be used in place of a temp-table, it must be ordered according
sl@0	1171	** to this collation sequence.
sl@0	1172	*/
sl@0	1173	CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
sl@0	1174
sl@0	1175	/* Check that the affinity that will be used to perform the
sl@0	1176	** comparison is the same as the affinity of the column. If
sl@0	1177	** it is not, it is not possible to use any index.
sl@0	1178	*/
sl@0	1179	Table *pTab = p->pSrc->a[0].pTab;
sl@0	1180	char aff = comparisonAffinity(pX);
sl@0	1181	int affinity_ok = (pTab->aCol[iCol].affinity==aff\|\|aff==SQLITE_AFF_NONE);
sl@0	1182
sl@0	1183	for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
sl@0	1184	if( (pIdx->aiColumn[0]==iCol)
sl@0	1185	&& (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
sl@0	1186	&& (!mustBeUnique \|\| (pIdx->nColumn==1 && pIdx->onError!=OE_None))
sl@0	1187	){
sl@0	1188	int iDb;
sl@0	1189	int iMem = ++pParse->nMem;
sl@0	1190	int iAddr;
sl@0	1191	char *pKey;
sl@0	1192
sl@0	1193	pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
sl@0	1194	iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
sl@0	1195	sqlite3VdbeUsesBtree(v, iDb);
sl@0	1196
sl@0	1197	iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
sl@0	1198	sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
sl@0	1199
sl@0	1200	sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pIdx->nColumn);
sl@0	1201	sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
sl@0	1202	pKey,P4_KEYINFO_HANDOFF);
sl@0	1203	VdbeComment((v, "%s", pIdx->zName));
sl@0	1204	eType = IN_INDEX_INDEX;
sl@0	1205
sl@0	1206	sqlite3VdbeJumpHere(v, iAddr);
sl@0	1207	if( prNotFound && !pTab->aCol[iCol].notNull ){
sl@0	1208	*prNotFound = ++pParse->nMem;
sl@0	1209	}
sl@0	1210	}
sl@0	1211	}
sl@0	1212	}
sl@0	1213	}
sl@0	1214
sl@0	1215	if( eType==0 ){
sl@0	1216	int rMayHaveNull = 0;
sl@0	1217	eType = IN_INDEX_EPH;
sl@0	1218	if( prNotFound ){
sl@0	1219	*prNotFound = rMayHaveNull = ++pParse->nMem;
sl@0	1220	}else if( pX->pLeft->iColumn<0 && pX->pSelect==0 ){
sl@0	1221	eType = IN_INDEX_ROWID;
sl@0	1222	}
sl@0	1223	sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
sl@0	1224	}else{
sl@0	1225	pX->iTable = iTab;
sl@0	1226	}
sl@0	1227	return eType;
sl@0	1228	}
sl@0	1229	#endif
sl@0	1230
sl@0	1231	/*
sl@0	1232	** Generate code for scalar subqueries used as an expression
sl@0	1233	** and IN operators. Examples:
sl@0	1234	**
sl@0	1235	** (SELECT a FROM b) -- subquery
sl@0	1236	** EXISTS (SELECT a FROM b) -- EXISTS subquery
sl@0	1237	** x IN (4,5,11) -- IN operator with list on right-hand side
sl@0	1238	** x IN (SELECT a FROM b) -- IN operator with subquery on the right
sl@0	1239	**
sl@0	1240	** The pExpr parameter describes the expression that contains the IN
sl@0	1241	** operator or subquery.
sl@0	1242	**
sl@0	1243	** If parameter isRowid is non-zero, then expression pExpr is guaranteed
sl@0	1244	** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
sl@0	1245	** to some integer key column of a table B-Tree. In this case, use an
sl@0	1246	** intkey B-Tree to store the set of IN(...) values instead of the usual
sl@0	1247	** (slower) variable length keys B-Tree.
sl@0	1248	*/
sl@0	1249	#ifndef SQLITE_OMIT_SUBQUERY
sl@0	1250	void sqlite3CodeSubselect(
sl@0	1251	Parse *pParse,
sl@0	1252	Expr *pExpr,
sl@0	1253	int rMayHaveNull,
sl@0	1254	int isRowid
sl@0	1255	){
sl@0	1256	int testAddr = 0; /* One-time test address */
sl@0	1257	Vdbe *v = sqlite3GetVdbe(pParse);
sl@0	1258	if( v==0 ) return;
sl@0	1259
sl@0	1260
sl@0	1261	/* This code must be run in its entirety every time it is encountered
sl@0	1262	** if any of the following is true:
sl@0	1263	**
sl@0	1264	** * The right-hand side is a correlated subquery
sl@0	1265	** * The right-hand side is an expression list containing variables
sl@0	1266	** * We are inside a trigger
sl@0	1267	**
sl@0	1268	** If all of the above are false, then we can run this code just once
sl@0	1269	** save the results, and reuse the same result on subsequent invocations.
sl@0	1270	*/
sl@0	1271	if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
sl@0	1272	int mem = ++pParse->nMem;
sl@0	1273	sqlite3VdbeAddOp1(v, OP_If, mem);
sl@0	1274	testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
sl@0	1275	assert( testAddr>0 \|\| pParse->db->mallocFailed );
sl@0	1276	}
sl@0	1277
sl@0	1278	switch( pExpr->op ){
sl@0	1279	case TK_IN: {
sl@0	1280	char affinity;
sl@0	1281	KeyInfo keyInfo;
sl@0	1282	int addr; /* Address of OP_OpenEphemeral instruction */
sl@0	1283	Expr *pLeft = pExpr->pLeft;
sl@0	1284
sl@0	1285	if( rMayHaveNull ){
sl@0	1286	sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
sl@0	1287	}
sl@0	1288
sl@0	1289	affinity = sqlite3ExprAffinity(pLeft);
sl@0	1290
sl@0	1291	/* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
sl@0	1292	** expression it is handled the same way. A virtual table is
sl@0	1293	** filled with single-field index keys representing the results
sl@0	1294	** from the SELECT or the <exprlist>.
sl@0	1295	**
sl@0	1296	** If the 'x' expression is a column value, or the SELECT...
sl@0	1297	** statement returns a column value, then the affinity of that
sl@0	1298	** column is used to build the index keys. If both 'x' and the
sl@0	1299	** SELECT... statement are columns, then numeric affinity is used
sl@0	1300	** if either column has NUMERIC or INTEGER affinity. If neither
sl@0	1301	** 'x' nor the SELECT... statement are columns, then numeric affinity
sl@0	1302	** is used.
sl@0	1303	*/
sl@0	1304	pExpr->iTable = pParse->nTab++;
sl@0	1305	addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
sl@0	1306	memset(&keyInfo, 0, sizeof(keyInfo));
sl@0	1307	keyInfo.nField = 1;
sl@0	1308
sl@0	1309	if( pExpr->pSelect ){
sl@0	1310	/* Case 1: expr IN (SELECT ...)
sl@0	1311	**
sl@0	1312	** Generate code to write the results of the select into the temporary
sl@0	1313	** table allocated and opened above.
sl@0	1314	*/
sl@0	1315	SelectDest dest;
sl@0	1316	ExprList *pEList;
sl@0	1317
sl@0	1318	assert( !isRowid );
sl@0	1319	sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
sl@0	1320	dest.affinity = (int)affinity;
sl@0	1321	assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
sl@0	1322	if( sqlite3Select(pParse, pExpr->pSelect, &dest) ){
sl@0	1323	return;
sl@0	1324	}
sl@0	1325	pEList = pExpr->pSelect->pEList;
sl@0	1326	if( pEList && pEList->nExpr>0 ){
sl@0	1327	keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
sl@0	1328	pEList->a[0].pExpr);
sl@0	1329	}
sl@0	1330	}else if( pExpr->pList ){
sl@0	1331	/* Case 2: expr IN (exprlist)
sl@0	1332	**
sl@0	1333	** For each expression, build an index key from the evaluation and
sl@0	1334	** store it in the temporary table. If <expr> is a column, then use
sl@0	1335	** that columns affinity when building index keys. If <expr> is not
sl@0	1336	** a column, use numeric affinity.
sl@0	1337	*/
sl@0	1338	int i;
sl@0	1339	ExprList *pList = pExpr->pList;
sl@0	1340	struct ExprList_item *pItem;
sl@0	1341	int r1, r2, r3;
sl@0	1342
sl@0	1343	if( !affinity ){
sl@0	1344	affinity = SQLITE_AFF_NONE;
sl@0	1345	}
sl@0	1346	keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
sl@0	1347
sl@0	1348	/* Loop through each expression in <exprlist>. */
sl@0	1349	r1 = sqlite3GetTempReg(pParse);
sl@0	1350	r2 = sqlite3GetTempReg(pParse);
sl@0	1351	for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
sl@0	1352	Expr *pE2 = pItem->pExpr;
sl@0	1353
sl@0	1354	/* If the expression is not constant then we will need to
sl@0	1355	** disable the test that was generated above that makes sure
sl@0	1356	** this code only executes once. Because for a non-constant
sl@0	1357	** expression we need to rerun this code each time.
sl@0	1358	*/
sl@0	1359	if( testAddr && !sqlite3ExprIsConstant(pE2) ){
sl@0	1360	sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
sl@0	1361	testAddr = 0;
sl@0	1362	}
sl@0	1363
sl@0	1364	/* Evaluate the expression and insert it into the temp table */
sl@0	1365	pParse->disableColCache++;
sl@0	1366	r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
sl@0	1367	assert( pParse->disableColCache>0 );
sl@0	1368	pParse->disableColCache--;
sl@0	1369
sl@0	1370	if( isRowid ){
sl@0	1371	sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
sl@0	1372	sqlite3VdbeAddOp2(v, OP_MustBeInt, r3, sqlite3VdbeCurrentAddr(v)+2);
sl@0	1373	sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
sl@0	1374	}else{
sl@0	1375	sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
sl@0	1376	sqlite3ExprCacheAffinityChange(pParse, r3, 1);
sl@0	1377	sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
sl@0	1378	}
sl@0	1379	}
sl@0	1380	sqlite3ReleaseTempReg(pParse, r1);
sl@0	1381	sqlite3ReleaseTempReg(pParse, r2);
sl@0	1382	}
sl@0	1383	if( !isRowid ){
sl@0	1384	sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
sl@0	1385	}
sl@0	1386	break;
sl@0	1387	}
sl@0	1388
sl@0	1389	case TK_EXISTS:
sl@0	1390	case TK_SELECT: {
sl@0	1391	/* This has to be a scalar SELECT. Generate code to put the
sl@0	1392	** value of this select in a memory cell and record the number
sl@0	1393	** of the memory cell in iColumn.
sl@0	1394	*/
sl@0	1395	static const Token one = { (u8*)"1", 0, 1 };
sl@0	1396	Select *pSel;
sl@0	1397	SelectDest dest;
sl@0	1398
sl@0	1399	pSel = pExpr->pSelect;
sl@0	1400	sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
sl@0	1401	if( pExpr->op==TK_SELECT ){
sl@0	1402	dest.eDest = SRT_Mem;
sl@0	1403	sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
sl@0	1404	VdbeComment((v, "Init subquery result"));
sl@0	1405	}else{
sl@0	1406	dest.eDest = SRT_Exists;
sl@0	1407	sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
sl@0	1408	VdbeComment((v, "Init EXISTS result"));
sl@0	1409	}
sl@0	1410	sqlite3ExprDelete(pParse->db, pSel->pLimit);
sl@0	1411	pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
sl@0	1412	if( sqlite3Select(pParse, pSel, &dest) ){
sl@0	1413	return;
sl@0	1414	}
sl@0	1415	pExpr->iColumn = dest.iParm;
sl@0	1416	break;
sl@0	1417	}
sl@0	1418	}
sl@0	1419
sl@0	1420	if( testAddr ){
sl@0	1421	sqlite3VdbeJumpHere(v, testAddr-1);
sl@0	1422	}
sl@0	1423
sl@0	1424	return;
sl@0	1425	}
sl@0	1426	#endif /* SQLITE_OMIT_SUBQUERY */
sl@0	1427
sl@0	1428	/*
sl@0	1429	** Duplicate an 8-byte value
sl@0	1430	*/
sl@0	1431	static char dup8bytes(Vdbe v, const char *in){
sl@0	1432	char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
sl@0	1433	if( out ){
sl@0	1434	memcpy(out, in, 8);
sl@0	1435	}
sl@0	1436	return out;
sl@0	1437	}
sl@0	1438
sl@0	1439	/*
sl@0	1440	** Generate an instruction that will put the floating point
sl@0	1441	** value described by z[0..n-1] into register iMem.
sl@0	1442	**
sl@0	1443	** The z[] string will probably not be zero-terminated. But the
sl@0	1444	** z[n] character is guaranteed to be something that does not look
sl@0	1445	** like the continuation of the number.
sl@0	1446	*/
sl@0	1447	static void codeReal(Vdbe v, const char z, int n, int negateFlag, int iMem){
sl@0	1448	assert( z \|\| v==0 \|\| sqlite3VdbeDb(v)->mallocFailed );
sl@0	1449	if( z ){
sl@0	1450	double value;
sl@0	1451	char *zV;
sl@0	1452	assert( !isdigit(z[n]) );
sl@0	1453	sqlite3AtoF(z, &value);
sl@0	1454	if( sqlite3IsNaN(value) ){
sl@0	1455	sqlite3VdbeAddOp2(v, OP_Null, 0, iMem);
sl@0	1456	}else{
sl@0	1457	if( negateFlag ) value = -value;
sl@0	1458	zV = dup8bytes(v, (char*)&value);
sl@0	1459	sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
sl@0	1460	}
sl@0	1461	}
sl@0	1462	}
sl@0	1463
sl@0	1464
sl@0	1465	/*
sl@0	1466	** Generate an instruction that will put the integer describe by
sl@0	1467	** text z[0..n-1] into register iMem.
sl@0	1468	**
sl@0	1469	** The z[] string will probably not be zero-terminated. But the
sl@0	1470	** z[n] character is guaranteed to be something that does not look
sl@0	1471	** like the continuation of the number.
sl@0	1472	*/
sl@0	1473	static void codeInteger(Vdbe v, Expr pExpr, int negFlag, int iMem){
sl@0	1474	const char *z;
sl@0	1475	if( pExpr->flags & EP_IntValue ){
sl@0	1476	int i = pExpr->iTable;
sl@0	1477	if( negFlag ) i = -i;
sl@0	1478	sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
sl@0	1479	}else if( (z = (char*)pExpr->token.z)!=0 ){
sl@0	1480	int i;
sl@0	1481	int n = pExpr->token.n;
sl@0	1482	assert( !isdigit(z[n]) );
sl@0	1483	if( sqlite3GetInt32(z, &i) ){
sl@0	1484	if( negFlag ) i = -i;
sl@0	1485	sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
sl@0	1486	}else if( sqlite3FitsIn64Bits(z, negFlag) ){
sl@0	1487	i64 value;
sl@0	1488	char *zV;
sl@0	1489	sqlite3Atoi64(z, &value);
sl@0	1490	if( negFlag ) value = -value;
sl@0	1491	zV = dup8bytes(v, (char*)&value);
sl@0	1492	sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
sl@0	1493	}else{
sl@0	1494	codeReal(v, z, n, negFlag, iMem);
sl@0	1495	}
sl@0	1496	}
sl@0	1497	}
sl@0	1498
sl@0	1499
sl@0	1500	/*
sl@0	1501	** Generate code that will extract the iColumn-th column from
sl@0	1502	** table pTab and store the column value in a register. An effort
sl@0	1503	** is made to store the column value in register iReg, but this is
sl@0	1504	** not guaranteed. The location of the column value is returned.
sl@0	1505	**
sl@0	1506	** There must be an open cursor to pTab in iTable when this routine
sl@0	1507	** is called. If iColumn<0 then code is generated that extracts the rowid.
sl@0	1508	**
sl@0	1509	** This routine might attempt to reuse the value of the column that
sl@0	1510	** has already been loaded into a register. The value will always
sl@0	1511	** be used if it has not undergone any affinity changes. But if
sl@0	1512	** an affinity change has occurred, then the cached value will only be
sl@0	1513	** used if allowAffChng is true.
sl@0	1514	*/
sl@0	1515	int sqlite3ExprCodeGetColumn(
sl@0	1516	Parse pParse, / Parsing and code generating context */
sl@0	1517	Table pTab, / Description of the table we are reading from */
sl@0	1518	int iColumn, /* Index of the table column */
sl@0	1519	int iTable, /* The cursor pointing to the table */
sl@0	1520	int iReg, /* Store results here */
sl@0	1521	int allowAffChng /* True if prior affinity changes are OK */
sl@0	1522	){
sl@0	1523	Vdbe *v = pParse->pVdbe;
sl@0	1524	int i;
sl@0	1525	struct yColCache *p;
sl@0	1526
sl@0	1527	for(i=0, p=pParse->aColCache; i<pParse->nColCache; i++, p++){
sl@0	1528	if( p->iTable==iTable && p->iColumn==iColumn
sl@0	1529	&& (!p->affChange \|\| allowAffChng) ){
sl@0	1530	#if 0
sl@0	1531	sqlite3VdbeAddOp0(v, OP_Noop);
sl@0	1532	VdbeComment((v, "OPT: tab%d.col%d -> r%d", iTable, iColumn, p->iReg));
sl@0	1533	#endif
sl@0	1534	return p->iReg;
sl@0	1535	}
sl@0	1536	}
sl@0	1537	assert( v!=0 );
sl@0	1538	if( iColumn<0 ){
sl@0	1539	int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;
sl@0	1540	sqlite3VdbeAddOp2(v, op, iTable, iReg);
sl@0	1541	}else if( pTab==0 ){
sl@0	1542	sqlite3VdbeAddOp3(v, OP_Column, iTable, iColumn, iReg);
sl@0	1543	}else{
sl@0	1544	int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
sl@0	1545	sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
sl@0	1546	sqlite3ColumnDefault(v, pTab, iColumn);
sl@0	1547	#ifndef SQLITE_OMIT_FLOATING_POINT
sl@0	1548	if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){
sl@0	1549	sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
sl@0	1550	}
sl@0	1551	#endif
sl@0	1552	}
sl@0	1553	if( pParse->disableColCache==0 ){
sl@0	1554	i = pParse->iColCache;
sl@0	1555	p = &pParse->aColCache[i];
sl@0	1556	p->iTable = iTable;
sl@0	1557	p->iColumn = iColumn;
sl@0	1558	p->iReg = iReg;
sl@0	1559	p->affChange = 0;
sl@0	1560	i++;
sl@0	1561	if( i>=ArraySize(pParse->aColCache) ) i = 0;
sl@0	1562	if( i>pParse->nColCache ) pParse->nColCache = i;
sl@0	1563	pParse->iColCache = i;
sl@0	1564	}
sl@0	1565	return iReg;
sl@0	1566	}
sl@0	1567
sl@0	1568	/*
sl@0	1569	** Clear all column cache entries associated with the vdbe
sl@0	1570	** cursor with cursor number iTable.
sl@0	1571	*/
sl@0	1572	void sqlite3ExprClearColumnCache(Parse *pParse, int iTable){
sl@0	1573	if( iTable<0 ){
sl@0	1574	pParse->nColCache = 0;
sl@0	1575	pParse->iColCache = 0;
sl@0	1576	}else{
sl@0	1577	int i;
sl@0	1578	for(i=0; i<pParse->nColCache; i++){
sl@0	1579	if( pParse->aColCache[i].iTable==iTable ){
sl@0	1580	testcase( i==pParse->nColCache-1 );
sl@0	1581	pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
sl@0	1582	pParse->iColCache = pParse->nColCache;
sl@0	1583	}
sl@0	1584	}
sl@0	1585	}
sl@0	1586	}
sl@0	1587
sl@0	1588	/*
sl@0	1589	** Record the fact that an affinity change has occurred on iCount
sl@0	1590	** registers starting with iStart.
sl@0	1591	*/
sl@0	1592	void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
sl@0	1593	int iEnd = iStart + iCount - 1;
sl@0	1594	int i;
sl@0	1595	for(i=0; i<pParse->nColCache; i++){
sl@0	1596	int r = pParse->aColCache[i].iReg;
sl@0	1597	if( r>=iStart && r<=iEnd ){
sl@0	1598	pParse->aColCache[i].affChange = 1;
sl@0	1599	}
sl@0	1600	}
sl@0	1601	}
sl@0	1602
sl@0	1603	/*
sl@0	1604	** Generate code to move content from registers iFrom...iFrom+nReg-1
sl@0	1605	** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
sl@0	1606	*/
sl@0	1607	void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
sl@0	1608	int i;
sl@0	1609	if( iFrom==iTo ) return;
sl@0	1610	sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
sl@0	1611	for(i=0; i<pParse->nColCache; i++){
sl@0	1612	int x = pParse->aColCache[i].iReg;
sl@0	1613	if( x>=iFrom && x<iFrom+nReg ){
sl@0	1614	pParse->aColCache[i].iReg += iTo-iFrom;
sl@0	1615	}
sl@0	1616	}
sl@0	1617	}
sl@0	1618
sl@0	1619	/*
sl@0	1620	** Generate code to copy content from registers iFrom...iFrom+nReg-1
sl@0	1621	** over to iTo..iTo+nReg-1.
sl@0	1622	*/
sl@0	1623	void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
sl@0	1624	int i;
sl@0	1625	if( iFrom==iTo ) return;
sl@0	1626	for(i=0; i<nReg; i++){
sl@0	1627	sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
sl@0	1628	}
sl@0	1629	}
sl@0	1630
sl@0	1631	/*
sl@0	1632	** Return true if any register in the range iFrom..iTo (inclusive)
sl@0	1633	** is used as part of the column cache.
sl@0	1634	*/
sl@0	1635	static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
sl@0	1636	int i;
sl@0	1637	for(i=0; i<pParse->nColCache; i++){
sl@0	1638	int r = pParse->aColCache[i].iReg;
sl@0	1639	if( r>=iFrom && r<=iTo ) return 1;
sl@0	1640	}
sl@0	1641	return 0;
sl@0	1642	}
sl@0	1643
sl@0	1644	/*
sl@0	1645	** Theres is a value in register iCurrent. We ultimately want
sl@0	1646	** the value to be in register iTarget. It might be that
sl@0	1647	** iCurrent and iTarget are the same register.
sl@0	1648	**
sl@0	1649	** We are going to modify the value, so we need to make sure it
sl@0	1650	** is not a cached register. If iCurrent is a cached register,
sl@0	1651	** then try to move the value over to iTarget. If iTarget is a
sl@0	1652	** cached register, then clear the corresponding cache line.
sl@0	1653	**
sl@0	1654	** Return the register that the value ends up in.
sl@0	1655	*/
sl@0	1656	int sqlite3ExprWritableRegister(Parse *pParse, int iCurrent, int iTarget){
sl@0	1657	int i;
sl@0	1658	assert( pParse->pVdbe!=0 );
sl@0	1659	if( !usedAsColumnCache(pParse, iCurrent, iCurrent) ){
sl@0	1660	return iCurrent;
sl@0	1661	}
sl@0	1662	if( iCurrent!=iTarget ){
sl@0	1663	sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, iCurrent, iTarget);
sl@0	1664	}
sl@0	1665	for(i=0; i<pParse->nColCache; i++){
sl@0	1666	if( pParse->aColCache[i].iReg==iTarget ){
sl@0	1667	pParse->aColCache[i] = pParse->aColCache[--pParse->nColCache];
sl@0	1668	pParse->iColCache = pParse->nColCache;
sl@0	1669	}
sl@0	1670	}
sl@0	1671	return iTarget;
sl@0	1672	}
sl@0	1673
sl@0	1674	/*
sl@0	1675	** If the last instruction coded is an ephemeral copy of any of
sl@0	1676	** the registers in the nReg registers beginning with iReg, then
sl@0	1677	** convert the last instruction from OP_SCopy to OP_Copy.
sl@0	1678	*/
sl@0	1679	void sqlite3ExprHardCopy(Parse *pParse, int iReg, int nReg){
sl@0	1680	int addr;
sl@0	1681	VdbeOp *pOp;
sl@0	1682	Vdbe *v;
sl@0	1683
sl@0	1684	v = pParse->pVdbe;
sl@0	1685	addr = sqlite3VdbeCurrentAddr(v);
sl@0	1686	pOp = sqlite3VdbeGetOp(v, addr-1);
sl@0	1687	assert( pOp \|\| pParse->db->mallocFailed );
sl@0	1688	if( pOp && pOp->opcode==OP_SCopy && pOp->p1>=iReg && pOp->p1<iReg+nReg ){
sl@0	1689	pOp->opcode = OP_Copy;
sl@0	1690	}
sl@0	1691	}
sl@0	1692
sl@0	1693	/*
sl@0	1694	** Generate code to store the value of the iAlias-th alias in register
sl@0	1695	** target. The first time this is called, pExpr is evaluated to compute
sl@0	1696	** the value of the alias. The value is stored in an auxiliary register
sl@0	1697	** and the number of that register is returned. On subsequent calls,
sl@0	1698	** the register number is returned without generating any code.
sl@0	1699	**
sl@0	1700	** Note that in order for this to work, code must be generated in the
sl@0	1701	** same order that it is executed.
sl@0	1702	**
sl@0	1703	** Aliases are numbered starting with 1. So iAlias is in the range
sl@0	1704	** of 1 to pParse->nAlias inclusive.
sl@0	1705	**
sl@0	1706	** pParse->aAlias[iAlias-1] records the register number where the value
sl@0	1707	** of the iAlias-th alias is stored. If zero, that means that the
sl@0	1708	** alias has not yet been computed.
sl@0	1709	*/
sl@0	1710	static int codeAlias(Parse pParse, int iAlias, Expr pExpr){
sl@0	1711	sqlite3 *db = pParse->db;
sl@0	1712	int iReg;
sl@0	1713	if( pParse->aAlias==0 ){
sl@0	1714	pParse->aAlias = sqlite3DbMallocZero(db,
sl@0	1715	sizeof(pParse->aAlias[0])*pParse->nAlias );
sl@0	1716	if( db->mallocFailed ) return 0;
sl@0	1717	}
sl@0	1718	assert( iAlias>0 && iAlias<=pParse->nAlias );
sl@0	1719	iReg = pParse->aAlias[iAlias-1];
sl@0	1720	if( iReg==0 ){
sl@0	1721	iReg = ++pParse->nMem;
sl@0	1722	sqlite3ExprCode(pParse, pExpr, iReg);
sl@0	1723	pParse->aAlias[iAlias-1] = iReg;
sl@0	1724	}
sl@0	1725	return iReg;
sl@0	1726	}
sl@0	1727
sl@0	1728	/*
sl@0	1729	** Generate code into the current Vdbe to evaluate the given
sl@0	1730	** expression. Attempt to store the results in register "target".
sl@0	1731	** Return the register where results are stored.
sl@0	1732	**
sl@0	1733	** With this routine, there is no guarantee that results will
sl@0	1734	** be stored in target. The result might be stored in some other
sl@0	1735	** register if it is convenient to do so. The calling function
sl@0	1736	** must check the return code and move the results to the desired
sl@0	1737	** register.
sl@0	1738	*/
sl@0	1739	int sqlite3ExprCodeTarget(Parse pParse, Expr pExpr, int target){
sl@0	1740	Vdbe v = pParse->pVdbe; / The VM under construction */
sl@0	1741	int op; /* The opcode being coded */
sl@0	1742	int inReg = target; /* Results stored in register inReg */
sl@0	1743	int regFree1 = 0; /* If non-zero free this temporary register */
sl@0	1744	int regFree2 = 0; /* If non-zero free this temporary register */
sl@0	1745	int r1, r2, r3, r4; /* Various register numbers */
sl@0	1746	sqlite3 *db;
sl@0	1747
sl@0	1748	db = pParse->db;
sl@0	1749	assert( v!=0 \|\| db->mallocFailed );
sl@0	1750	assert( target>0 && target<=pParse->nMem );
sl@0	1751	if( v==0 ) return 0;
sl@0	1752
sl@0	1753	if( pExpr==0 ){
sl@0	1754	op = TK_NULL;
sl@0	1755	}else{
sl@0	1756	op = pExpr->op;
sl@0	1757	}
sl@0	1758	switch( op ){
sl@0	1759	case TK_AGG_COLUMN: {
sl@0	1760	AggInfo *pAggInfo = pExpr->pAggInfo;
sl@0	1761	struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
sl@0	1762	if( !pAggInfo->directMode ){
sl@0	1763	assert( pCol->iMem>0 );
sl@0	1764	inReg = pCol->iMem;
sl@0	1765	break;
sl@0	1766	}else if( pAggInfo->useSortingIdx ){
sl@0	1767	sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
sl@0	1768	pCol->iSorterColumn, target);
sl@0	1769	break;
sl@0	1770	}
sl@0	1771	/* Otherwise, fall thru into the TK_COLUMN case */
sl@0	1772	}
sl@0	1773	case TK_COLUMN: {
sl@0	1774	if( pExpr->iTable<0 ){
sl@0	1775	/* This only happens when coding check constraints */
sl@0	1776	assert( pParse->ckBase>0 );
sl@0	1777	inReg = pExpr->iColumn + pParse->ckBase;
sl@0	1778	}else{
sl@0	1779	testcase( (pExpr->flags & EP_AnyAff)!=0 );
sl@0	1780	inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
sl@0	1781	pExpr->iColumn, pExpr->iTable, target,
sl@0	1782	pExpr->flags & EP_AnyAff);
sl@0	1783	}
sl@0	1784	break;
sl@0	1785	}
sl@0	1786	case TK_INTEGER: {
sl@0	1787	codeInteger(v, pExpr, 0, target);
sl@0	1788	break;
sl@0	1789	}
sl@0	1790	case TK_FLOAT: {
sl@0	1791	codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
sl@0	1792	break;
sl@0	1793	}
sl@0	1794	case TK_STRING: {
sl@0	1795	sqlite3DequoteExpr(db, pExpr);
sl@0	1796	sqlite3VdbeAddOp4(v,OP_String8, 0, target, 0,
sl@0	1797	(char*)pExpr->token.z, pExpr->token.n);
sl@0	1798	break;
sl@0	1799	}
sl@0	1800	case TK_NULL: {
sl@0	1801	sqlite3VdbeAddOp2(v, OP_Null, 0, target);
sl@0	1802	break;
sl@0	1803	}
sl@0	1804	#ifndef SQLITE_OMIT_BLOB_LITERAL
sl@0	1805	case TK_BLOB: {
sl@0	1806	int n;
sl@0	1807	const char *z;
sl@0	1808	char *zBlob;
sl@0	1809	assert( pExpr->token.n>=3 );
sl@0	1810	assert( pExpr->token.z[0]=='x' \|\| pExpr->token.z[0]=='X' );
sl@0	1811	assert( pExpr->token.z[1]=='\'' );
sl@0	1812	assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
sl@0	1813	n = pExpr->token.n - 3;
sl@0	1814	z = (char*)pExpr->token.z + 2;
sl@0	1815	zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
sl@0	1816	sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
sl@0	1817	break;
sl@0	1818	}
sl@0	1819	#endif
sl@0	1820	case TK_VARIABLE: {
sl@0	1821	sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iTable, target);
sl@0	1822	if( pExpr->token.n>1 ){
sl@0	1823	sqlite3VdbeChangeP4(v, -1, (char*)pExpr->token.z, pExpr->token.n);
sl@0	1824	}
sl@0	1825	break;
sl@0	1826	}
sl@0	1827	case TK_REGISTER: {
sl@0	1828	inReg = pExpr->iTable;
sl@0	1829	break;
sl@0	1830	}
sl@0	1831	case TK_AS: {
sl@0	1832	inReg = codeAlias(pParse, pExpr->iTable, pExpr->pLeft);
sl@0	1833	break;
sl@0	1834	}
sl@0	1835	#ifndef SQLITE_OMIT_CAST
sl@0	1836	case TK_CAST: {
sl@0	1837	/* Expressions of the form: CAST(pLeft AS token) */
sl@0	1838	int aff, to_op;
sl@0	1839	inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
sl@0	1840	aff = sqlite3AffinityType(&pExpr->token);
sl@0	1841	to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
sl@0	1842	assert( to_op==OP_ToText \|\| aff!=SQLITE_AFF_TEXT );
sl@0	1843	assert( to_op==OP_ToBlob \|\| aff!=SQLITE_AFF_NONE );
sl@0	1844	assert( to_op==OP_ToNumeric \|\| aff!=SQLITE_AFF_NUMERIC );
sl@0	1845	assert( to_op==OP_ToInt \|\| aff!=SQLITE_AFF_INTEGER );
sl@0	1846	assert( to_op==OP_ToReal \|\| aff!=SQLITE_AFF_REAL );
sl@0	1847	testcase( to_op==OP_ToText );
sl@0	1848	testcase( to_op==OP_ToBlob );
sl@0	1849	testcase( to_op==OP_ToNumeric );
sl@0	1850	testcase( to_op==OP_ToInt );
sl@0	1851	testcase( to_op==OP_ToReal );
sl@0	1852	sqlite3VdbeAddOp1(v, to_op, inReg);
sl@0	1853	testcase( usedAsColumnCache(pParse, inReg, inReg) );
sl@0	1854	sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
sl@0	1855	break;
sl@0	1856	}
sl@0	1857	#endif /* SQLITE_OMIT_CAST */
sl@0	1858	case TK_LT:
sl@0	1859	case TK_LE:
sl@0	1860	case TK_GT:
sl@0	1861	case TK_GE:
sl@0	1862	case TK_NE:
sl@0	1863	case TK_EQ: {
sl@0	1864	assert( TK_LT==OP_Lt );
sl@0	1865	assert( TK_LE==OP_Le );
sl@0	1866	assert( TK_GT==OP_Gt );
sl@0	1867	assert( TK_GE==OP_Ge );
sl@0	1868	assert( TK_EQ==OP_Eq );
sl@0	1869	assert( TK_NE==OP_Ne );
sl@0	1870	testcase( op==TK_LT );
sl@0	1871	testcase( op==TK_LE );
sl@0	1872	testcase( op==TK_GT );
sl@0	1873	testcase( op==TK_GE );
sl@0	1874	testcase( op==TK_EQ );
sl@0	1875	testcase( op==TK_NE );
sl@0	1876	codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
sl@0	1877	pExpr->pRight, &r2, &regFree2);
sl@0	1878	codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
sl@0	1879	r1, r2, inReg, SQLITE_STOREP2);
sl@0	1880	testcase( regFree1==0 );
sl@0	1881	testcase( regFree2==0 );
sl@0	1882	break;
sl@0	1883	}
sl@0	1884	case TK_AND:
sl@0	1885	case TK_OR:
sl@0	1886	case TK_PLUS:
sl@0	1887	case TK_STAR:
sl@0	1888	case TK_MINUS:
sl@0	1889	case TK_REM:
sl@0	1890	case TK_BITAND:
sl@0	1891	case TK_BITOR:
sl@0	1892	case TK_SLASH:
sl@0	1893	case TK_LSHIFT:
sl@0	1894	case TK_RSHIFT:
sl@0	1895	case TK_CONCAT: {
sl@0	1896	assert( TK_AND==OP_And );
sl@0	1897	assert( TK_OR==OP_Or );
sl@0	1898	assert( TK_PLUS==OP_Add );
sl@0	1899	assert( TK_MINUS==OP_Subtract );
sl@0	1900	assert( TK_REM==OP_Remainder );
sl@0	1901	assert( TK_BITAND==OP_BitAnd );
sl@0	1902	assert( TK_BITOR==OP_BitOr );
sl@0	1903	assert( TK_SLASH==OP_Divide );
sl@0	1904	assert( TK_LSHIFT==OP_ShiftLeft );
sl@0	1905	assert( TK_RSHIFT==OP_ShiftRight );
sl@0	1906	assert( TK_CONCAT==OP_Concat );
sl@0	1907	testcase( op==TK_AND );
sl@0	1908	testcase( op==TK_OR );
sl@0	1909	testcase( op==TK_PLUS );
sl@0	1910	testcase( op==TK_MINUS );
sl@0	1911	testcase( op==TK_REM );
sl@0	1912	testcase( op==TK_BITAND );
sl@0	1913	testcase( op==TK_BITOR );
sl@0	1914	testcase( op==TK_SLASH );
sl@0	1915	testcase( op==TK_LSHIFT );
sl@0	1916	testcase( op==TK_RSHIFT );
sl@0	1917	testcase( op==TK_CONCAT );
sl@0	1918	r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
sl@0	1919	r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
sl@0	1920	sqlite3VdbeAddOp3(v, op, r2, r1, target);
sl@0	1921	testcase( regFree1==0 );
sl@0	1922	testcase( regFree2==0 );
sl@0	1923	break;
sl@0	1924	}
sl@0	1925	case TK_UMINUS: {
sl@0	1926	Expr *pLeft = pExpr->pLeft;
sl@0	1927	assert( pLeft );
sl@0	1928	if( pLeft->op==TK_FLOAT \|\| pLeft->op==TK_INTEGER ){
sl@0	1929	if( pLeft->op==TK_FLOAT ){
sl@0	1930	codeReal(v, (char*)pLeft->token.z, pLeft->token.n, 1, target);
sl@0	1931	}else{
sl@0	1932	codeInteger(v, pLeft, 1, target);
sl@0	1933	}
sl@0	1934	}else{
sl@0	1935	regFree1 = r1 = sqlite3GetTempReg(pParse);
sl@0	1936	sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
sl@0	1937	r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
sl@0	1938	sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
sl@0	1939	testcase( regFree2==0 );
sl@0	1940	}
sl@0	1941	inReg = target;
sl@0	1942	break;
sl@0	1943	}
sl@0	1944	case TK_BITNOT:
sl@0	1945	case TK_NOT: {
sl@0	1946	assert( TK_BITNOT==OP_BitNot );
sl@0	1947	assert( TK_NOT==OP_Not );
sl@0	1948	testcase( op==TK_BITNOT );
sl@0	1949	testcase( op==TK_NOT );
sl@0	1950	inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
sl@0	1951	testcase( inReg==target );
sl@0	1952	testcase( usedAsColumnCache(pParse, inReg, inReg) );
sl@0	1953	inReg = sqlite3ExprWritableRegister(pParse, inReg, target);
sl@0	1954	sqlite3VdbeAddOp1(v, op, inReg);
sl@0	1955	break;
sl@0	1956	}
sl@0	1957	case TK_ISNULL:
sl@0	1958	case TK_NOTNULL: {
sl@0	1959	int addr;
sl@0	1960	assert( TK_ISNULL==OP_IsNull );
sl@0	1961	assert( TK_NOTNULL==OP_NotNull );
sl@0	1962	testcase( op==TK_ISNULL );
sl@0	1963	testcase( op==TK_NOTNULL );
sl@0	1964	sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
sl@0	1965	r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
sl@0	1966	testcase( regFree1==0 );
sl@0	1967	addr = sqlite3VdbeAddOp1(v, op, r1);
sl@0	1968	sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
sl@0	1969	sqlite3VdbeJumpHere(v, addr);
sl@0	1970	break;
sl@0	1971	}
sl@0	1972	case TK_AGG_FUNCTION: {
sl@0	1973	AggInfo *pInfo = pExpr->pAggInfo;
sl@0	1974	if( pInfo==0 ){
sl@0	1975	sqlite3ErrorMsg(pParse, "misuse of aggregate: %T",
sl@0	1976	&pExpr->span);
sl@0	1977	}else{
sl@0	1978	inReg = pInfo->aFunc[pExpr->iAgg].iMem;
sl@0	1979	}
sl@0	1980	break;
sl@0	1981	}
sl@0	1982	case TK_CONST_FUNC:
sl@0	1983	case TK_FUNCTION: {
sl@0	1984	ExprList *pList = pExpr->pList;
sl@0	1985	int nExpr = pList ? pList->nExpr : 0;
sl@0	1986	FuncDef *pDef;
sl@0	1987	int nId;
sl@0	1988	const char *zId;
sl@0	1989	int constMask = 0;
sl@0	1990	int i;
sl@0	1991	u8 enc = ENC(db);
sl@0	1992	CollSeq *pColl = 0;
sl@0	1993
sl@0	1994	testcase( op==TK_CONST_FUNC );
sl@0	1995	testcase( op==TK_FUNCTION );
sl@0	1996	zId = (char*)pExpr->token.z;
sl@0	1997	nId = pExpr->token.n;
sl@0	1998	pDef = sqlite3FindFunction(db, zId, nId, nExpr, enc, 0);
sl@0	1999	assert( pDef!=0 );
sl@0	2000	if( pList ){
sl@0	2001	nExpr = pList->nExpr;
sl@0	2002	r1 = sqlite3GetTempRange(pParse, nExpr);
sl@0	2003	sqlite3ExprCodeExprList(pParse, pList, r1, 1);
sl@0	2004	}else{
sl@0	2005	nExpr = r1 = 0;
sl@0	2006	}
sl@0	2007	#ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0	2008	/* Possibly overload the function if the first argument is
sl@0	2009	** a virtual table column.
sl@0	2010	**
sl@0	2011	** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
sl@0	2012	** second argument, not the first, as the argument to test to
sl@0	2013	** see if it is a column in a virtual table. This is done because
sl@0	2014	** the left operand of infix functions (the operand we want to
sl@0	2015	** control overloading) ends up as the second argument to the
sl@0	2016	** function. The expression "A glob B" is equivalent to
sl@0	2017	** "glob(B,A). We want to use the A in "A glob B" to test
sl@0	2018	** for function overloading. But we use the B term in "glob(B,A)".
sl@0	2019	*/
sl@0	2020	if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
sl@0	2021	pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
sl@0	2022	}else if( nExpr>0 ){
sl@0	2023	pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
sl@0	2024	}
sl@0	2025	#endif
sl@0	2026	for(i=0; i<nExpr && i<32; i++){
sl@0	2027	if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
sl@0	2028	constMask \|= (1<<i);
sl@0	2029	}
sl@0	2030	if( pDef->needCollSeq && !pColl ){
sl@0	2031	pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
sl@0	2032	}
sl@0	2033	}
sl@0	2034	if( pDef->needCollSeq ){
sl@0	2035	if( !pColl ) pColl = db->pDfltColl;
sl@0	2036	sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
sl@0	2037	}
sl@0	2038	sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
sl@0	2039	(char*)pDef, P4_FUNCDEF);
sl@0	2040	sqlite3VdbeChangeP5(v, nExpr);
sl@0	2041	if( nExpr ){
sl@0	2042	sqlite3ReleaseTempRange(pParse, r1, nExpr);
sl@0	2043	}
sl@0	2044	sqlite3ExprCacheAffinityChange(pParse, r1, nExpr);
sl@0	2045	break;
sl@0	2046	}
sl@0	2047	#ifndef SQLITE_OMIT_SUBQUERY
sl@0	2048	case TK_EXISTS:
sl@0	2049	case TK_SELECT: {
sl@0	2050	testcase( op==TK_EXISTS );
sl@0	2051	testcase( op==TK_SELECT );
sl@0	2052	if( pExpr->iColumn==0 ){
sl@0	2053	sqlite3CodeSubselect(pParse, pExpr, 0, 0);
sl@0	2054	}
sl@0	2055	inReg = pExpr->iColumn;
sl@0	2056	break;
sl@0	2057	}
sl@0	2058	case TK_IN: {
sl@0	2059	int rNotFound = 0;
sl@0	2060	int rMayHaveNull = 0;
sl@0	2061	int j2, j3, j4, j5;
sl@0	2062	char affinity;
sl@0	2063	int eType;
sl@0	2064
sl@0	2065	VdbeNoopComment((v, "begin IN expr r%d", target));
sl@0	2066	eType = sqlite3FindInIndex(pParse, pExpr, &rMayHaveNull);
sl@0	2067	if( rMayHaveNull ){
sl@0	2068	rNotFound = ++pParse->nMem;
sl@0	2069	}
sl@0	2070
sl@0	2071	/* Figure out the affinity to use to create a key from the results
sl@0	2072	** of the expression. affinityStr stores a static string suitable for
sl@0	2073	** P4 of OP_MakeRecord.
sl@0	2074	*/
sl@0	2075	affinity = comparisonAffinity(pExpr);
sl@0	2076
sl@0	2077
sl@0	2078	/* Code the <expr> from "<expr> IN (...)". The temporary table
sl@0	2079	** pExpr->iTable contains the values that make up the (...) set.
sl@0	2080	*/
sl@0	2081	pParse->disableColCache++;
sl@0	2082	sqlite3ExprCode(pParse, pExpr->pLeft, target);
sl@0	2083	pParse->disableColCache--;
sl@0	2084	j2 = sqlite3VdbeAddOp1(v, OP_IsNull, target);
sl@0	2085	if( eType==IN_INDEX_ROWID ){
sl@0	2086	j3 = sqlite3VdbeAddOp1(v, OP_MustBeInt, target);
sl@0	2087	j4 = sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, 0, target);
sl@0	2088	sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
sl@0	2089	j5 = sqlite3VdbeAddOp0(v, OP_Goto);
sl@0	2090	sqlite3VdbeJumpHere(v, j3);
sl@0	2091	sqlite3VdbeJumpHere(v, j4);
sl@0	2092	sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
sl@0	2093	}else{
sl@0	2094	r2 = regFree2 = sqlite3GetTempReg(pParse);
sl@0	2095
sl@0	2096	/* Create a record and test for set membership. If the set contains
sl@0	2097	** the value, then jump to the end of the test code. The target
sl@0	2098	** register still contains the true (1) value written to it earlier.
sl@0	2099	*/
sl@0	2100	sqlite3VdbeAddOp4(v, OP_MakeRecord, target, 1, r2, &affinity, 1);
sl@0	2101	sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
sl@0	2102	j5 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, r2);
sl@0	2103
sl@0	2104	/* If the set membership test fails, then the result of the
sl@0	2105	** "x IN (...)" expression must be either 0 or NULL. If the set
sl@0	2106	** contains no NULL values, then the result is 0. If the set
sl@0	2107	** contains one or more NULL values, then the result of the
sl@0	2108	** expression is also NULL.
sl@0	2109	*/
sl@0	2110	if( rNotFound==0 ){
sl@0	2111	/* This branch runs if it is known at compile time (now) that
sl@0	2112	** the set contains no NULL values. This happens as the result
sl@0	2113	** of a "NOT NULL" constraint in the database schema. No need
sl@0	2114	** to test the data structure at runtime in this case.
sl@0	2115	*/
sl@0	2116	sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
sl@0	2117	}else{
sl@0	2118	/* This block populates the rNotFound register with either NULL
sl@0	2119	** or 0 (an integer value). If the data structure contains one
sl@0	2120	** or more NULLs, then set rNotFound to NULL. Otherwise, set it
sl@0	2121	** to 0. If register rMayHaveNull is already set to some value
sl@0	2122	** other than NULL, then the test has already been run and
sl@0	2123	** rNotFound is already populated.
sl@0	2124	*/
sl@0	2125	static const char nullRecord[] = { 0x02, 0x00 };
sl@0	2126	j3 = sqlite3VdbeAddOp1(v, OP_NotNull, rMayHaveNull);
sl@0	2127	sqlite3VdbeAddOp2(v, OP_Null, 0, rNotFound);
sl@0	2128	sqlite3VdbeAddOp4(v, OP_Blob, 2, rMayHaveNull, 0,
sl@0	2129	nullRecord, P4_STATIC);
sl@0	2130	j4 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, rMayHaveNull);
sl@0	2131	sqlite3VdbeAddOp2(v, OP_Integer, 0, rNotFound);
sl@0	2132	sqlite3VdbeJumpHere(v, j4);
sl@0	2133	sqlite3VdbeJumpHere(v, j3);
sl@0	2134
sl@0	2135	/* Copy the value of register rNotFound (which is either NULL or 0)
sl@0	2136	** into the target register. This will be the result of the
sl@0	2137	** expression.
sl@0	2138	*/
sl@0	2139	sqlite3VdbeAddOp2(v, OP_Copy, rNotFound, target);
sl@0	2140	}
sl@0	2141	}
sl@0	2142	sqlite3VdbeJumpHere(v, j2);
sl@0	2143	sqlite3VdbeJumpHere(v, j5);
sl@0	2144	VdbeComment((v, "end IN expr r%d", target));
sl@0	2145	break;
sl@0	2146	}
sl@0	2147	#endif
sl@0	2148	/*
sl@0	2149	** x BETWEEN y AND z
sl@0	2150	**
sl@0	2151	** This is equivalent to
sl@0	2152	**
sl@0	2153	** x>=y AND x<=z
sl@0	2154	**
sl@0	2155	** X is stored in pExpr->pLeft.
sl@0	2156	** Y is stored in pExpr->pList->a[0].pExpr.
sl@0	2157	** Z is stored in pExpr->pList->a[1].pExpr.
sl@0	2158	*/
sl@0	2159	case TK_BETWEEN: {
sl@0	2160	Expr *pLeft = pExpr->pLeft;
sl@0	2161	struct ExprList_item *pLItem = pExpr->pList->a;
sl@0	2162	Expr *pRight = pLItem->pExpr;
sl@0	2163
sl@0	2164	codeCompareOperands(pParse, pLeft, &r1, &regFree1,
sl@0	2165	pRight, &r2, &regFree2);
sl@0	2166	testcase( regFree1==0 );
sl@0	2167	testcase( regFree2==0 );
sl@0	2168	r3 = sqlite3GetTempReg(pParse);
sl@0	2169	r4 = sqlite3GetTempReg(pParse);
sl@0	2170	codeCompare(pParse, pLeft, pRight, OP_Ge,
sl@0	2171	r1, r2, r3, SQLITE_STOREP2);
sl@0	2172	pLItem++;
sl@0	2173	pRight = pLItem->pExpr;
sl@0	2174	sqlite3ReleaseTempReg(pParse, regFree2);
sl@0	2175	r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
sl@0	2176	testcase( regFree2==0 );
sl@0	2177	codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
sl@0	2178	sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
sl@0	2179	sqlite3ReleaseTempReg(pParse, r3);
sl@0	2180	sqlite3ReleaseTempReg(pParse, r4);
sl@0	2181	break;
sl@0	2182	}
sl@0	2183	case TK_UPLUS: {
sl@0	2184	inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
sl@0	2185	break;
sl@0	2186	}
sl@0	2187
sl@0	2188	/*
sl@0	2189	** Form A:
sl@0	2190	** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
sl@0	2191	**
sl@0	2192	** Form B:
sl@0	2193	** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
sl@0	2194	**
sl@0	2195	** Form A is can be transformed into the equivalent form B as follows:
sl@0	2196	** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
sl@0	2197	** WHEN x=eN THEN rN ELSE y END
sl@0	2198	**
sl@0	2199	** X (if it exists) is in pExpr->pLeft.
sl@0	2200	** Y is in pExpr->pRight. The Y is also optional. If there is no
sl@0	2201	** ELSE clause and no other term matches, then the result of the
sl@0	2202	** exprssion is NULL.
sl@0	2203	** Ei is in pExpr->pList->a[i2] and Ri is pExpr->pList->a[i2+1].
sl@0	2204	**
sl@0	2205	** The result of the expression is the Ri for the first matching Ei,
sl@0	2206	** or if there is no matching Ei, the ELSE term Y, or if there is
sl@0	2207	** no ELSE term, NULL.
sl@0	2208	*/
sl@0	2209	case TK_CASE: {
sl@0	2210	int endLabel; /* GOTO label for end of CASE stmt */
sl@0	2211	int nextCase; /* GOTO label for next WHEN clause */
sl@0	2212	int nExpr; /* 2x number of WHEN terms */
sl@0	2213	int i; /* Loop counter */
sl@0	2214	ExprList pEList; / List of WHEN terms */
sl@0	2215	struct ExprList_item aListelem; / Array of WHEN terms */
sl@0	2216	Expr opCompare; /* The X==Ei expression */
sl@0	2217	Expr cacheX; /* Cached expression X */
sl@0	2218	Expr pX; / The X expression */
sl@0	2219	Expr pTest; / X==Ei (form A) or just Ei (form B) */
sl@0	2220
sl@0	2221	assert(pExpr->pList);
sl@0	2222	assert((pExpr->pList->nExpr % 2) == 0);
sl@0	2223	assert(pExpr->pList->nExpr > 0);
sl@0	2224	pEList = pExpr->pList;
sl@0	2225	aListelem = pEList->a;
sl@0	2226	nExpr = pEList->nExpr;
sl@0	2227	endLabel = sqlite3VdbeMakeLabel(v);
sl@0	2228	if( (pX = pExpr->pLeft)!=0 ){
sl@0	2229	cacheX = *pX;
sl@0	2230	testcase( pX->op==TK_COLUMN \|\| pX->op==TK_REGISTER );
sl@0	2231	cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
sl@0	2232	testcase( regFree1==0 );
sl@0	2233	cacheX.op = TK_REGISTER;
sl@0	2234	opCompare.op = TK_EQ;
sl@0	2235	opCompare.pLeft = &cacheX;
sl@0	2236	pTest = &opCompare;
sl@0	2237	}
sl@0	2238	pParse->disableColCache++;
sl@0	2239	for(i=0; i<nExpr; i=i+2){
sl@0	2240	if( pX ){
sl@0	2241	opCompare.pRight = aListelem[i].pExpr;
sl@0	2242	}else{
sl@0	2243	pTest = aListelem[i].pExpr;
sl@0	2244	}
sl@0	2245	nextCase = sqlite3VdbeMakeLabel(v);
sl@0	2246	testcase( pTest->op==TK_COLUMN \|\| pTest->op==TK_REGISTER );
sl@0	2247	sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
sl@0	2248	testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
sl@0	2249	testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
sl@0	2250	sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
sl@0	2251	sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
sl@0	2252	sqlite3VdbeResolveLabel(v, nextCase);
sl@0	2253	}
sl@0	2254	if( pExpr->pRight ){
sl@0	2255	sqlite3ExprCode(pParse, pExpr->pRight, target);
sl@0	2256	}else{
sl@0	2257	sqlite3VdbeAddOp2(v, OP_Null, 0, target);
sl@0	2258	}
sl@0	2259	sqlite3VdbeResolveLabel(v, endLabel);
sl@0	2260	assert( pParse->disableColCache>0 );
sl@0	2261	pParse->disableColCache--;
sl@0	2262	break;
sl@0	2263	}
sl@0	2264	#ifndef SQLITE_OMIT_TRIGGER
sl@0	2265	case TK_RAISE: {
sl@0	2266	if( !pParse->trigStack ){
sl@0	2267	sqlite3ErrorMsg(pParse,
sl@0	2268	"RAISE() may only be used within a trigger-program");
sl@0	2269	return 0;
sl@0	2270	}
sl@0	2271	if( pExpr->iColumn!=OE_Ignore ){
sl@0	2272	assert( pExpr->iColumn==OE_Rollback \|\|
sl@0	2273	pExpr->iColumn == OE_Abort \|\|
sl@0	2274	pExpr->iColumn == OE_Fail );
sl@0	2275	sqlite3DequoteExpr(db, pExpr);
sl@0	2276	sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 0,
sl@0	2277	(char*)pExpr->token.z, pExpr->token.n);
sl@0	2278	} else {
sl@0	2279	assert( pExpr->iColumn == OE_Ignore );
sl@0	2280	sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
sl@0	2281	sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
sl@0	2282	VdbeComment((v, "raise(IGNORE)"));
sl@0	2283	}
sl@0	2284	break;
sl@0	2285	}
sl@0	2286	#endif
sl@0	2287	}
sl@0	2288	sqlite3ReleaseTempReg(pParse, regFree1);
sl@0	2289	sqlite3ReleaseTempReg(pParse, regFree2);
sl@0	2290	return inReg;
sl@0	2291	}
sl@0	2292
sl@0	2293	/*
sl@0	2294	** Generate code to evaluate an expression and store the results
sl@0	2295	** into a register. Return the register number where the results
sl@0	2296	** are stored.
sl@0	2297	**
sl@0	2298	** If the register is a temporary register that can be deallocated,
sl@0	2299	** then write its number into *pReg. If the result register is not
sl@0	2300	** a temporary, then set *pReg to zero.
sl@0	2301	*/
sl@0	2302	int sqlite3ExprCodeTemp(Parse pParse, Expr pExpr, int *pReg){
sl@0	2303	int r1 = sqlite3GetTempReg(pParse);
sl@0	2304	int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
sl@0	2305	if( r2==r1 ){
sl@0	2306	*pReg = r1;
sl@0	2307	}else{
sl@0	2308	sqlite3ReleaseTempReg(pParse, r1);
sl@0	2309	*pReg = 0;
sl@0	2310	}
sl@0	2311	return r2;
sl@0	2312	}
sl@0	2313
sl@0	2314	/*
sl@0	2315	** Generate code that will evaluate expression pExpr and store the
sl@0	2316	** results in register target. The results are guaranteed to appear
sl@0	2317	** in register target.
sl@0	2318	*/
sl@0	2319	int sqlite3ExprCode(Parse pParse, Expr pExpr, int target){
sl@0	2320	int inReg;
sl@0	2321
sl@0	2322	assert( target>0 && target<=pParse->nMem );
sl@0	2323	inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
sl@0	2324	assert( pParse->pVdbe \|\| pParse->db->mallocFailed );
sl@0	2325	if( inReg!=target && pParse->pVdbe ){
sl@0	2326	sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
sl@0	2327	}
sl@0	2328	return target;
sl@0	2329	}
sl@0	2330
sl@0	2331	/*
sl@0	2332	** Generate code that evalutes the given expression and puts the result
sl@0	2333	** in register target.
sl@0	2334	**
sl@0	2335	** Also make a copy of the expression results into another "cache" register
sl@0	2336	** and modify the expression so that the next time it is evaluated,
sl@0	2337	** the result is a copy of the cache register.
sl@0	2338	**
sl@0	2339	** This routine is used for expressions that are used multiple
sl@0	2340	** times. They are evaluated once and the results of the expression
sl@0	2341	** are reused.
sl@0	2342	*/
sl@0	2343	int sqlite3ExprCodeAndCache(Parse pParse, Expr pExpr, int target){
sl@0	2344	Vdbe *v = pParse->pVdbe;
sl@0	2345	int inReg;
sl@0	2346	inReg = sqlite3ExprCode(pParse, pExpr, target);
sl@0	2347	assert( target>0 );
sl@0	2348	if( pExpr->op!=TK_REGISTER ){
sl@0	2349	int iMem;
sl@0	2350	iMem = ++pParse->nMem;
sl@0	2351	sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
sl@0	2352	pExpr->iTable = iMem;
sl@0	2353	pExpr->op = TK_REGISTER;
sl@0	2354	}
sl@0	2355	return inReg;
sl@0	2356	}
sl@0	2357
sl@0	2358	/*
sl@0	2359	** Return TRUE if pExpr is an constant expression that is appropriate
sl@0	2360	** for factoring out of a loop. Appropriate expressions are:
sl@0	2361	**
sl@0	2362	** * Any expression that evaluates to two or more opcodes.
sl@0	2363	**
sl@0	2364	** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
sl@0	2365	** or OP_Variable that does not need to be placed in a
sl@0	2366	** specific register.
sl@0	2367	**
sl@0	2368	** There is no point in factoring out single-instruction constant
sl@0	2369	** expressions that need to be placed in a particular register.
sl@0	2370	** We could factor them out, but then we would end up adding an
sl@0	2371	** OP_SCopy instruction to move the value into the correct register
sl@0	2372	** later. We might as well just use the original instruction and
sl@0	2373	** avoid the OP_SCopy.
sl@0	2374	*/
sl@0	2375	static int isAppropriateForFactoring(Expr *p){
sl@0	2376	if( !sqlite3ExprIsConstantNotJoin(p) ){
sl@0	2377	return 0; /* Only constant expressions are appropriate for factoring */
sl@0	2378	}
sl@0	2379	if( (p->flags & EP_FixedDest)==0 ){
sl@0	2380	return 1; /* Any constant without a fixed destination is appropriate */
sl@0	2381	}
sl@0	2382	while( p->op==TK_UPLUS ) p = p->pLeft;
sl@0	2383	switch( p->op ){
sl@0	2384	#ifndef SQLITE_OMIT_BLOB_LITERAL
sl@0	2385	case TK_BLOB:
sl@0	2386	#endif
sl@0	2387	case TK_VARIABLE:
sl@0	2388	case TK_INTEGER:
sl@0	2389	case TK_FLOAT:
sl@0	2390	case TK_NULL:
sl@0	2391	case TK_STRING: {
sl@0	2392	testcase( p->op==TK_BLOB );
sl@0	2393	testcase( p->op==TK_VARIABLE );
sl@0	2394	testcase( p->op==TK_INTEGER );
sl@0	2395	testcase( p->op==TK_FLOAT );
sl@0	2396	testcase( p->op==TK_NULL );
sl@0	2397	testcase( p->op==TK_STRING );
sl@0	2398	/* Single-instruction constants with a fixed destination are
sl@0	2399	** better done in-line. If we factor them, they will just end
sl@0	2400	** up generating an OP_SCopy to move the value to the destination
sl@0	2401	** register. */
sl@0	2402	return 0;
sl@0	2403	}
sl@0	2404	case TK_UMINUS: {
sl@0	2405	if( p->pLeft->op==TK_FLOAT \|\| p->pLeft->op==TK_INTEGER ){
sl@0	2406	return 0;
sl@0	2407	}
sl@0	2408	break;
sl@0	2409	}
sl@0	2410	default: {
sl@0	2411	break;
sl@0	2412	}
sl@0	2413	}
sl@0	2414	return 1;
sl@0	2415	}
sl@0	2416
sl@0	2417	/*
sl@0	2418	** If pExpr is a constant expression that is appropriate for
sl@0	2419	** factoring out of a loop, then evaluate the expression
sl@0	2420	** into a register and convert the expression into a TK_REGISTER
sl@0	2421	** expression.
sl@0	2422	*/
sl@0	2423	static int evalConstExpr(Walker pWalker, Expr pExpr){
sl@0	2424	Parse *pParse = pWalker->pParse;
sl@0	2425	switch( pExpr->op ){
sl@0	2426	case TK_REGISTER: {
sl@0	2427	return 1;
sl@0	2428	}
sl@0	2429	case TK_FUNCTION:
sl@0	2430	case TK_AGG_FUNCTION:
sl@0	2431	case TK_CONST_FUNC: {
sl@0	2432	/* The arguments to a function have a fixed destination.
sl@0	2433	** Mark them this way to avoid generated unneeded OP_SCopy
sl@0	2434	** instructions.
sl@0	2435	*/
sl@0	2436	ExprList *pList = pExpr->pList;
sl@0	2437	if( pList ){
sl@0	2438	int i = pList->nExpr;
sl@0	2439	struct ExprList_item *pItem = pList->a;
sl@0	2440	for(; i>0; i--, pItem++){
sl@0	2441	if( pItem->pExpr ) pItem->pExpr->flags \|= EP_FixedDest;
sl@0	2442	}
sl@0	2443	}
sl@0	2444	break;
sl@0	2445	}
sl@0	2446	}
sl@0	2447	if( isAppropriateForFactoring(pExpr) ){
sl@0	2448	int r1 = ++pParse->nMem;
sl@0	2449	int r2;
sl@0	2450	r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
sl@0	2451	if( r1!=r2 ) sqlite3ReleaseTempReg(pParse, r1);
sl@0	2452	pExpr->op = TK_REGISTER;
sl@0	2453	pExpr->iTable = r2;
sl@0	2454	return WRC_Prune;
sl@0	2455	}
sl@0	2456	return WRC_Continue;
sl@0	2457	}
sl@0	2458
sl@0	2459	/*
sl@0	2460	** Preevaluate constant subexpressions within pExpr and store the
sl@0	2461	** results in registers. Modify pExpr so that the constant subexpresions
sl@0	2462	** are TK_REGISTER opcodes that refer to the precomputed values.
sl@0	2463	*/
sl@0	2464	void sqlite3ExprCodeConstants(Parse pParse, Expr pExpr){
sl@0	2465	Walker w;
sl@0	2466	w.xExprCallback = evalConstExpr;
sl@0	2467	w.xSelectCallback = 0;
sl@0	2468	w.pParse = pParse;
sl@0	2469	sqlite3WalkExpr(&w, pExpr);
sl@0	2470	}
sl@0	2471
sl@0	2472
sl@0	2473	/*
sl@0	2474	** Generate code that pushes the value of every element of the given
sl@0	2475	** expression list into a sequence of registers beginning at target.
sl@0	2476	**
sl@0	2477	** Return the number of elements evaluated.
sl@0	2478	*/
sl@0	2479	int sqlite3ExprCodeExprList(
sl@0	2480	Parse pParse, / Parsing context */
sl@0	2481	ExprList pList, / The expression list to be coded */
sl@0	2482	int target, /* Where to write results */
sl@0	2483	int doHardCopy /* Make a hard copy of every element */
sl@0	2484	){
sl@0	2485	struct ExprList_item *pItem;
sl@0	2486	int i, n;
sl@0	2487	assert( pList!=0 );
sl@0	2488	assert( target>0 );
sl@0	2489	n = pList->nExpr;
sl@0	2490	for(pItem=pList->a, i=0; i<n; i++, pItem++){
sl@0	2491	if( pItem->iAlias ){
sl@0	2492	int iReg = codeAlias(pParse, pItem->iAlias, pItem->pExpr);
sl@0	2493	Vdbe *v = sqlite3GetVdbe(pParse);
sl@0	2494	sqlite3VdbeAddOp2(v, OP_SCopy, iReg, target+i);
sl@0	2495	}else{
sl@0	2496	sqlite3ExprCode(pParse, pItem->pExpr, target+i);
sl@0	2497	}
sl@0	2498	if( doHardCopy ){
sl@0	2499	sqlite3ExprHardCopy(pParse, target, n);
sl@0	2500	}
sl@0	2501	}
sl@0	2502	return n;
sl@0	2503	}
sl@0	2504
sl@0	2505	/*
sl@0	2506	** Generate code for a boolean expression such that a jump is made
sl@0	2507	** to the label "dest" if the expression is true but execution
sl@0	2508	** continues straight thru if the expression is false.
sl@0	2509	**
sl@0	2510	** If the expression evaluates to NULL (neither true nor false), then
sl@0	2511	** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
sl@0	2512	**
sl@0	2513	** This code depends on the fact that certain token values (ex: TK_EQ)
sl@0	2514	** are the same as opcode values (ex: OP_Eq) that implement the corresponding
sl@0	2515	** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
sl@0	2516	** the make process cause these values to align. Assert()s in the code
sl@0	2517	** below verify that the numbers are aligned correctly.
sl@0	2518	*/
sl@0	2519	void sqlite3ExprIfTrue(Parse pParse, Expr pExpr, int dest, int jumpIfNull){
sl@0	2520	Vdbe *v = pParse->pVdbe;
sl@0	2521	int op = 0;
sl@0	2522	int regFree1 = 0;
sl@0	2523	int regFree2 = 0;
sl@0	2524	int r1, r2;
sl@0	2525
sl@0	2526	assert( jumpIfNull==SQLITE_JUMPIFNULL \|\| jumpIfNull==0 );
sl@0	2527	if( v==0 \|\| pExpr==0 ) return;
sl@0	2528	op = pExpr->op;
sl@0	2529	switch( op ){
sl@0	2530	case TK_AND: {
sl@0	2531	int d2 = sqlite3VdbeMakeLabel(v);
sl@0	2532	testcase( jumpIfNull==0 );
sl@0	2533	testcase( pParse->disableColCache==0 );
sl@0	2534	sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
sl@0	2535	pParse->disableColCache++;
sl@0	2536	sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
sl@0	2537	assert( pParse->disableColCache>0 );
sl@0	2538	pParse->disableColCache--;
sl@0	2539	sqlite3VdbeResolveLabel(v, d2);
sl@0	2540	break;
sl@0	2541	}
sl@0	2542	case TK_OR: {
sl@0	2543	testcase( jumpIfNull==0 );
sl@0	2544	testcase( pParse->disableColCache==0 );
sl@0	2545	sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
sl@0	2546	pParse->disableColCache++;
sl@0	2547	sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
sl@0	2548	assert( pParse->disableColCache>0 );
sl@0	2549	pParse->disableColCache--;
sl@0	2550	break;
sl@0	2551	}
sl@0	2552	case TK_NOT: {
sl@0	2553	testcase( jumpIfNull==0 );
sl@0	2554	sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
sl@0	2555	break;
sl@0	2556	}
sl@0	2557	case TK_LT:
sl@0	2558	case TK_LE:
sl@0	2559	case TK_GT:
sl@0	2560	case TK_GE:
sl@0	2561	case TK_NE:
sl@0	2562	case TK_EQ: {
sl@0	2563	assert( TK_LT==OP_Lt );
sl@0	2564	assert( TK_LE==OP_Le );
sl@0	2565	assert( TK_GT==OP_Gt );
sl@0	2566	assert( TK_GE==OP_Ge );
sl@0	2567	assert( TK_EQ==OP_Eq );
sl@0	2568	assert( TK_NE==OP_Ne );
sl@0	2569	testcase( op==TK_LT );
sl@0	2570	testcase( op==TK_LE );
sl@0	2571	testcase( op==TK_GT );
sl@0	2572	testcase( op==TK_GE );
sl@0	2573	testcase( op==TK_EQ );
sl@0	2574	testcase( op==TK_NE );
sl@0	2575	testcase( jumpIfNull==0 );
sl@0	2576	codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
sl@0	2577	pExpr->pRight, &r2, &regFree2);
sl@0	2578	codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
sl@0	2579	r1, r2, dest, jumpIfNull);
sl@0	2580	testcase( regFree1==0 );
sl@0	2581	testcase( regFree2==0 );
sl@0	2582	break;
sl@0	2583	}
sl@0	2584	case TK_ISNULL:
sl@0	2585	case TK_NOTNULL: {
sl@0	2586	assert( TK_ISNULL==OP_IsNull );
sl@0	2587	assert( TK_NOTNULL==OP_NotNull );
sl@0	2588	testcase( op==TK_ISNULL );
sl@0	2589	testcase( op==TK_NOTNULL );
sl@0	2590	r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
sl@0	2591	sqlite3VdbeAddOp2(v, op, r1, dest);
sl@0	2592	testcase( regFree1==0 );
sl@0	2593	break;
sl@0	2594	}
sl@0	2595	case TK_BETWEEN: {
sl@0	2596	/* x BETWEEN y AND z
sl@0	2597	**
sl@0	2598	** Is equivalent to
sl@0	2599	**
sl@0	2600	** x>=y AND x<=z
sl@0	2601	**
sl@0	2602	** Code it as such, taking care to do the common subexpression
sl@0	2603	** elementation of x.
sl@0	2604	*/
sl@0	2605	Expr exprAnd;
sl@0	2606	Expr compLeft;
sl@0	2607	Expr compRight;
sl@0	2608	Expr exprX;
sl@0	2609
sl@0	2610	exprX = *pExpr->pLeft;
sl@0	2611	exprAnd.op = TK_AND;
sl@0	2612	exprAnd.pLeft = &compLeft;
sl@0	2613	exprAnd.pRight = &compRight;
sl@0	2614	compLeft.op = TK_GE;
sl@0	2615	compLeft.pLeft = &exprX;
sl@0	2616	compLeft.pRight = pExpr->pList->a[0].pExpr;
sl@0	2617	compRight.op = TK_LE;
sl@0	2618	compRight.pLeft = &exprX;
sl@0	2619	compRight.pRight = pExpr->pList->a[1].pExpr;
sl@0	2620	exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
sl@0	2621	testcase( regFree1==0 );
sl@0	2622	exprX.op = TK_REGISTER;
sl@0	2623	testcase( jumpIfNull==0 );
sl@0	2624	sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
sl@0	2625	break;
sl@0	2626	}
sl@0	2627	default: {
sl@0	2628	r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
sl@0	2629	sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
sl@0	2630	testcase( regFree1==0 );
sl@0	2631	testcase( jumpIfNull==0 );
sl@0	2632	break;
sl@0	2633	}
sl@0	2634	}
sl@0	2635	sqlite3ReleaseTempReg(pParse, regFree1);
sl@0	2636	sqlite3ReleaseTempReg(pParse, regFree2);
sl@0	2637	}
sl@0	2638
sl@0	2639	/*
sl@0	2640	** Generate code for a boolean expression such that a jump is made
sl@0	2641	** to the label "dest" if the expression is false but execution
sl@0	2642	** continues straight thru if the expression is true.
sl@0	2643	**
sl@0	2644	** If the expression evaluates to NULL (neither true nor false) then
sl@0	2645	** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
sl@0	2646	** is 0.
sl@0	2647	*/
sl@0	2648	void sqlite3ExprIfFalse(Parse pParse, Expr pExpr, int dest, int jumpIfNull){
sl@0	2649	Vdbe *v = pParse->pVdbe;
sl@0	2650	int op = 0;
sl@0	2651	int regFree1 = 0;
sl@0	2652	int regFree2 = 0;
sl@0	2653	int r1, r2;
sl@0	2654
sl@0	2655	assert( jumpIfNull==SQLITE_JUMPIFNULL \|\| jumpIfNull==0 );
sl@0	2656	if( v==0 \|\| pExpr==0 ) return;
sl@0	2657
sl@0	2658	/* The value of pExpr->op and op are related as follows:
sl@0	2659	**
sl@0	2660	** pExpr->op op
sl@0	2661	** --------- ----------
sl@0	2662	** TK_ISNULL OP_NotNull
sl@0	2663	** TK_NOTNULL OP_IsNull
sl@0	2664	** TK_NE OP_Eq
sl@0	2665	** TK_EQ OP_Ne
sl@0	2666	** TK_GT OP_Le
sl@0	2667	** TK_LE OP_Gt
sl@0	2668	** TK_GE OP_Lt
sl@0	2669	** TK_LT OP_Ge
sl@0	2670	**
sl@0	2671	** For other values of pExpr->op, op is undefined and unused.
sl@0	2672	** The value of TK_ and OP_ constants are arranged such that we
sl@0	2673	** can compute the mapping above using the following expression.
sl@0	2674	** Assert()s verify that the computation is correct.
sl@0	2675	*/
sl@0	2676	op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
sl@0	2677
sl@0	2678	/* Verify correct alignment of TK_ and OP_ constants
sl@0	2679	*/
sl@0	2680	assert( pExpr->op!=TK_ISNULL \|\| op==OP_NotNull );
sl@0	2681	assert( pExpr->op!=TK_NOTNULL \|\| op==OP_IsNull );
sl@0	2682	assert( pExpr->op!=TK_NE \|\| op==OP_Eq );
sl@0	2683	assert( pExpr->op!=TK_EQ \|\| op==OP_Ne );
sl@0	2684	assert( pExpr->op!=TK_LT \|\| op==OP_Ge );
sl@0	2685	assert( pExpr->op!=TK_LE \|\| op==OP_Gt );
sl@0	2686	assert( pExpr->op!=TK_GT \|\| op==OP_Le );
sl@0	2687	assert( pExpr->op!=TK_GE \|\| op==OP_Lt );
sl@0	2688
sl@0	2689	switch( pExpr->op ){
sl@0	2690	case TK_AND: {
sl@0	2691	testcase( jumpIfNull==0 );
sl@0	2692	testcase( pParse->disableColCache==0 );
sl@0	2693	sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
sl@0	2694	pParse->disableColCache++;
sl@0	2695	sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
sl@0	2696	assert( pParse->disableColCache>0 );
sl@0	2697	pParse->disableColCache--;
sl@0	2698	break;
sl@0	2699	}
sl@0	2700	case TK_OR: {
sl@0	2701	int d2 = sqlite3VdbeMakeLabel(v);
sl@0	2702	testcase( jumpIfNull==0 );
sl@0	2703	testcase( pParse->disableColCache==0 );
sl@0	2704	sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
sl@0	2705	pParse->disableColCache++;
sl@0	2706	sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
sl@0	2707	assert( pParse->disableColCache>0 );
sl@0	2708	pParse->disableColCache--;
sl@0	2709	sqlite3VdbeResolveLabel(v, d2);
sl@0	2710	break;
sl@0	2711	}
sl@0	2712	case TK_NOT: {
sl@0	2713	sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
sl@0	2714	break;
sl@0	2715	}
sl@0	2716	case TK_LT:
sl@0	2717	case TK_LE:
sl@0	2718	case TK_GT:
sl@0	2719	case TK_GE:
sl@0	2720	case TK_NE:
sl@0	2721	case TK_EQ: {
sl@0	2722	testcase( op==TK_LT );
sl@0	2723	testcase( op==TK_LE );
sl@0	2724	testcase( op==TK_GT );
sl@0	2725	testcase( op==TK_GE );
sl@0	2726	testcase( op==TK_EQ );
sl@0	2727	testcase( op==TK_NE );
sl@0	2728	testcase( jumpIfNull==0 );
sl@0	2729	codeCompareOperands(pParse, pExpr->pLeft, &r1, &regFree1,
sl@0	2730	pExpr->pRight, &r2, &regFree2);
sl@0	2731	codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
sl@0	2732	r1, r2, dest, jumpIfNull);
sl@0	2733	testcase( regFree1==0 );
sl@0	2734	testcase( regFree2==0 );
sl@0	2735	break;
sl@0	2736	}
sl@0	2737	case TK_ISNULL:
sl@0	2738	case TK_NOTNULL: {
sl@0	2739	testcase( op==TK_ISNULL );
sl@0	2740	testcase( op==TK_NOTNULL );
sl@0	2741	r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
sl@0	2742	sqlite3VdbeAddOp2(v, op, r1, dest);
sl@0	2743	testcase( regFree1==0 );
sl@0	2744	break;
sl@0	2745	}
sl@0	2746	case TK_BETWEEN: {
sl@0	2747	/* x BETWEEN y AND z
sl@0	2748	**
sl@0	2749	** Is equivalent to
sl@0	2750	**
sl@0	2751	** x>=y AND x<=z
sl@0	2752	**
sl@0	2753	** Code it as such, taking care to do the common subexpression
sl@0	2754	** elementation of x.
sl@0	2755	*/
sl@0	2756	Expr exprAnd;
sl@0	2757	Expr compLeft;
sl@0	2758	Expr compRight;
sl@0	2759	Expr exprX;
sl@0	2760
sl@0	2761	exprX = *pExpr->pLeft;
sl@0	2762	exprAnd.op = TK_AND;
sl@0	2763	exprAnd.pLeft = &compLeft;
sl@0	2764	exprAnd.pRight = &compRight;
sl@0	2765	compLeft.op = TK_GE;
sl@0	2766	compLeft.pLeft = &exprX;
sl@0	2767	compLeft.pRight = pExpr->pList->a[0].pExpr;
sl@0	2768	compRight.op = TK_LE;
sl@0	2769	compRight.pLeft = &exprX;
sl@0	2770	compRight.pRight = pExpr->pList->a[1].pExpr;
sl@0	2771	exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
sl@0	2772	testcase( regFree1==0 );
sl@0	2773	exprX.op = TK_REGISTER;
sl@0	2774	testcase( jumpIfNull==0 );
sl@0	2775	sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
sl@0	2776	break;
sl@0	2777	}
sl@0	2778	default: {
sl@0	2779	r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
sl@0	2780	sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
sl@0	2781	testcase( regFree1==0 );
sl@0	2782	testcase( jumpIfNull==0 );
sl@0	2783	break;
sl@0	2784	}
sl@0	2785	}
sl@0	2786	sqlite3ReleaseTempReg(pParse, regFree1);
sl@0	2787	sqlite3ReleaseTempReg(pParse, regFree2);
sl@0	2788	}
sl@0	2789
sl@0	2790	/*
sl@0	2791	** Do a deep comparison of two expression trees. Return TRUE (non-zero)
sl@0	2792	** if they are identical and return FALSE if they differ in any way.
sl@0	2793	**
sl@0	2794	** Sometimes this routine will return FALSE even if the two expressions
sl@0	2795	** really are equivalent. If we cannot prove that the expressions are
sl@0	2796	** identical, we return FALSE just to be safe. So if this routine
sl@0	2797	** returns false, then you do not really know for certain if the two
sl@0	2798	** expressions are the same. But if you get a TRUE return, then you
sl@0	2799	** can be sure the expressions are the same. In the places where
sl@0	2800	** this routine is used, it does not hurt to get an extra FALSE - that
sl@0	2801	** just might result in some slightly slower code. But returning
sl@0	2802	** an incorrect TRUE could lead to a malfunction.
sl@0	2803	*/
sl@0	2804	int sqlite3ExprCompare(Expr pA, Expr pB){
sl@0	2805	int i;
sl@0	2806	if( pA==0\|\|pB==0 ){
sl@0	2807	return pB==pA;
sl@0	2808	}
sl@0	2809	if( pA->op!=pB->op ) return 0;
sl@0	2810	if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0;
sl@0	2811	if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
sl@0	2812	if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
sl@0	2813	if( pA->pList ){
sl@0	2814	if( pB->pList==0 ) return 0;
sl@0	2815	if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
sl@0	2816	for(i=0; i<pA->pList->nExpr; i++){
sl@0	2817	if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
sl@0	2818	return 0;
sl@0	2819	}
sl@0	2820	}
sl@0	2821	}else if( pB->pList ){
sl@0	2822	return 0;
sl@0	2823	}
sl@0	2824	if( pA->pSelect \|\| pB->pSelect ) return 0;
sl@0	2825	if( pA->iTable!=pB->iTable \|\| pA->iColumn!=pB->iColumn ) return 0;
sl@0	2826	if( pA->op!=TK_COLUMN && pA->token.z ){
sl@0	2827	if( pB->token.z==0 ) return 0;
sl@0	2828	if( pB->token.n!=pA->token.n ) return 0;
sl@0	2829	if( sqlite3StrNICmp((char)pA->token.z,(char)pB->token.z,pB->token.n)!=0 ){
sl@0	2830	return 0;
sl@0	2831	}
sl@0	2832	}
sl@0	2833	return 1;
sl@0	2834	}
sl@0	2835
sl@0	2836
sl@0	2837	/*
sl@0	2838	** Add a new element to the pAggInfo->aCol[] array. Return the index of
sl@0	2839	** the new element. Return a negative number if malloc fails.
sl@0	2840	*/
sl@0	2841	static int addAggInfoColumn(sqlite3 db, AggInfo pInfo){
sl@0	2842	int i;
sl@0	2843	pInfo->aCol = sqlite3ArrayAllocate(
sl@0	2844	db,
sl@0	2845	pInfo->aCol,
sl@0	2846	sizeof(pInfo->aCol[0]),
sl@0	2847	3,
sl@0	2848	&pInfo->nColumn,
sl@0	2849	&pInfo->nColumnAlloc,
sl@0	2850	&i
sl@0	2851	);
sl@0	2852	return i;
sl@0	2853	}
sl@0	2854
sl@0	2855	/*
sl@0	2856	** Add a new element to the pAggInfo->aFunc[] array. Return the index of
sl@0	2857	** the new element. Return a negative number if malloc fails.
sl@0	2858	*/
sl@0	2859	static int addAggInfoFunc(sqlite3 db, AggInfo pInfo){
sl@0	2860	int i;
sl@0	2861	pInfo->aFunc = sqlite3ArrayAllocate(
sl@0	2862	db,
sl@0	2863	pInfo->aFunc,
sl@0	2864	sizeof(pInfo->aFunc[0]),
sl@0	2865	3,
sl@0	2866	&pInfo->nFunc,
sl@0	2867	&pInfo->nFuncAlloc,
sl@0	2868	&i
sl@0	2869	);
sl@0	2870	return i;
sl@0	2871	}
sl@0	2872
sl@0	2873	/*
sl@0	2874	** This is the xExprCallback for a tree walker. It is used to
sl@0	2875	** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
sl@0	2876	** for additional information.
sl@0	2877	*/
sl@0	2878	static int analyzeAggregate(Walker pWalker, Expr pExpr){
sl@0	2879	int i;
sl@0	2880	NameContext *pNC = pWalker->u.pNC;
sl@0	2881	Parse *pParse = pNC->pParse;
sl@0	2882	SrcList *pSrcList = pNC->pSrcList;
sl@0	2883	AggInfo *pAggInfo = pNC->pAggInfo;
sl@0	2884
sl@0	2885	switch( pExpr->op ){
sl@0	2886	case TK_AGG_COLUMN:
sl@0	2887	case TK_COLUMN: {
sl@0	2888	testcase( pExpr->op==TK_AGG_COLUMN );
sl@0	2889	testcase( pExpr->op==TK_COLUMN );
sl@0	2890	/* Check to see if the column is in one of the tables in the FROM
sl@0	2891	** clause of the aggregate query */
sl@0	2892	if( pSrcList ){
sl@0	2893	struct SrcList_item *pItem = pSrcList->a;
sl@0	2894	for(i=0; i<pSrcList->nSrc; i++, pItem++){
sl@0	2895	struct AggInfo_col *pCol;
sl@0	2896	if( pExpr->iTable==pItem->iCursor ){
sl@0	2897	/* If we reach this point, it means that pExpr refers to a table
sl@0	2898	** that is in the FROM clause of the aggregate query.
sl@0	2899	**
sl@0	2900	** Make an entry for the column in pAggInfo->aCol[] if there
sl@0	2901	** is not an entry there already.
sl@0	2902	*/
sl@0	2903	int k;
sl@0	2904	pCol = pAggInfo->aCol;
sl@0	2905	for(k=0; k<pAggInfo->nColumn; k++, pCol++){
sl@0	2906	if( pCol->iTable==pExpr->iTable &&
sl@0	2907	pCol->iColumn==pExpr->iColumn ){
sl@0	2908	break;
sl@0	2909	}
sl@0	2910	}
sl@0	2911	if( (k>=pAggInfo->nColumn)
sl@0	2912	&& (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
sl@0	2913	){
sl@0	2914	pCol = &pAggInfo->aCol[k];
sl@0	2915	pCol->pTab = pExpr->pTab;
sl@0	2916	pCol->iTable = pExpr->iTable;
sl@0	2917	pCol->iColumn = pExpr->iColumn;
sl@0	2918	pCol->iMem = ++pParse->nMem;
sl@0	2919	pCol->iSorterColumn = -1;
sl@0	2920	pCol->pExpr = pExpr;
sl@0	2921	if( pAggInfo->pGroupBy ){
sl@0	2922	int j, n;
sl@0	2923	ExprList *pGB = pAggInfo->pGroupBy;
sl@0	2924	struct ExprList_item *pTerm = pGB->a;
sl@0	2925	n = pGB->nExpr;
sl@0	2926	for(j=0; j<n; j++, pTerm++){
sl@0	2927	Expr *pE = pTerm->pExpr;
sl@0	2928	if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
sl@0	2929	pE->iColumn==pExpr->iColumn ){
sl@0	2930	pCol->iSorterColumn = j;
sl@0	2931	break;
sl@0	2932	}
sl@0	2933	}
sl@0	2934	}
sl@0	2935	if( pCol->iSorterColumn<0 ){
sl@0	2936	pCol->iSorterColumn = pAggInfo->nSortingColumn++;
sl@0	2937	}
sl@0	2938	}
sl@0	2939	/* There is now an entry for pExpr in pAggInfo->aCol[] (either
sl@0	2940	** because it was there before or because we just created it).
sl@0	2941	** Convert the pExpr to be a TK_AGG_COLUMN referring to that
sl@0	2942	** pAggInfo->aCol[] entry.
sl@0	2943	*/
sl@0	2944	pExpr->pAggInfo = pAggInfo;
sl@0	2945	pExpr->op = TK_AGG_COLUMN;
sl@0	2946	pExpr->iAgg = k;
sl@0	2947	break;
sl@0	2948	} /* endif pExpr->iTable==pItem->iCursor */
sl@0	2949	} /* end loop over pSrcList */
sl@0	2950	}
sl@0	2951	return WRC_Prune;
sl@0	2952	}
sl@0	2953	case TK_AGG_FUNCTION: {
sl@0	2954	/* The pNC->nDepth==0 test causes aggregate functions in subqueries
sl@0	2955	** to be ignored */
sl@0	2956	if( pNC->nDepth==0 ){
sl@0	2957	/* Check to see if pExpr is a duplicate of another aggregate
sl@0	2958	** function that is already in the pAggInfo structure
sl@0	2959	*/
sl@0	2960	struct AggInfo_func *pItem = pAggInfo->aFunc;
sl@0	2961	for(i=0; i<pAggInfo->nFunc; i++, pItem++){
sl@0	2962	if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
sl@0	2963	break;
sl@0	2964	}
sl@0	2965	}
sl@0	2966	if( i>=pAggInfo->nFunc ){
sl@0	2967	/* pExpr is original. Make a new entry in pAggInfo->aFunc[]
sl@0	2968	*/
sl@0	2969	u8 enc = ENC(pParse->db);
sl@0	2970	i = addAggInfoFunc(pParse->db, pAggInfo);
sl@0	2971	if( i>=0 ){
sl@0	2972	pItem = &pAggInfo->aFunc[i];
sl@0	2973	pItem->pExpr = pExpr;
sl@0	2974	pItem->iMem = ++pParse->nMem;
sl@0	2975	pItem->pFunc = sqlite3FindFunction(pParse->db,
sl@0	2976	(char*)pExpr->token.z, pExpr->token.n,
sl@0	2977	pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
sl@0	2978	if( pExpr->flags & EP_Distinct ){
sl@0	2979	pItem->iDistinct = pParse->nTab++;
sl@0	2980	}else{
sl@0	2981	pItem->iDistinct = -1;
sl@0	2982	}
sl@0	2983	}
sl@0	2984	}
sl@0	2985	/* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
sl@0	2986	*/
sl@0	2987	pExpr->iAgg = i;
sl@0	2988	pExpr->pAggInfo = pAggInfo;
sl@0	2989	return WRC_Prune;
sl@0	2990	}
sl@0	2991	}
sl@0	2992	}
sl@0	2993	return WRC_Continue;
sl@0	2994	}
sl@0	2995	static int analyzeAggregatesInSelect(Walker pWalker, Select pSelect){
sl@0	2996	NameContext *pNC = pWalker->u.pNC;
sl@0	2997	if( pNC->nDepth==0 ){
sl@0	2998	pNC->nDepth++;
sl@0	2999	sqlite3WalkSelect(pWalker, pSelect);
sl@0	3000	pNC->nDepth--;
sl@0	3001	return WRC_Prune;
sl@0	3002	}else{
sl@0	3003	return WRC_Continue;
sl@0	3004	}
sl@0	3005	}
sl@0	3006
sl@0	3007	/*
sl@0	3008	** Analyze the given expression looking for aggregate functions and
sl@0	3009	** for variables that need to be added to the pParse->aAgg[] array.
sl@0	3010	** Make additional entries to the pParse->aAgg[] array as necessary.
sl@0	3011	**
sl@0	3012	** This routine should only be called after the expression has been
sl@0	3013	** analyzed by sqlite3ResolveExprNames().
sl@0	3014	*/
sl@0	3015	void sqlite3ExprAnalyzeAggregates(NameContext pNC, Expr pExpr){
sl@0	3016	Walker w;
sl@0	3017	w.xExprCallback = analyzeAggregate;
sl@0	3018	w.xSelectCallback = analyzeAggregatesInSelect;
sl@0	3019	w.u.pNC = pNC;
sl@0	3020	sqlite3WalkExpr(&w, pExpr);
sl@0	3021	}
sl@0	3022
sl@0	3023	/*
sl@0	3024	** Call sqlite3ExprAnalyzeAggregates() for every expression in an
sl@0	3025	** expression list. Return the number of errors.
sl@0	3026	**
sl@0	3027	** If an error is found, the analysis is cut short.
sl@0	3028	*/
sl@0	3029	void sqlite3ExprAnalyzeAggList(NameContext pNC, ExprList pList){
sl@0	3030	struct ExprList_item *pItem;
sl@0	3031	int i;
sl@0	3032	if( pList ){
sl@0	3033	for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
sl@0	3034	sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
sl@0	3035	}
sl@0	3036	}
sl@0	3037	}
sl@0	3038
sl@0	3039	/*
sl@0	3040	** Allocate or deallocate temporary use registers during code generation.
sl@0	3041	*/
sl@0	3042	int sqlite3GetTempReg(Parse *pParse){
sl@0	3043	if( pParse->nTempReg==0 ){
sl@0	3044	return ++pParse->nMem;
sl@0	3045	}
sl@0	3046	return pParse->aTempReg[--pParse->nTempReg];
sl@0	3047	}
sl@0	3048	void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
sl@0	3049	if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
sl@0	3050	sqlite3ExprWritableRegister(pParse, iReg, iReg);
sl@0	3051	pParse->aTempReg[pParse->nTempReg++] = iReg;
sl@0	3052	}
sl@0	3053	}
sl@0	3054
sl@0	3055	/*
sl@0	3056	** Allocate or deallocate a block of nReg consecutive registers
sl@0	3057	*/
sl@0	3058	int sqlite3GetTempRange(Parse *pParse, int nReg){
sl@0	3059	int i, n;
sl@0	3060	i = pParse->iRangeReg;
sl@0	3061	n = pParse->nRangeReg;
sl@0	3062	if( nReg<=n && !usedAsColumnCache(pParse, i, i+n-1) ){
sl@0	3063	pParse->iRangeReg += nReg;
sl@0	3064	pParse->nRangeReg -= nReg;
sl@0	3065	}else{
sl@0	3066	i = pParse->nMem+1;
sl@0	3067	pParse->nMem += nReg;
sl@0	3068	}
sl@0	3069	return i;
sl@0	3070	}
sl@0	3071	void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
sl@0	3072	if( nReg>pParse->nRangeReg ){
sl@0	3073	pParse->nRangeReg = nReg;
sl@0	3074	pParse->iRangeReg = iReg;
sl@0	3075	}
sl@0	3076	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--