Correctly handle column names and string constants in parentheses.
Fix for ticket #179. (CVS 770) FossilOrigin-Name: 3b68aa25c451b7c09ece457ac2b70a9a5d93508a
This commit is contained in:
drh
parent
e958bb4aef
commit
6977fea801
24
manifest
24
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
|
||||
|
||||
@ -1 +1 @@
|
||||
562da534bbb605a8ce15824135b012ef2d86bbeb
|
||||
3b68aa25c451b7c09ece457ac2b70a9a5d93508a
|
||||
72
src/expr.c
72
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 <ctype.h>
|
||||
@ -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; i<p->nExpr; 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;
|
||||
|
||||
48
src/parse.y
48
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 //////////////////////////////
|
||||
|
||||
43
src/select.c
43
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; i<pList->nExpr; 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 ){
|
||||
|
||||
@ -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 "<expr> IN (<expr-list)" */
|
||||
Token token; /* An operand token */
|
||||
Token span; /* Complete text of the expression */
|
||||
int iTable, iColumn; /* When op==TK_COLUMN, then this expr node means the
|
||||
** iColumn-th field of the iTable-th table. */
|
||||
int iAgg; /* When op==TK_COLUMN and pParse->useAgg==TRUE, pull
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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.
|
||||
#
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user