Correctly handle column names and string constants in parentheses.

Fix for ticket #179. (CVS 770)

FossilOrigin-Name: 3b68aa25c451b7c09ece457ac2b70a9a5d93508a

5 files changed, 74 insertions, 105 deletions

diff --git a/src/expr.c b/src/expr.c
index 0aaaf0e87..b2ec92e2e 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 <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;
diff --git a/src/parse.y b/src/parse.y
index 5a4242b18..e2dd57f5a 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 a885a44c6..e964f48fd 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; 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 ){
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 63b39f9d4..60ec0dadc 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 "<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
diff --git a/src/tokenize.c b/src/tokenize.c
index 4637f6138..8b03bd94e 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;