From 6977fea801aa706725279f8b1ebb2996c63b67dd Mon Sep 17 00:00:00 2001 From: drh Date: Tue, 22 Oct 2002 23:38:04 +0000 Subject: [PATCH] Correctly handle column names and string constants in parentheses. Fix for ticket #179. (CVS 770) FossilOrigin-Name: 3b68aa25c451b7c09ece457ac2b70a9a5d93508a --- manifest | 24 ++++++++--------- manifest.uuid | 2 +- src/expr.c | 72 +++++++++++++++++++------------------------------ src/parse.y | 48 ++++++++++++++++----------------- src/select.c | 43 +++++++++++++---------------- src/sqliteInt.h | 13 +++------ src/tokenize.c | 3 +-- test/misc1.test | 6 ++++- test/where.test | 15 ++++++++++- 9 files changed, 106 insertions(+), 120 deletions(-) diff --git a/manifest b/manifest index 9e3019ef56..104ab04818 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Take\scare\sto\strack\sephemeral\sstrings\sin\sthe\sVDBE\sand\smake\scopies\sof\sephemeral\nstrings\sthat\sneed\sto\sbe\spreserved.\s\sTicket\s#177.\s(CVS\s769) -D 2002-10-22T15:04:34 +C Correctly\shandle\scolumn\snames\sand\sstring\sconstants\sin\sparentheses.\nFix\sfor\sticket\s#179.\s(CVS\s770) +D 2002-10-22T23:38:04 F Makefile.in d6c9a85c2a5e696843201d090dcf8bf2f8716f2a F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906 F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd @@ -23,7 +23,7 @@ F src/btree.h 0ca6c2631338df62e4f7894252d9347ae234eda9 F src/build.c 1559232f6878fd7f2b1c79aede0f7a33ececab07 F src/delete.c aad9d4051ab46e6f6391ea5f7b8994a7c05bdd15 F src/encode.c 6c9c87d5b7b2c0101d011ebc283a80abf672a4d1 -F src/expr.c e1327eb020a68ff7c49382e121ad4b71b3441b2a +F src/expr.c 108017b98634a3bddc1b41c9b158e4d26f9b27f0 F src/func.c e45cd908b9b723d9b91473d09e12c23f786b3fc2 F src/hash.c 6a6236b89c8c060c65dabd300a1c8ce7c10edb72 F src/hash.h cd0433998bc1a3759d244e1637fe5a3c13b53bf8 @@ -34,21 +34,21 @@ F src/os.c ede7346dffdbab40c6de20d2f325981f3f1168fd F src/os.h 3009379b06941e7796a9812d1b6cbc59b26248c8 F src/pager.c 592e5931fdc65e952a6c3e152bc822580856532a F src/pager.h 6991c9c2dc5e4c7f2df4d4ba47d1c6458f763a32 -F src/parse.y 818b03a73f6b3b8b284b515c5b1d9998d4663dc3 +F src/parse.y e37e66aa0aee94d235058c7a7b7aaa71bb401324 F src/printf.c 5c50fc1da75c8f5bf432b1ad17d91d6653acd167 F src/random.c 19e8e00fe0df32a742f115773f57651be327cabe -F src/select.c 987e0c6134f157905f4531b4c0191ca078c81ef2 +F src/select.c 4a6f3fb86a9e25f6c74ee95c5d0e26a0b8648592 F src/shell.c 9e9a6eb6bca07f01e6472a603f908a0127ea50ff F src/shell.tcl 27ecbd63dd88396ad16d81ab44f73e6c0ea9d20e F src/sqlite.h.in d3999a9c6374675779058d6cfe5431131618e92b -F src/sqliteInt.h 54caf09fbb64b43a060637c46fb7464ea7b6f759 +F src/sqliteInt.h 9a5fea861133f1913cfebd3bbbf6a4e9ace47fef F src/table.c eed2098c9b577aa17f8abe89313a9c4413f57d63 F src/tclsqlite.c fa646506f02509455c1e4a878d1303bd2d4c3ead F src/test1.c a46e9f61915b32787c5d5a05a4b92e4dacc437d9 F src/test2.c 5fa694d130b3309e3f9c852f0a437750fcb5a006 F src/test3.c 540fa7fc3cb3732517b779b5f90ad9cc4303d0ab F src/threadtest.c 72bce0a284647314847bbea44616ceb056bfb77f -F src/tokenize.c 62c98842447effe92eba9622bb2f9a2a8a4b97ad +F src/tokenize.c 0000d3555af749cfc2d85f9686fdab82eedb77c4 F src/trigger.c 5ba917fc226b96065108da28186c2efaec53e481 F src/update.c 881e4c8e7c786545da4fd2d95da19252b2e31137 F src/util.c ca7650ef2cc2d50241e48029fca109a3016144ee @@ -80,7 +80,7 @@ F test/main.test c66b564554b770ee7fdbf6a66c0cd90329bc2c85 F test/malloc.test 7ba32a9ebd3aeed52ae4aaa6d42ca37e444536fd F test/memleak.test b4f59aa44488793b00feff2011d77d0f05b22468 F test/minmax.test 29bc5727c3e4c792d5c4745833dd4b505905819e -F test/misc1.test 9b0fdc82756bd88da91e5d62f4c93ef6a457c1bc +F test/misc1.test 3c4672069c430d0f21c23385e78ea4e063183aa5 F test/misuse.test a3aa2b18a97e4c409a1fcaff5151a4dd804a0162 F test/notnull.test b1f3e42fc475b0b5827b27b2e9b562081995ff30 F test/null.test 5c2b57307e4b6178aae825eb65ddbee01e76b0fd @@ -113,7 +113,7 @@ F test/update.test 7ffb062d580a972e7870d0f51d5af3ab9bfeae08 F test/vacuum.test 059871b312eb910bbe49dafde1d01490cc2c6bbe F test/version.test 605fd0d7e7d571370c32b12dbf395b58953de246 F test/view.test 76d3fe155f1215f9dde1ccad1d1bce5c803132d0 -F test/where.test c7aba40ad9178acf9c898e53aac9e447e2d2f2f7 +F test/where.test 9c1c2c13cfff419ea38451e78cf3d0d238fabc27 F tool/diffdb.c 7524b1b5df217c20cd0431f6789851a4e0cb191b F tool/lemon.c 022adc2830c2705828f744d2c59798bd462eb465 F tool/lempar.c 73a991cc3017fb34804250fa901488b5147b3717 @@ -149,7 +149,7 @@ F www/speed.tcl a20a792738475b68756ea7a19321600f23d1d803 F www/sqlite.tcl ae3dcfb077e53833b59d4fcc94d8a12c50a44098 F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331 F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218 -P f50a177b4239bc7a83563ac9361e830ec04e81fb -R 51ce3b0413b1dc8a7f5705e4ce1ca408 +P 562da534bbb605a8ce15824135b012ef2d86bbeb +R df476aa0a67bb0f1bc7353bd04cb345e U drh -Z c497ca5b513d571220d0f770a2a71d04 +Z f9c703cf01e9f1a25c5301f84c45f9b9 diff --git a/manifest.uuid b/manifest.uuid index 8412d8f232..9e6c29e040 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -562da534bbb605a8ce15824135b012ef2d86bbeb \ No newline at end of file +3b68aa25c451b7c09ece457ac2b70a9a5d93508a \ No newline at end of file diff --git a/src/expr.c b/src/expr.c index 0aaaf0e879..b2ec92e2e0 100644 --- a/src/expr.c +++ b/src/expr.c @@ -12,7 +12,7 @@ ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** -** $Id: expr.c,v 1.81 2002/09/08 00:04:52 drh Exp $ +** $Id: expr.c,v 1.82 2002/10/22 23:38:04 drh Exp $ */ #include "sqliteInt.h" #include @@ -36,34 +36,33 @@ Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){ if( pToken ){ assert( pToken->dyn==0 ); pNew->token = *pToken; - pNew->token.base = 1; - }else if( pLeft && pRight ){ - sqliteExprSpan(pNew, &pLeft->token, &pRight->token); + pNew->span = *pToken; }else{ pNew->token.dyn = 0; - pNew->token.base = 1; pNew->token.z = 0; pNew->token.n = 0; + if( pLeft && pRight ){ + sqliteExprSpan(pNew, &pLeft->span, &pRight->span); + }else{ + pNew->span = pNew->token; + } } return pNew; } /* -** Set the Expr.token field of the given expression to span all +** Set the Expr.span field of the given expression to span all ** text between the two given tokens. */ void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ - if( pExpr ){ - assert( pExpr->token.dyn==0 ); + if( pExpr && pRight && pRight->z && pLeft && pLeft->z ){ if( pLeft->dyn==0 && pRight->dyn==0 ){ - pExpr->token.z = pLeft->z; - pExpr->token.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); - pExpr->token.base = 0; + pExpr->span.z = pLeft->z; + pExpr->span.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); }else{ - pExpr->token.z = 0; - pExpr->token.n = 0; - pExpr->token.dyn = 0; - pExpr->token.base = 0; + pExpr->span.z = 0; + pExpr->span.n = 0; + pExpr->span.dyn = 0; } } } @@ -81,22 +80,15 @@ Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ } pNew->op = TK_FUNCTION; pNew->pList = pList; - - /* Expr.token.n is the length of the entire function - ** call, including the function arguments. The parser - ** will extend token.n to cover the either length of the string. - ** Expr.nFuncName is the length of just the function name. - */ pNew->token.dyn = 0; - pNew->token.base = 1; if( pToken ){ assert( pToken->dyn==0 ); pNew->token = *pToken; - pNew->nFuncName = pToken->n>255 ? 255 : pToken->n; }else{ pNew->token.z = 0; pNew->token.n = 0; } + pNew->span = pNew->token; return pNew; } @@ -105,6 +97,7 @@ Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ */ void sqliteExprDelete(Expr *p){ if( p==0 ) return; + if( p->span.dyn && p->span.z ) sqliteFree((char*)p->span.z); if( p->token.dyn && p->token.z ) sqliteFree((char*)p->token.z); if( p->pLeft ) sqliteExprDelete(p->pLeft); if( p->pRight ) sqliteExprDelete(p->pRight); @@ -132,12 +125,7 @@ Expr *sqliteExprDup(Expr *p){ pNew = sqliteMalloc( sizeof(*p) ); if( pNew==0 ) return 0; memcpy(pNew, p, sizeof(*pNew)); - /* Only make a copy of the token if it is a base token (meaning that - ** it covers a single term of an expression - not two or more terms) - ** or if it is already dynamically allocated. So, for example, in - ** a complex expression like "a+b+c", the token "b" would be duplicated - ** but "a+b" would not be. */ - if( p->token.z!=0 && (p->token.base || p->token.dyn) ){ + if( p->token.z!=0 ){ pNew->token.z = sqliteStrDup(p->token.z); pNew->token.dyn = 1; }else{ @@ -145,6 +133,9 @@ Expr *sqliteExprDup(Expr *p){ pNew->token.n = 0; pNew->token.dyn = 0; } + pNew->span.z = 0; + pNew->span.n = 0; + pNew->span.dyn = 0; pNew->pLeft = sqliteExprDup(p->pLeft); pNew->pRight = sqliteExprDup(p->pRight); pNew->pList = sqliteExprListDup(p->pList); @@ -153,7 +144,6 @@ Expr *sqliteExprDup(Expr *p){ } void sqliteTokenCopy(Token *pTo, Token *pFrom){ if( pTo->dyn ) sqliteFree((char*)pTo->z); - pTo->base = pFrom->base; if( pFrom->z ){ pTo->n = pFrom->n; pTo->z = sqliteStrNDup(pFrom->z, pFrom->n); @@ -176,12 +166,13 @@ ExprList *sqliteExprListDup(ExprList *p){ for(i=0; inExpr; i++){ Expr *pNewExpr, *pOldExpr; pNew->a[i].pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr); - if( pOldExpr->token.z!=0 && pNewExpr && pNewExpr->token.z==0 ){ - /* Always make a copy of the token for top-level expressions in the + if( pOldExpr->span.z!=0 && pNewExpr ){ + /* Always make a copy of the span for top-level expressions in the ** expression list. The logic in SELECT processing that determines ** the names of columns in the result set needs this information */ - sqliteTokenCopy(&pNew->a[i].pExpr->token, &p->a[i].pExpr->token); + sqliteTokenCopy(&pNewExpr->span, &pOldExpr->span); } + assert( pNewExpr==0 || pNewExpr->span.z!=0 || pOldExpr->span.z==0 ); pNew->a[i].zName = sqliteStrDup(p->a[i].zName); pNew->a[i].sortOrder = p->a[i].sortOrder; pNew->a[i].isAgg = p->a[i].isAgg; @@ -714,7 +705,7 @@ static void getFunctionName(Expr *pExpr, const char **pzName, int *pnName){ switch( pExpr->op ){ case TK_FUNCTION: { *pzName = pExpr->token.z; - *pnName = pExpr->nFuncName; + *pnName = pExpr->token.n; break; } case TK_LIKE: { @@ -1451,16 +1442,9 @@ int sqliteExprCompare(Expr *pA, Expr *pB){ if( pA->pSelect || pB->pSelect ) return 0; if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0; if( pA->token.z ){ - int n; if( pB->token.z==0 ) return 0; - if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){ - n = pA->nFuncName; - if( pB->nFuncName!=n ) return 0; - }else{ - n = pA->token.n; - if( pB->token.n!=n ) return 0; - } - if( sqliteStrNICmp(pA->token.z, pB->token.z, n)!=0 ) return 0; + if( pB->token.n!=pA->token.n ) return 0; + if( sqliteStrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0; } return 1; } @@ -1531,7 +1515,7 @@ int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){ pParse->aAgg[i].isAgg = 1; pParse->aAgg[i].pExpr = pExpr; pParse->aAgg[i].pFunc = sqliteFindFunction(pParse->db, - pExpr->token.z, pExpr->nFuncName, + pExpr->token.z, pExpr->token.n, pExpr->pList ? pExpr->pList->nExpr : 0, 0); } pExpr->iAgg = i; diff --git a/src/parse.y b/src/parse.y index 5a4242b18a..e2dd57f5a4 100644 --- a/src/parse.y +++ b/src/parse.y @@ -14,7 +14,7 @@ ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** -** @(#) $Id: parse.y,v 1.83 2002/08/31 18:53:07 drh Exp $ +** @(#) $Id: parse.y,v 1.84 2002/10/22 23:38:04 drh Exp $ */ %token_prefix TK_ %token_type {Token} @@ -503,7 +503,7 @@ inscollist(A) ::= nm(Y). {A = sqliteIdListAppend(0,&Y);} %type expr {Expr*} %destructor expr {sqliteExprDelete($$);} -expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E);} +expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); } expr(A) ::= NULL(X). {A = sqliteExpr(TK_NULL, 0, 0, &X);} expr(A) ::= ID(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} expr(A) ::= JOIN_KW(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} @@ -518,12 +518,10 @@ expr(A) ::= STRING(X). {A = sqliteExpr(TK_STRING, 0, 0, &X);} expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = sqliteExprFunction(Y, &X); sqliteExprSpan(A,&X,&E); - if( A ) A->token.base = 1; } expr(A) ::= ID(X) LP STAR RP(E). { A = sqliteExprFunction(0, &X); sqliteExprSpan(A,&X,&E); - if( A ) A->token.base = 1; } expr(A) ::= expr(X) AND expr(Y). {A = sqliteExpr(TK_AND, X, Y, 0);} expr(A) ::= expr(X) OR expr(Y). {A = sqliteExpr(TK_OR, X, Y, 0);} @@ -542,7 +540,7 @@ expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE] { pList = sqliteExprListAppend(pList, X, 0); A = sqliteExprFunction(pList, 0); if( A ) A->op = OP; - sqliteExprSpan(A, &X->token, &Y->token); + sqliteExprSpan(A, &X->span, &Y->span); } expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] { ExprList *pList = sqliteExprListAppend(0, Y, 0); @@ -550,7 +548,7 @@ expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] { A = sqliteExprFunction(pList, 0); if( A ) A->op = OP; A = sqliteExpr(TK_NOT, A, 0, 0); - sqliteExprSpan(A,&X->token,&Y->token); + sqliteExprSpan(A,&X->span,&Y->span); } %type likeop {int} likeop(A) ::= LIKE. {A = TK_LIKE;} @@ -563,39 +561,39 @@ expr(A) ::= expr(X) REM expr(Y). {A = sqliteExpr(TK_REM, X, Y, 0);} expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);} expr(A) ::= expr(X) ISNULL(E). { A = sqliteExpr(TK_ISNULL, X, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) IS NULL(E). { A = sqliteExpr(TK_ISNULL, X, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) NOTNULL(E). { A = sqliteExpr(TK_NOTNULL, X, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) NOT NULL(E). { A = sqliteExpr(TK_NOTNULL, X, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) IS NOT NULL(E). { A = sqliteExpr(TK_NOTNULL, X, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= NOT(B) expr(X). { A = sqliteExpr(TK_NOT, X, 0, 0); - sqliteExprSpan(A,&B,&X->token); + sqliteExprSpan(A,&B,&X->span); } expr(A) ::= BITNOT(B) expr(X). { A = sqliteExpr(TK_BITNOT, X, 0, 0); - sqliteExprSpan(A,&B,&X->token); + sqliteExprSpan(A,&B,&X->span); } expr(A) ::= MINUS(B) expr(X). [UMINUS] { A = sqliteExpr(TK_UMINUS, X, 0, 0); - sqliteExprSpan(A,&B,&X->token); + sqliteExprSpan(A,&B,&X->span); } expr(A) ::= PLUS(B) expr(X). [UPLUS] { A = sqliteExpr(TK_UPLUS, X, 0, 0); - sqliteExprSpan(A,&B,&X->token); + sqliteExprSpan(A,&B,&X->span); } expr(A) ::= LP(B) select(X) RP(E). { A = sqliteExpr(TK_SELECT, 0, 0, 0); @@ -607,7 +605,7 @@ expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). { pList = sqliteExprListAppend(pList, Y, 0); A = sqliteExpr(TK_BETWEEN, W, 0, 0); if( A ) A->pList = pList; - sqliteExprSpan(A,&W->token,&Y->token); + sqliteExprSpan(A,&W->span,&Y->span); } expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). { ExprList *pList = sqliteExprListAppend(0, X, 0); @@ -615,29 +613,29 @@ expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). { A = sqliteExpr(TK_BETWEEN, W, 0, 0); if( A ) A->pList = pList; A = sqliteExpr(TK_NOT, A, 0, 0); - sqliteExprSpan(A,&W->token,&Y->token); + sqliteExprSpan(A,&W->span,&Y->span); } expr(A) ::= expr(X) IN LP exprlist(Y) RP(E). { A = sqliteExpr(TK_IN, X, 0, 0); if( A ) A->pList = Y; - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) IN LP select(Y) RP(E). { A = sqliteExpr(TK_IN, X, 0, 0); if( A ) A->pSelect = Y; - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E). { A = sqliteExpr(TK_IN, X, 0, 0); if( A ) A->pList = Y; A = sqliteExpr(TK_NOT, A, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } expr(A) ::= expr(X) NOT IN LP select(Y) RP(E). { A = sqliteExpr(TK_IN, X, 0, 0); if( A ) A->pSelect = Y; A = sqliteExpr(TK_NOT, A, 0, 0); - sqliteExprSpan(A,&X->token,&E); + sqliteExprSpan(A,&X->span,&E); } /* CASE expressions */ @@ -793,22 +791,22 @@ trigger_cmd(A) ::= select(X). {A = sqliteTriggerSelectStep(X); } expr(A) ::= RAISE(X) LP IGNORE RP(Y). { A = sqliteExpr(TK_RAISE, 0, 0, 0); A->iColumn = OE_Ignore; - /* sqliteExprSpan(A, &X, &Y); */ + sqliteExprSpan(A, &X, &Y); } expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y). { A = sqliteExpr(TK_RAISE, 0, 0, &Z); A->iColumn = OE_Rollback; - /* sqliteExprSpan(A, &X, &Y); */ + sqliteExprSpan(A, &X, &Y); } expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y). { A = sqliteExpr(TK_RAISE, 0, 0, &Z); A->iColumn = OE_Abort; - /* sqliteExprSpan(A, &X, &Y); */ + sqliteExprSpan(A, &X, &Y); } expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y). { A = sqliteExpr(TK_RAISE, 0, 0, &Z); A->iColumn = OE_Fail; - /* sqliteExprSpan(A, &X, &Y); */ + sqliteExprSpan(A, &X, &Y); } //////////////////////// DROP TRIGGER statement ////////////////////////////// diff --git a/src/select.c b/src/select.c index a885a44c6a..e964f48fd7 100644 --- a/src/select.c +++ b/src/select.c @@ -12,7 +12,7 @@ ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** -** $Id: select.c,v 1.113 2002/10/20 15:53:04 drh Exp $ +** $Id: select.c,v 1.114 2002/10/22 23:38:04 drh Exp $ */ #include "sqliteInt.h" @@ -157,7 +157,6 @@ static void addWhereTerm( dummy.z = zCol; dummy.n = strlen(zCol); - dummy.base = 1; dummy.dyn = 0; pE1a = sqliteExpr(TK_ID, 0, 0, &dummy); pE2a = sqliteExpr(TK_ID, 0, 0, &dummy); @@ -664,9 +663,9 @@ static void generateColumnNames( zCol = pTab->aCol[iCol].zName; zType = pTab->aCol[iCol].zType; } - if( p->token.z && p->token.z[0] && !showFullNames ){ + if( p->span.z && p->span.z[0] && !showFullNames ){ int addr = sqliteVdbeAddOp(v,OP_ColumnName, i, 0); - sqliteVdbeChangeP3(v, -1, p->token.z, p->token.n); + sqliteVdbeChangeP3(v, -1, p->span.z, p->span.n); sqliteVdbeCompressSpace(v, addr); }else if( pTabList->nSrc>1 || showFullNames ){ char *zName = 0; @@ -682,13 +681,9 @@ static void generateColumnNames( sqliteVdbeAddOp(v, OP_ColumnName, i, 0); sqliteVdbeChangeP3(v, -1, zCol, 0); } - }else if( p->token.z && p->token.z[0] && !showFullNames ){ + }else if( p->span.z && p->span.z[0] ){ int addr = sqliteVdbeAddOp(v,OP_ColumnName, i, 0); - sqliteVdbeChangeP3(v, -1, p->token.z, p->token.n); - sqliteVdbeCompressSpace(v, addr); - }else if( p->token.z && p->token.z[0] ){ - int addr = sqliteVdbeAddOp(v,OP_ColumnName, i, 0); - sqliteVdbeChangeP3(v, -1, p->token.z, p->token.n); + sqliteVdbeChangeP3(v, -1, p->span.z, p->span.n); sqliteVdbeCompressSpace(v, addr); }else{ char zName[30]; @@ -755,8 +750,8 @@ Table *sqliteResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ Expr *p; if( pEList->a[i].zName ){ pTab->aCol[i].zName = sqliteStrDup(pEList->a[i].zName); - }else if( (p=pEList->a[i].pExpr)->token.z && p->token.z[0] ){ - sqliteSetNString(&pTab->aCol[i].zName, p->token.z, p->token.n, 0); + }else if( (p=pEList->a[i].pExpr)->span.z && p->span.z[0] ){ + sqliteSetNString(&pTab->aCol[i].zName, p->span.z, p->span.n, 0); }else if( p->op==TK_DOT && p->pRight && p->pRight->token.z && p->pRight->token.z[0] ){ sqliteSetNString(&pTab->aCol[i].zName, @@ -922,7 +917,6 @@ static int fillInColumnList(Parse *pParse, Select *p){ pRight->token.z = zName; pRight->token.n = strlen(zName); pRight->token.dyn = 0; - pRight->token.base = 1; if( zTabName && pTabList->nSrc>1 ){ pLeft = sqliteExpr(TK_ID, 0, 0, 0); pExpr = sqliteExpr(TK_DOT, pLeft, pRight, 0); @@ -930,13 +924,15 @@ static int fillInColumnList(Parse *pParse, Select *p){ pLeft->token.z = zTabName; pLeft->token.n = strlen(zTabName); pLeft->token.dyn = 0; - pLeft->token.base = 1; - sqliteSetString((char**)&pExpr->token.z, zTabName, ".", zName, 0); - pExpr->token.n = strlen(pExpr->token.z); - pExpr->token.base = 0; - pExpr->token.dyn = 1; + sqliteSetString((char**)&pExpr->span.z, zTabName, ".", zName, 0); + pExpr->span.n = strlen(pExpr->span.z); + pExpr->span.dyn = 1; + pExpr->token.z = 0; + pExpr->token.n = 0; + pExpr->token.dyn = 0; }else{ pExpr = pRight; + pExpr->span = pExpr->token; } pNew = sqliteExprListAppend(pNew, pExpr, 0); } @@ -1344,8 +1340,8 @@ static void substExpr(Expr *pExpr, int iTable, ExprList *pEList, int iSub){ pExpr->iTable = pNew->iTable; pExpr->iColumn = pNew->iColumn; pExpr->iAgg = pNew->iAgg; - pExpr->nFuncName = pNew->nFuncName; sqliteTokenCopy(&pExpr->token, &pNew->token); + sqliteTokenCopy(&pExpr->span, &pNew->span); if( iSub!=iTable ){ changeTables(pExpr, iSub, iTable); } @@ -1467,10 +1463,9 @@ static int flattenSubquery( substExprList(p->pEList, iParent, pSub->pEList, iSub); pList = p->pEList; for(i=0; inExpr; i++){ - if( pList->a[i].zName==0 ){ - Expr *pExpr = pList->a[i].pExpr; - assert( pExpr->token.z!=0 ); - pList->a[i].zName = sqliteStrNDup(pExpr->token.z, pExpr->token.n); + Expr *pExpr; + if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){ + pList->a[i].zName = sqliteStrNDup(pExpr->span.z, pExpr->span.n); } } if( isAgg ){ @@ -1593,7 +1588,7 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ pExpr = p->pEList->a[0].pExpr; if( pExpr->op!=TK_AGG_FUNCTION ) return 0; if( pExpr->pList==0 || pExpr->pList->nExpr!=1 ) return 0; - if( pExpr->nFuncName!=3 ) return 0; + if( pExpr->token.n!=3 ) return 0; if( sqliteStrNICmp(pExpr->token.z,"min",3)==0 ){ seekOp = OP_Rewind; }else if( sqliteStrNICmp(pExpr->token.z,"max",3)==0 ){ diff --git a/src/sqliteInt.h b/src/sqliteInt.h index 63b39f9d43..60ec0dadce 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -11,7 +11,7 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.146 2002/09/14 13:47:32 drh Exp $ +** @(#) $Id: sqliteInt.h,v 1.147 2002/10/22 23:38:04 drh Exp $ */ #include "sqlite.h" #include "hash.h" @@ -449,18 +449,11 @@ struct Index { /* ** Each token coming out of the lexer is an instance of ** this structure. Tokens are also used as part of an expression. -** -** A "base" token is a real single token such as would come out of the -** lexer. There are also compound tokens which are aggregates of one -** or more base tokens. Compound tokens are used to name columns in the -** result set of a SELECT statement. In the expression "a+b+c", "b" -** is a base token but "a+b" is a compound token. */ struct Token { const char *z; /* Text of the token. Not NULL-terminated! */ unsigned dyn : 1; /* True for malloced memory, false for static */ - unsigned base : 1; /* True for a base token, false for compounds */ - unsigned n : 30; /* Number of characters in this token */ + unsigned n : 31; /* Number of characters in this token */ }; /* @@ -501,11 +494,11 @@ struct Expr { u8 op; /* Operation performed by this node */ u8 dataType; /* Either SQLITE_SO_TEXT or SQLITE_SO_NUM */ u8 isJoinExpr; /* Origin is the ON or USING phrase of a join */ - u8 nFuncName; /* Number of characters in a function name */ Expr *pLeft, *pRight; /* Left and right subnodes */ ExprList *pList; /* A list of expressions used as function arguments ** or in " IN (useAgg==TRUE, pull diff --git a/src/tokenize.c b/src/tokenize.c index 4637f6138a..8b03bd94e0 100644 --- a/src/tokenize.c +++ b/src/tokenize.c @@ -15,7 +15,7 @@ ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** -** $Id: tokenize.c,v 1.49 2002/08/27 14:28:30 drh Exp $ +** $Id: tokenize.c,v 1.50 2002/10/22 23:38:04 drh Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -424,7 +424,6 @@ int sqliteRunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ break; } pParse->sLastToken.z = &zSql[i]; - pParse->sLastToken.base = 1; pParse->sLastToken.dyn = 0; pParse->sLastToken.n = sqliteGetToken((unsigned char*)&zSql[i], &tokenType); i += pParse->sLastToken.n; diff --git a/test/misc1.test b/test/misc1.test index a083242871..35894953c5 100644 --- a/test/misc1.test +++ b/test/misc1.test @@ -13,7 +13,7 @@ # This file implements tests for miscellanous features that were # left out of other test files. # -# $Id: misc1.test,v 1.15 2002/09/17 03:20:46 drh Exp $ +# $Id: misc1.test,v 1.16 2002/10/22 23:38:04 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl @@ -103,6 +103,10 @@ do_test misc1-2.2 { execsql {SELECT sum(one), two, four FROM agger GROUP BY two, four ORDER BY sum(one) desc} } {8 two no 6 one yes 4 two yes 3 thr yes} +do_test misc1-2.3 { + execsql {SELECT sum((one)), (two), (four) FROM agger + GROUP BY (two), (four) ORDER BY sum(one) desc} +} {8 two no 6 one yes 4 two yes 3 thr yes} # Here's a test for a bug found by Joel Lucsy. The code below # was causing an assertion failure. diff --git a/test/where.test b/test/where.test index 9fcb3e9c6d..6c16d53596 100644 --- a/test/where.test +++ b/test/where.test @@ -11,7 +11,7 @@ # This file implements regression tests for SQLite library. The # focus of this file is testing the use of indices in WHERE clases. # -# $Id: where.test,v 1.10 2002/08/14 03:03:58 drh Exp $ +# $Id: where.test,v 1.11 2002/10/22 23:38:04 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl @@ -170,6 +170,19 @@ do_test where-1.37 { count {SELECT w FROM t1 WHERE w+1<=4 ORDER BY w} } {1 2 3 199} +do_test where-1.38 { + count {SELECT (w) FROM t1 WHERE (w)>(97)} +} {98 99 100 6} +do_test where-1.39 { + count {SELECT (w) FROM t1 WHERE (w)>=(97)} +} {97 98 99 100 8} +do_test where-1.40 { + count {SELECT (w) FROM t1 WHERE (w)==(97)} +} {97 3} +do_test where-1.41 { + count {SELECT (w) FROM t1 WHERE ((w)+(1))==(98)} +} {97 99} + # Do the same kind of thing except use a join as the data source. #