-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
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
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
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
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
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
-562da534bbb605a8ce15824135b012ef2d86bbeb
\ No newline at end of file
+3b68aa25c451b7c09ece457ac2b70a9a5d93508a
\ No newline at end of file
** 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>
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;
}
}
}
}
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;
}
*/
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);
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{
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);
}
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);
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;
switch( pExpr->op ){
case TK_FUNCTION: {
*pzName = pExpr->token.z;
- *pnName = pExpr->nFuncName;
+ *pnName = pExpr->token.n;
break;
}
case TK_LIKE: {
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;
}
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;
** 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}
%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);}
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);}
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);
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;}
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);
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);
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 */
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 //////////////////////////////
** 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"
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);
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;
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];
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,
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);
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);
}
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);
}
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 ){
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 ){
*************************************************************************
** 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"
/*
** 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 */
};
/*
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
** 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"
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;
# 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
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.
# 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
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.
#
projects / thirdparty / sqlite.git / commitdiff
