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

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