Change lots of internal symbols from sqliteXXX to sqlite3XXX so that the

library links again. It doesn't work yet, due to changes in the btree layer
calling convention. (CVS 1324)

FossilOrigin-Name: 8af6474c49263ae26216dff9465b33f76b500cf4

1 files changed, 270 insertions, 267 deletions

diff --git a/src/expr.c b/src/expr.c
index f92dbc078..ed464ebf8 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.114 2004/04/23 17:04:45 drh Exp $
+** $Id: expr.c,v 1.115 2004/05/08 08:23:24 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include <ctype.h>
@@ -22,7 +22,7 @@
 ** for this node is obtained from sqliteMalloc().  The calling function
 ** is responsible for making sure the node eventually gets freed.
 */
-Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){
+Expr *sqlite3Expr(int op, Expr *pLeft, Expr *pRight, Token *pToken){
   Expr *pNew;
   pNew = sqliteMalloc( sizeof(Expr) );
   if( pNew==0 ){
@@ -41,7 +41,7 @@ Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){
     assert( pNew->token.z==0 );
     assert( pNew->token.n==0 );
     if( pLeft && pRight ){
-      sqliteExprSpan(pNew, &pLeft->span, &pRight->span);
+      sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span);
     }else{
       pNew->span = pNew->token;
     }
@@ -53,7 +53,7 @@ Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){
 ** 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){
+void sqlite3ExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){
   assert( pRight!=0 );
   assert( pLeft!=0 );
   /* Note: pExpr might be NULL due to a prior malloc failure */
@@ -71,11 +71,11 @@ void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){
 ** Construct a new expression node for a function with multiple
 ** arguments.
 */
-Expr *sqliteExprFunction(ExprList *pList, Token *pToken){
+Expr *sqlite3ExprFunction(ExprList *pList, Token *pToken){
   Expr *pNew;
   pNew = sqliteMalloc( sizeof(Expr) );
   if( pNew==0 ){
-    /* sqliteExprListDelete(pList); // Leak pList when malloc fails */
+    /* sqlite3ExprListDelete(pList); // Leak pList when malloc fails */
     return 0;
   }
   pNew->op = TK_FUNCTION;
@@ -93,14 +93,14 @@ Expr *sqliteExprFunction(ExprList *pList, Token *pToken){
 /*
 ** Recursively delete an expression tree.
 */
-void sqliteExprDelete(Expr *p){
+void sqlite3ExprDelete(Expr *p){
   if( p==0 ) return;
   if( p->span.dyn ) sqliteFree((char*)p->span.z);
   if( p->token.dyn ) sqliteFree((char*)p->token.z);
-  sqliteExprDelete(p->pLeft);
-  sqliteExprDelete(p->pRight);
-  sqliteExprListDelete(p->pList);
-  sqliteSelectDelete(p->pSelect);
+  sqlite3ExprDelete(p->pLeft);
+  sqlite3ExprDelete(p->pRight);
+  sqlite3ExprListDelete(p->pList);
+  sqlite3SelectDelete(p->pSelect);
   sqliteFree(p);
 }
 
@@ -111,13 +111,13 @@ void sqliteExprDelete(Expr *p){
 ** be deleted (by being passed to their respective ...Delete() routines)
 ** without effecting the originals.
 **
-** The expression list, ID, and source lists return by sqliteExprListDup(),
-** sqliteIdListDup(), and sqliteSrcListDup() can not be further expanded 
+** The expression list, ID, and source lists return by sqlite3ExprListDup(),
+** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded 
 ** by subsequent calls to sqlite*ListAppend() routines.
 **
 ** Any tables that the SrcList might point to are not duplicated.
 */
-Expr *sqliteExprDup(Expr *p){
+Expr *sqlite3ExprDup(Expr *p){
   Expr *pNew;
   if( p==0 ) return 0;
   pNew = sqliteMallocRaw( sizeof(*p) );
@@ -130,13 +130,13 @@ Expr *sqliteExprDup(Expr *p){
     assert( pNew->token.z==0 );
   }
   pNew->span.z = 0;
-  pNew->pLeft = sqliteExprDup(p->pLeft);
-  pNew->pRight = sqliteExprDup(p->pRight);
-  pNew->pList = sqliteExprListDup(p->pList);
-  pNew->pSelect = sqliteSelectDup(p->pSelect);
+  pNew->pLeft = sqlite3ExprDup(p->pLeft);
+  pNew->pRight = sqlite3ExprDup(p->pRight);
+  pNew->pList = sqlite3ExprListDup(p->pList);
+  pNew->pSelect = sqlite3SelectDup(p->pSelect);
   return pNew;
 }
-void sqliteTokenCopy(Token *pTo, Token *pFrom){
+void sqlite3TokenCopy(Token *pTo, Token *pFrom){
   if( pTo->dyn ) sqliteFree((char*)pTo->z);
   if( pFrom->z ){
     pTo->n = pFrom->n;
@@ -146,7 +146,7 @@ void sqliteTokenCopy(Token *pTo, Token *pFrom){
     pTo->z = 0;
   }
 }
-ExprList *sqliteExprListDup(ExprList *p){
+ExprList *sqlite3ExprListDup(ExprList *p){
   ExprList *pNew;
   struct ExprList_item *pItem;
   int i;
@@ -158,12 +158,12 @@ ExprList *sqliteExprListDup(ExprList *p){
   if( pItem==0 ) return 0;  /* Leaks memory after a malloc failure */
   for(i=0; i<p->nExpr; i++, pItem++){
     Expr *pNewExpr, *pOldExpr;
-    pItem->pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr);
+    pItem->pExpr = pNewExpr = sqlite3ExprDup(pOldExpr = p->a[i].pExpr);
     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(&pNewExpr->span, &pOldExpr->span);
+      sqlite3TokenCopy(&pNewExpr->span, &pOldExpr->span);
     }
     assert( pNewExpr==0 || pNewExpr->span.z!=0 
             || pOldExpr->span.z==0 || sqlite_malloc_failed );
@@ -174,7 +174,7 @@ ExprList *sqliteExprListDup(ExprList *p){
   }
   return pNew;
 }
-SrcList *sqliteSrcListDup(SrcList *p){
+SrcList *sqlite3SrcListDup(SrcList *p){
   SrcList *pNew;
   int i;
   int nByte;
@@ -192,13 +192,13 @@ SrcList *sqliteSrcListDup(SrcList *p){
     pNewItem->jointype = pOldItem->jointype;
     pNewItem->iCursor = pOldItem->iCursor;
     pNewItem->pTab = 0;
-    pNewItem->pSelect = sqliteSelectDup(pOldItem->pSelect);
-    pNewItem->pOn = sqliteExprDup(pOldItem->pOn);
-    pNewItem->pUsing = sqliteIdListDup(pOldItem->pUsing);
+    pNewItem->pSelect = sqlite3SelectDup(pOldItem->pSelect);
+    pNewItem->pOn = sqlite3ExprDup(pOldItem->pOn);
+    pNewItem->pUsing = sqlite3IdListDup(pOldItem->pUsing);
   }
   return pNew;
 }
-IdList *sqliteIdListDup(IdList *p){
+IdList *sqlite3IdListDup(IdList *p){
   IdList *pNew;
   int i;
   if( p==0 ) return 0;
@@ -215,20 +215,20 @@ IdList *sqliteIdListDup(IdList *p){
   }
   return pNew;
 }
-Select *sqliteSelectDup(Select *p){
+Select *sqlite3SelectDup(Select *p){
   Select *pNew;
   if( p==0 ) return 0;
   pNew = sqliteMallocRaw( sizeof(*p) );
   if( pNew==0 ) return 0;
   pNew->isDistinct = p->isDistinct;
-  pNew->pEList = sqliteExprListDup(p->pEList);
-  pNew->pSrc = sqliteSrcListDup(p->pSrc);
-  pNew->pWhere = sqliteExprDup(p->pWhere);
-  pNew->pGroupBy = sqliteExprListDup(p->pGroupBy);
-  pNew->pHaving = sqliteExprDup(p->pHaving);
-  pNew->pOrderBy = sqliteExprListDup(p->pOrderBy);
+  pNew->pEList = sqlite3ExprListDup(p->pEList);
+  pNew->pSrc = sqlite3SrcListDup(p->pSrc);
+  pNew->pWhere = sqlite3ExprDup(p->pWhere);
+  pNew->pGroupBy = sqlite3ExprListDup(p->pGroupBy);
+  pNew->pHaving = sqlite3ExprDup(p->pHaving);
+  pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy);
   pNew->op = p->op;
-  pNew->pPrior = sqliteSelectDup(p->pPrior);
+  pNew->pPrior = sqlite3SelectDup(p->pPrior);
   pNew->nLimit = p->nLimit;
   pNew->nOffset = p->nOffset;
   pNew->zSelect = 0;
@@ -242,11 +242,11 @@ Select *sqliteSelectDup(Select *p){
 ** Add a new element to the end of an expression list.  If pList is
 ** initially NULL, then create a new expression list.
 */
-ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){
+ExprList *sqlite3ExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){
   if( pList==0 ){
     pList = sqliteMalloc( sizeof(ExprList) );
     if( pList==0 ){
-      /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */
+      /* sqlite3ExprDelete(pExpr); // Leak memory if malloc fails */
       return 0;
     }
     assert( pList->nAlloc==0 );
@@ -255,7 +255,7 @@ ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){
     pList->nAlloc = pList->nAlloc*2 + 4;
     pList->a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]));
     if( pList->a==0 ){
-      /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */
+      /* sqlite3ExprDelete(pExpr); // Leak memory if malloc fails */
       pList->nExpr = pList->nAlloc = 0;
       return pList;
     }
@@ -266,8 +266,8 @@ ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){
     memset(pItem, 0, sizeof(*pItem));
     pItem->pExpr = pExpr;
     if( pName ){
-      sqliteSetNString(&pItem->zName, pName->z, pName->n, 0);
-      sqliteDequote(pItem->zName);
+      sqlite3SetNString(&pItem->zName, pName->z, pName->n, 0);
+      sqlite3Dequote(pItem->zName);
     }
   }
   return pList;
@@ -276,13 +276,13 @@ ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){
 /*
 ** Delete an entire expression list.
 */
-void sqliteExprListDelete(ExprList *pList){
+void sqlite3ExprListDelete(ExprList *pList){
   int i;
   if( pList==0 ) return;
   assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
   assert( pList->nExpr<=pList->nAlloc );
   for(i=0; i<pList->nExpr; i++){
-    sqliteExprDelete(pList->a[i].pExpr);
+    sqlite3ExprDelete(pList->a[i].pExpr);
     sqliteFree(pList->a[i].zName);
   }
   sqliteFree(pList->a);
@@ -297,7 +297,7 @@ void sqliteExprListDelete(ExprList *pList){
 ** is considered a variable but a single-quoted string (ex: 'abc') is
 ** a constant.
 */
-int sqliteExprIsConstant(Expr *p){
+int sqlite3ExprIsConstant(Expr *p){
   switch( p->op ){
     case TK_ID:
     case TK_COLUMN:
@@ -311,12 +311,12 @@ int sqliteExprIsConstant(Expr *p){
     case TK_VARIABLE:
       return 1;
     default: {
-      if( p->pLeft && !sqliteExprIsConstant(p->pLeft) ) return 0;
-      if( p->pRight && !sqliteExprIsConstant(p->pRight) ) return 0;
+      if( p->pLeft && !sqlite3ExprIsConstant(p->pLeft) ) return 0;
+      if( p->pRight && !sqlite3ExprIsConstant(p->pRight) ) return 0;
       if( p->pList ){
         int i;
         for(i=0; i<p->pList->nExpr; i++){
-          if( !sqliteExprIsConstant(p->pList->a[i].pExpr) ) return 0;
+          if( !sqlite3ExprIsConstant(p->pList->a[i].pExpr) ) return 0;
         }
       }
       return p->pLeft!=0 || p->pRight!=0 || (p->pList && p->pList->nExpr>0);
@@ -331,10 +331,10 @@ int sqliteExprIsConstant(Expr *p){
 ** in *pValue.  If the expression is not an integer or if it is too big
 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
 */
-int sqliteExprIsInteger(Expr *p, int *pValue){
+int sqlite3ExprIsInteger(Expr *p, int *pValue){
   switch( p->op ){
     case TK_INTEGER: {
-      if( sqliteFitsIn32Bits(p->token.z) ){
+      if( sqlite3FitsIn32Bits(p->token.z) ){
         *pValue = atoi(p->token.z);
         return 1;
       }
@@ -345,18 +345,18 @@ int sqliteExprIsInteger(Expr *p, int *pValue){
       int n = p->token.n;
       if( n>0 && z[0]=='-' ){ z++; n--; }
       while( n>0 && *z && isdigit(*z) ){ z++; n--; }
-      if( n==0 && sqliteFitsIn32Bits(p->token.z) ){
+      if( n==0 && sqlite3FitsIn32Bits(p->token.z) ){
         *pValue = atoi(p->token.z);
         return 1;
       }
       break;
     }
     case TK_UPLUS: {
-      return sqliteExprIsInteger(p->pLeft, pValue);
+      return sqlite3ExprIsInteger(p->pLeft, pValue);
     }
     case TK_UMINUS: {
       int v;
-      if( sqliteExprIsInteger(p->pLeft, &v) ){
+      if( sqlite3ExprIsInteger(p->pLeft, &v) ){
         *pValue = -v;
         return 1;
       }
@@ -370,10 +370,10 @@ int sqliteExprIsInteger(Expr *p, int *pValue){
 /*
 ** Return TRUE if the given string is a row-id column name.
 */
-int sqliteIsRowid(const char *z){
-  if( sqliteStrICmp(z, "_ROWID_")==0 ) return 1;
-  if( sqliteStrICmp(z, "ROWID")==0 ) return 1;
-  if( sqliteStrICmp(z, "OID")==0 ) return 1;
+int sqlite3IsRowid(const char *z){
+  if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
+  if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
+  if( sqlite3StrICmp(z, "OID")==0 ) return 1;
   return 0;
 }
 
@@ -423,19 +423,19 @@ static int lookupName(
   assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */
   if( pDbToken && pDbToken->z ){
     zDb = sqliteStrNDup(pDbToken->z, pDbToken->n);
-    sqliteDequote(zDb);
+    sqlite3Dequote(zDb);
   }else{
     zDb = 0;
   }
   if( pTableToken && pTableToken->z ){
     zTab = sqliteStrNDup(pTableToken->z, pTableToken->n);
-    sqliteDequote(zTab);
+    sqlite3Dequote(zTab);
   }else{
     assert( zDb==0 );
     zTab = 0;
   }
   zCol = sqliteStrNDup(pColumnToken->z, pColumnToken->n);
-  sqliteDequote(zCol);
+  sqlite3Dequote(zCol);
   if( sqlite_malloc_failed ){
     return 1;  /* Leak memory (zDb and zTab) if malloc fails */
   }
@@ -452,11 +452,11 @@ static int lookupName(
     if( zTab ){
       if( pItem->zAlias ){
         char *zTabName = pItem->zAlias;
-        if( sqliteStrICmp(zTabName, zTab)!=0 ) continue;
+        if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
       }else{
         char *zTabName = pTab->zName;
-        if( zTabName==0 || sqliteStrICmp(zTabName, zTab)!=0 ) continue;
-        if( zDb!=0 && sqliteStrICmp(db->aDb[pTab->iDb].zName, zDb)!=0 ){
+        if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
+        if( zDb!=0 && sqlite3StrICmp(db->aDb[pTab->iDb].zName, zDb)!=0 ){
           continue;
         }
       }
@@ -466,7 +466,7 @@ static int lookupName(
       pExpr->iDb = pTab->iDb;
     }
     for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
-      if( sqliteStrICmp(pCol->zName, zCol)==0 ){
+      if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
         cnt++;
         pExpr->iTable = pItem->iCursor;
         pExpr->iDb = pTab->iDb;
@@ -484,11 +484,11 @@ static int lookupName(
   if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){
     TriggerStack *pTriggerStack = pParse->trigStack;
     Table *pTab = 0;
-    if( pTriggerStack->newIdx != -1 && sqliteStrICmp("new", zTab) == 0 ){
+    if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){
       pExpr->iTable = pTriggerStack->newIdx;
       assert( pTriggerStack->pTab );
       pTab = pTriggerStack->pTab;
-    }else if( pTriggerStack->oldIdx != -1 && sqliteStrICmp("old", zTab) == 0 ){
+    }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab) == 0 ){
       pExpr->iTable = pTriggerStack->oldIdx;
       assert( pTriggerStack->pTab );
       pTab = pTriggerStack->pTab;
@@ -501,7 +501,7 @@ static int lookupName(
       pExpr->iDb = pTab->iDb;
       cntTab++;
       for(j=0; j < pTab->nCol; j++, pCol++) {
-        if( sqliteStrICmp(pCol->zName, zCol)==0 ){
+        if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
           cnt++;
           pExpr->iColumn = j==pTab->iPKey ? -1 : j;
           pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK;
@@ -514,7 +514,7 @@ static int lookupName(
   /*
   ** Perhaps the name is a reference to the ROWID
   */
-  if( cnt==0 && cntTab==1 && sqliteIsRowid(zCol) ){
+  if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
     cnt = 1;
     pExpr->iColumn = -1;
     pExpr->dataType = SQLITE_SO_NUM;
@@ -535,11 +535,11 @@ static int lookupName(
   if( cnt==0 && pEList!=0 ){
     for(j=0; j<pEList->nExpr; j++){
       char *zAs = pEList->a[j].zName;
-      if( zAs!=0 && sqliteStrICmp(zAs, zCol)==0 ){
+      if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
         assert( pExpr->pLeft==0 && pExpr->pRight==0 );
         pExpr->op = TK_AS;
         pExpr->iColumn = j;
-        pExpr->pLeft = sqliteExprDup(pEList->a[j].pExpr);
+        pExpr->pLeft = sqlite3ExprDup(pEList->a[j].pExpr);
         sqliteFree(zCol);
         assert( zTab==0 && zDb==0 );
         return 0;
@@ -568,13 +568,13 @@ static int lookupName(
     char *zErr;
     zErr = cnt==0 ? "no such column: %s" : "ambiguous column name: %s";
     if( zDb ){
-      sqliteSetString(&z, zDb, ".", zTab, ".", zCol, 0);
+      sqlite3SetString(&z, zDb, ".", zTab, ".", zCol, 0);
     }else if( zTab ){
-      sqliteSetString(&z, zTab, ".", zCol, 0);
+      sqlite3SetString(&z, zTab, ".", zCol, 0);
     }else{
       z = sqliteStrDup(zCol);
     }
-    sqliteErrorMsg(pParse, zErr, z);
+    sqlite3ErrorMsg(pParse, zErr, z);
     sqliteFree(z);
   }
 
@@ -583,12 +583,12 @@ static int lookupName(
   sqliteFree(zDb);
   sqliteFree(zTab);
   sqliteFree(zCol);
-  sqliteExprDelete(pExpr->pLeft);
+  sqlite3ExprDelete(pExpr->pLeft);
   pExpr->pLeft = 0;
-  sqliteExprDelete(pExpr->pRight);
+  sqlite3ExprDelete(pExpr->pRight);
   pExpr->pRight = 0;
   pExpr->op = TK_COLUMN;
-  sqliteAuthRead(pParse, pExpr, pSrcList);
+  sqlite3AuthRead(pParse, pExpr, pSrcList);
   return cnt!=1;
 }
 
@@ -623,7 +623,7 @@ static int lookupName(
 ** Unknown columns or tables provoke an error.  The function returns
 ** the number of errors seen and leaves an error message on pParse->zErrMsg.
 */
-int sqliteExprResolveIds(
+int sqlite3ExprResolveIds(
   Parse *pParse,     /* The parser context */
   SrcList *pSrcList, /* List of tables used to resolve column names */
   ExprList *pEList,  /* List of expressions used to resolve "AS" */
@@ -680,9 +680,9 @@ int sqliteExprResolveIds(
     }
 
     case TK_IN: {
-      Vdbe *v = sqliteGetVdbe(pParse);
+      Vdbe *v = sqlite3GetVdbe(pParse);
       if( v==0 ) return 1;
-      if( sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
+      if( sqlite3ExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
         return 1;
       }
       if( pExpr->pSelect ){
@@ -690,11 +690,11 @@ int sqliteExprResolveIds(
         **
         ** Generate code to write the results of the select into a temporary
         ** table.  The cursor number of the temporary table has already
-        ** been put in iTable by sqliteExprResolveInSelect().
+        ** been put in iTable by sqlite3ExprResolveInSelect().
         */
         pExpr->iTable = pParse->nTab++;
-        sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1);
-        sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0);
+        sqlite3VdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1);
+        sqlite3Select(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0);
       }else if( pExpr->pList ){
         /* Case 2:     expr IN (exprlist)
         **
@@ -704,12 +704,12 @@ int sqliteExprResolveIds(
         int i, iSet;
         for(i=0; i<pExpr->pList->nExpr; i++){
           Expr *pE2 = pExpr->pList->a[i].pExpr;
-          if( !sqliteExprIsConstant(pE2) ){
-            sqliteErrorMsg(pParse,
+          if( !sqlite3ExprIsConstant(pE2) ){
+            sqlite3ErrorMsg(pParse,
               "right-hand side of IN operator must be constant");
             return 1;
           }
-          if( sqliteExprCheck(pParse, pE2, 0, 0) ){
+          if( sqlite3ExprCheck(pParse, pE2, 0, 0) ){
             return 1;
           }
         }
@@ -722,14 +722,14 @@ int sqliteExprResolveIds(
             case TK_STRING: {
               int addr;
               assert( pE2->token.z );
-              addr = sqliteVdbeOp3(v, OP_SetInsert, iSet, 0,
+              addr = sqlite3VdbeOp3(v, OP_SetInsert, iSet, 0,
                                   pE2->token.z, pE2->token.n);
-              sqliteVdbeDequoteP3(v, addr);
+              sqlite3VdbeDequoteP3(v, addr);
               break;
             }
             default: {
-              sqliteExprCode(pParse, pE2);
-              sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0);
+              sqlite3ExprCode(pParse, pE2);
+              sqlite3VdbeAddOp(v, OP_SetInsert, iSet, 0);
               break;
             }
           }
@@ -744,7 +744,7 @@ int sqliteExprResolveIds(
       ** of the memory cell in iColumn.
       */
       pExpr->iColumn = pParse->nMem++;
-      if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){
+      if( sqlite3Select(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){
         return 1;
       }
       break;
@@ -753,11 +753,11 @@ int sqliteExprResolveIds(
     /* For all else, just recursively walk the tree */
     default: {
       if( pExpr->pLeft
-      && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
+      && sqlite3ExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
         return 1;
       }
       if( pExpr->pRight 
-      && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){
+      && sqlite3ExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){
         return 1;
       }
       if( pExpr->pList ){
@@ -765,7 +765,7 @@ int sqliteExprResolveIds(
         ExprList *pList = pExpr->pList;
         for(i=0; i<pList->nExpr; i++){
           Expr *pArg = pList->a[i].pExpr;
-          if( sqliteExprResolveIds(pParse, pSrcList, pEList, pArg) ){
+          if( sqlite3ExprResolveIds(pParse, pSrcList, pEList, pArg) ){
             return 1;
           }
         }
@@ -817,7 +817,7 @@ static void getFunctionName(Expr *pExpr, const char **pzName, int *pnName){
 ** if pIsAgg is not null and this expression is an aggregate function
 ** (like count(*) or max(value)) then write a 1 into *pIsAgg.
 */
-int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
+int sqlite3ExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
   int nErr = 0;
   if( pExpr==0 ) return 0;
   switch( pExpr->op ){
@@ -834,9 +834,9 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
       FuncDef *pDef;
 
       getFunctionName(pExpr, &zId, &nId);
-      pDef = sqliteFindFunction(pParse->db, zId, nId, n, 0);
+      pDef = sqlite3FindFunction(pParse->db, zId, nId, n, 0);
       if( pDef==0 ){
-        pDef = sqliteFindFunction(pParse->db, zId, nId, -1, 0);
+        pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, 0);
         if( pDef==0 ){
           no_such_func = 1;
         }else{
@@ -846,14 +846,14 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
         is_agg = pDef->xFunc==0;
       }
       if( is_agg && !allowAgg ){
-        sqliteErrorMsg(pParse, "misuse of aggregate function %.*s()", nId, zId);
+        sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId, zId);
         nErr++;
         is_agg = 0;
       }else if( no_such_func ){
-        sqliteErrorMsg(pParse, "no such function: %.*s", nId, zId);
+        sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
         nErr++;
       }else if( wrong_num_args ){
-        sqliteErrorMsg(pParse,"wrong number of arguments to function %.*s()",
+        sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
              nId, zId);
         nErr++;
       }
@@ -862,7 +862,7 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
         if( pIsAgg ) *pIsAgg = 1;
       }
       for(i=0; nErr==0 && i<n; i++){
-        nErr = sqliteExprCheck(pParse, pExpr->pList->a[i].pExpr,
+        nErr = sqlite3ExprCheck(pParse, pExpr->pList->a[i].pExpr,
                                allowAgg && !is_agg, pIsAgg);
       }
       if( pDef==0 ){
@@ -870,14 +870,14 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
       }else if( pDef->dataType>=0 ){
         if( pDef->dataType<n ){
           pExpr->dataType = 
-             sqliteExprType(pExpr->pList->a[pDef->dataType].pExpr);
+             sqlite3ExprType(pExpr->pList->a[pDef->dataType].pExpr);
         }else{
           pExpr->dataType = SQLITE_SO_NUM;
         }
       }else if( pDef->dataType==SQLITE_ARGS ){
         pDef->dataType = SQLITE_SO_TEXT;
         for(i=0; i<n; i++){
-          if( sqliteExprType(pExpr->pList->a[i].pExpr)==SQLITE_SO_NUM ){
+          if( sqlite3ExprType(pExpr->pList->a[i].pExpr)==SQLITE_SO_NUM ){
             pExpr->dataType = SQLITE_SO_NUM;
             break;
           }
@@ -890,17 +890,17 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
     }
     default: {
       if( pExpr->pLeft ){
-        nErr = sqliteExprCheck(pParse, pExpr->pLeft, allowAgg, pIsAgg);
+        nErr = sqlite3ExprCheck(pParse, pExpr->pLeft, allowAgg, pIsAgg);
       }
       if( nErr==0 && pExpr->pRight ){
-        nErr = sqliteExprCheck(pParse, pExpr->pRight, allowAgg, pIsAgg);
+        nErr = sqlite3ExprCheck(pParse, pExpr->pRight, allowAgg, pIsAgg);
       }
       if( nErr==0 && pExpr->pList ){
         int n = pExpr->pList->nExpr;
         int i;
         for(i=0; nErr==0 && i<n; i++){
           Expr *pE2 = pExpr->pList->a[i].pExpr;
-          nErr = sqliteExprCheck(pParse, pE2, allowAgg, pIsAgg);
+          nErr = sqlite3ExprCheck(pParse, pE2, allowAgg, pIsAgg);
         }
       }
       break;
@@ -913,10 +913,10 @@ int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){
 ** Return either SQLITE_SO_NUM or SQLITE_SO_TEXT to indicate whether the
 ** given expression should sort as numeric values or as text.
 **
-** The sqliteExprResolveIds() and sqliteExprCheck() routines must have
+** The sqlite3ExprResolveIds() and sqlite3ExprCheck() routines must have
 ** both been called on the expression before it is passed to this routine.
 */
-int sqliteExprType(Expr *p){
+int sqlite3ExprType(Expr *p){
   if( p==0 ) return SQLITE_SO_NUM;
   while( p ) switch( p->op ){
     case TK_PLUS:
@@ -956,7 +956,7 @@ int sqliteExprType(Expr *p){
     case TK_GE:
     case TK_NE:
     case TK_EQ:
-      if( sqliteExprType(p->pLeft)==SQLITE_SO_NUM ){
+      if( sqlite3ExprType(p->pLeft)==SQLITE_SO_NUM ){
         return SQLITE_SO_NUM;
       }
       p = p->pRight;
@@ -979,14 +979,14 @@ int sqliteExprType(Expr *p){
       break;
 
     case TK_CASE: {
-      if( p->pRight && sqliteExprType(p->pRight)==SQLITE_SO_NUM ){
+      if( p->pRight && sqlite3ExprType(p->pRight)==SQLITE_SO_NUM ){
         return SQLITE_SO_NUM;
       }
       if( p->pList ){
         int i;
         ExprList *pList = p->pList;
         for(i=1; i<pList->nExpr; i+=2){
-          if( sqliteExprType(pList->a[i].pExpr)==SQLITE_SO_NUM ){
+          if( sqlite3ExprType(pList->a[i].pExpr)==SQLITE_SO_NUM ){
             return SQLITE_SO_NUM;
           }
         }
@@ -1005,7 +1005,7 @@ int sqliteExprType(Expr *p){
 ** Generate code into the current Vdbe to evaluate the given
 ** expression and leave the result on the top of stack.
 */
-void sqliteExprCode(Parse *pParse, Expr *pExpr){
+void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
   Vdbe *v = pParse->pVdbe;
   int op;
   if( v==0 || pExpr==0 ) return;
@@ -1037,33 +1037,33 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
   switch( pExpr->op ){
     case TK_COLUMN: {
       if( pParse->useAgg ){
-        sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg);
+        sqlite3VdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg);
       }else if( pExpr->iColumn>=0 ){
-        sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn);
+        sqlite3VdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn);
       }else{
-        sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0);
+        sqlite3VdbeAddOp(v, OP_Recno, pExpr->iTable, 0);
       }
       break;
     }
     case TK_STRING:
     case TK_FLOAT:
     case TK_INTEGER: {
-      if( pExpr->op==TK_INTEGER && sqliteFitsIn32Bits(pExpr->token.z) ){
-        sqliteVdbeAddOp(v, OP_Integer, atoi(pExpr->token.z), 0);
+      if( pExpr->op==TK_INTEGER && sqlite3FitsIn32Bits(pExpr->token.z) ){
+        sqlite3VdbeAddOp(v, OP_Integer, atoi(pExpr->token.z), 0);
       }else{
-        sqliteVdbeAddOp(v, OP_String, 0, 0);
+        sqlite3VdbeAddOp(v, OP_String, 0, 0);
       }
       assert( pExpr->token.z );
-      sqliteVdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n);
-      sqliteVdbeDequoteP3(v, -1);
+      sqlite3VdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n);
+      sqlite3VdbeDequoteP3(v, -1);
       break;
     }
     case TK_NULL: {
-      sqliteVdbeAddOp(v, OP_String, 0, 0);
+      sqlite3VdbeAddOp(v, OP_String, 0, 0);
       break;
     }
     case TK_VARIABLE: {
-      sqliteVdbeAddOp(v, OP_Variable, pExpr->iTable, 0);
+      sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0);
       break;
     }
     case TK_LT:
@@ -1072,7 +1072,7 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
     case TK_GE:
     case TK_NE:
     case TK_EQ: {
-      if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){
+      if( pParse->db->file_format>=4 && sqlite3ExprType(pExpr)==SQLITE_SO_TEXT ){
         op += 6;  /* Convert numeric opcodes to text opcodes */
       }
       /* Fall through into the next case */
@@ -1086,22 +1086,22 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
     case TK_BITAND:
     case TK_BITOR:
     case TK_SLASH: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteExprCode(pParse, pExpr->pRight);
-      sqliteVdbeAddOp(v, op, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3ExprCode(pParse, pExpr->pRight);
+      sqlite3VdbeAddOp(v, op, 0, 0);
       break;
     }
     case TK_LSHIFT:
     case TK_RSHIFT: {
-      sqliteExprCode(pParse, pExpr->pRight);
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, op, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pRight);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, op, 0, 0);
       break;
     }
     case TK_CONCAT: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteExprCode(pParse, pExpr->pRight);
-      sqliteVdbeAddOp(v, OP_Concat, 2, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3ExprCode(pParse, pExpr->pRight);
+      sqlite3VdbeAddOp(v, OP_Concat, 2, 0);
       break;
     }
     case TK_UMINUS: {
@@ -1110,12 +1110,12 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
         Token *p = &pExpr->pLeft->token;
         char *z = sqliteMalloc( p->n + 2 );
         sprintf(z, "-%.*s", p->n, p->z);
-        if( pExpr->pLeft->op==TK_INTEGER && sqliteFitsIn32Bits(z) ){
-          sqliteVdbeAddOp(v, OP_Integer, atoi(z), 0);
+        if( pExpr->pLeft->op==TK_INTEGER && sqlite3FitsIn32Bits(z) ){
+          sqlite3VdbeAddOp(v, OP_Integer, atoi(z), 0);
         }else{
-          sqliteVdbeAddOp(v, OP_String, 0, 0);
+          sqlite3VdbeAddOp(v, OP_String, 0, 0);
         }
-        sqliteVdbeChangeP3(v, -1, z, p->n+1);
+        sqlite3VdbeChangeP3(v, -1, z, p->n+1);
         sqliteFree(z);
         break;
       }
@@ -1123,22 +1123,22 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
     }
     case TK_BITNOT:
     case TK_NOT: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, op, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, op, 0, 0);
       break;
     }
     case TK_ISNULL:
     case TK_NOTNULL: {
       int dest;
-      sqliteVdbeAddOp(v, OP_Integer, 1, 0);
-      sqliteExprCode(pParse, pExpr->pLeft);
-      dest = sqliteVdbeCurrentAddr(v) + 2;
-      sqliteVdbeAddOp(v, op, 1, dest);
-      sqliteVdbeAddOp(v, OP_AddImm, -1, 0);
+      sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      dest = sqlite3VdbeCurrentAddr(v) + 2;
+      sqlite3VdbeAddOp(v, op, 1, dest);
+      sqlite3VdbeAddOp(v, OP_AddImm, -1, 0);
       break;
     }
     case TK_AGG_FUNCTION: {
-      sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg);
+      sqlite3VdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg);
       break;
     }
     case TK_GLOB:
@@ -1150,47 +1150,47 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
       int nId;
       const char *zId;
       getFunctionName(pExpr, &zId, &nId);
-      pDef = sqliteFindFunction(pParse->db, zId, nId, nExpr, 0);
+      pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, 0);
       assert( pDef!=0 );
-      nExpr = sqliteExprCodeExprList(pParse, pList, pDef->includeTypes);
-      sqliteVdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER);
+      nExpr = sqlite3ExprCodeExprList(pParse, pList, pDef->includeTypes);
+      sqlite3VdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER);
       break;
     }
     case TK_SELECT: {
-      sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0);
+      sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0);
       break;
     }
     case TK_IN: {
       int addr;
-      sqliteVdbeAddOp(v, OP_Integer, 1, 0);
-      sqliteExprCode(pParse, pExpr->pLeft);
-      addr = sqliteVdbeCurrentAddr(v);
-      sqliteVdbeAddOp(v, OP_NotNull, -1, addr+4);
-      sqliteVdbeAddOp(v, OP_Pop, 2, 0);
-      sqliteVdbeAddOp(v, OP_String, 0, 0);
-      sqliteVdbeAddOp(v, OP_Goto, 0, addr+6);
+      sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      addr = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+4);
+      sqlite3VdbeAddOp(v, OP_Pop, 2, 0);
+      sqlite3VdbeAddOp(v, OP_String, 0, 0);
+      sqlite3VdbeAddOp(v, OP_Goto, 0, addr+6);
       if( pExpr->pSelect ){
-        sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, addr+6);
+        sqlite3VdbeAddOp(v, OP_Found, pExpr->iTable, addr+6);
       }else{
-        sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+6);
+        sqlite3VdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+6);
       }
-      sqliteVdbeAddOp(v, OP_AddImm, -1, 0);
+      sqlite3VdbeAddOp(v, OP_AddImm, -1, 0);
       break;
     }
     case TK_BETWEEN: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, OP_Dup, 0, 0);
-      sqliteExprCode(pParse, pExpr->pList->a[0].pExpr);
-      sqliteVdbeAddOp(v, OP_Ge, 0, 0);
-      sqliteVdbeAddOp(v, OP_Pull, 1, 0);
-      sqliteExprCode(pParse, pExpr->pList->a[1].pExpr);
-      sqliteVdbeAddOp(v, OP_Le, 0, 0);
-      sqliteVdbeAddOp(v, OP_And, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pList->a[0].pExpr);
+      sqlite3VdbeAddOp(v, OP_Ge, 0, 0);
+      sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
+      sqlite3ExprCode(pParse, pExpr->pList->a[1].pExpr);
+      sqlite3VdbeAddOp(v, OP_Le, 0, 0);
+      sqlite3VdbeAddOp(v, OP_And, 0, 0);
       break;
     }
     case TK_UPLUS:
     case TK_AS: {
-      sqliteExprCode(pParse, pExpr->pLeft);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
       break;
     }
     case TK_CASE: {
@@ -1204,38 +1204,38 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
       assert((pExpr->pList->nExpr % 2) == 0);
       assert(pExpr->pList->nExpr > 0);
       nExpr = pExpr->pList->nExpr;
-      expr_end_label = sqliteVdbeMakeLabel(v);
+      expr_end_label = sqlite3VdbeMakeLabel(v);
       if( pExpr->pLeft ){
-        sqliteExprCode(pParse, pExpr->pLeft);
+        sqlite3ExprCode(pParse, pExpr->pLeft);
       }
       for(i=0; i<nExpr; i=i+2){
-        sqliteExprCode(pParse, pExpr->pList->a[i].pExpr);
+        sqlite3ExprCode(pParse, pExpr->pList->a[i].pExpr);
         if( pExpr->pLeft ){
-          sqliteVdbeAddOp(v, OP_Dup, 1, 1);
-          jumpInst = sqliteVdbeAddOp(v, OP_Ne, 1, 0);
-          sqliteVdbeAddOp(v, OP_Pop, 1, 0);
+          sqlite3VdbeAddOp(v, OP_Dup, 1, 1);
+          jumpInst = sqlite3VdbeAddOp(v, OP_Ne, 1, 0);
+          sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
         }else{
-          jumpInst = sqliteVdbeAddOp(v, OP_IfNot, 1, 0);
+          jumpInst = sqlite3VdbeAddOp(v, OP_IfNot, 1, 0);
         }
-        sqliteExprCode(pParse, pExpr->pList->a[i+1].pExpr);
-        sqliteVdbeAddOp(v, OP_Goto, 0, expr_end_label);
-        addr = sqliteVdbeCurrentAddr(v);
-        sqliteVdbeChangeP2(v, jumpInst, addr);
+        sqlite3ExprCode(pParse, pExpr->pList->a[i+1].pExpr);
+        sqlite3VdbeAddOp(v, OP_Goto, 0, expr_end_label);
+        addr = sqlite3VdbeCurrentAddr(v);
+        sqlite3VdbeChangeP2(v, jumpInst, addr);
       }
       if( pExpr->pLeft ){
-        sqliteVdbeAddOp(v, OP_Pop, 1, 0);
+        sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
       }
       if( pExpr->pRight ){
-        sqliteExprCode(pParse, pExpr->pRight);
+        sqlite3ExprCode(pParse, pExpr->pRight);
       }else{
-        sqliteVdbeAddOp(v, OP_String, 0, 0);
+        sqlite3VdbeAddOp(v, OP_String, 0, 0);
       }
-      sqliteVdbeResolveLabel(v, expr_end_label);
+      sqlite3VdbeResolveLabel(v, expr_end_label);
       break;
     }
     case TK_RAISE: {
       if( !pParse->trigStack ){
-        sqliteErrorMsg(pParse,
+        sqlite3ErrorMsg(pParse,
                        "RAISE() may only be used within a trigger-program");
         pParse->nErr++;
 	return;
@@ -1243,12 +1243,12 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
       if( pExpr->iColumn == OE_Rollback ||
 	  pExpr->iColumn == OE_Abort ||
 	  pExpr->iColumn == OE_Fail ){
-	  sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
+	  sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
                            pExpr->token.z, pExpr->token.n);
-	  sqliteVdbeDequoteP3(v, -1);
+	  sqlite3VdbeDequoteP3(v, -1);
       } else {
 	  assert( pExpr->iColumn == OE_Ignore );
-	  sqliteVdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump,
+	  sqlite3VdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump,
                            "(IGNORE jump)", 0);
       }
     }
@@ -1264,7 +1264,7 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){
 **
 ** Return the number of elements pushed onto the stack.
 */
-int sqliteExprCodeExprList(
+int sqlite3ExprCodeExprList(
   Parse *pParse,     /* Parsing context */
   ExprList *pList,   /* The expression list to be coded */
   int includeTypes   /* TRUE to put datatypes on the stack too */
@@ -1273,13 +1273,13 @@ int sqliteExprCodeExprList(
   int i, n;
   Vdbe *v;
   if( pList==0 ) return 0;
-  v = sqliteGetVdbe(pParse);
+  v = sqlite3GetVdbe(pParse);
   n = pList->nExpr;
   for(pItem=pList->a, i=0; i<n; i++, pItem++){
-    sqliteExprCode(pParse, pItem->pExpr);
+    sqlite3ExprCode(pParse, pItem->pExpr);
     if( includeTypes ){
-      sqliteVdbeOp3(v, OP_String, 0, 0, 
-         sqliteExprType(pItem->pExpr)==SQLITE_SO_NUM ? "numeric" : "text",
+      sqlite3VdbeOp3(v, OP_String, 0, 0, 
+         sqlite3ExprType(pItem->pExpr)==SQLITE_SO_NUM ? "numeric" : "text",
          P3_STATIC);
     }
   }
@@ -1294,7 +1294,7 @@ int sqliteExprCodeExprList(
 ** If the expression evaluates to NULL (neither true nor false), then
 ** take the jump if the jumpIfNull flag is true.
 */
-void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
+void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
   Vdbe *v = pParse->pVdbe;
   int op = 0;
   if( v==0 || pExpr==0 ) return;
@@ -1311,19 +1311,19 @@ void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
   }
   switch( pExpr->op ){
     case TK_AND: {
-      int d2 = sqliteVdbeMakeLabel(v);
-      sqliteExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull);
-      sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
-      sqliteVdbeResolveLabel(v, d2);
+      int d2 = sqlite3VdbeMakeLabel(v);
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull);
+      sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3VdbeResolveLabel(v, d2);
       break;
     }
     case TK_OR: {
-      sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
-      sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
       break;
     }
     case TK_NOT: {
-      sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
       break;
     }
     case TK_LT:
@@ -1332,50 +1332,50 @@ void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
     case TK_GE:
     case TK_NE:
     case TK_EQ: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteExprCode(pParse, pExpr->pRight);
-      if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3ExprCode(pParse, pExpr->pRight);
+      if( pParse->db->file_format>=4 && sqlite3ExprType(pExpr)==SQLITE_SO_TEXT ){
         op += 6;  /* Convert numeric opcodes to text opcodes */
       }
-      sqliteVdbeAddOp(v, op, jumpIfNull, dest);
+      sqlite3VdbeAddOp(v, op, jumpIfNull, dest);
       break;
     }
     case TK_ISNULL:
     case TK_NOTNULL: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, op, 1, dest);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, op, 1, dest);
       break;
     }
     case TK_IN: {
       int addr;
-      sqliteExprCode(pParse, pExpr->pLeft);
-      addr = sqliteVdbeCurrentAddr(v);
-      sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3);
-      sqliteVdbeAddOp(v, OP_Pop, 1, 0);
-      sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      addr = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+3);
+      sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
+      sqlite3VdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4);
       if( pExpr->pSelect ){
-        sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, dest);
+        sqlite3VdbeAddOp(v, OP_Found, pExpr->iTable, dest);
       }else{
-        sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, dest);
+        sqlite3VdbeAddOp(v, OP_SetFound, pExpr->iTable, dest);
       }
       break;
     }
     case TK_BETWEEN: {
       int addr;
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, OP_Dup, 0, 0);
-      sqliteExprCode(pParse, pExpr->pList->a[0].pExpr);
-      addr = sqliteVdbeAddOp(v, OP_Lt, !jumpIfNull, 0);
-      sqliteExprCode(pParse, pExpr->pList->a[1].pExpr);
-      sqliteVdbeAddOp(v, OP_Le, jumpIfNull, dest);
-      sqliteVdbeAddOp(v, OP_Integer, 0, 0);
-      sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v));
-      sqliteVdbeAddOp(v, OP_Pop, 1, 0);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pList->a[0].pExpr);
+      addr = sqlite3VdbeAddOp(v, OP_Lt, !jumpIfNull, 0);
+      sqlite3ExprCode(pParse, pExpr->pList->a[1].pExpr);
+      sqlite3VdbeAddOp(v, OP_Le, jumpIfNull, dest);
+      sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
+      sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
+      sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
       break;
     }
     default: {
-      sqliteExprCode(pParse, pExpr);
-      sqliteVdbeAddOp(v, OP_If, jumpIfNull, dest);
+      sqlite3ExprCode(pParse, pExpr);
+      sqlite3VdbeAddOp(v, OP_If, jumpIfNull, dest);
       break;
     }
   }
@@ -1389,7 +1389,7 @@ void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
 ** If the expression evaluates to NULL (neither true nor false) then
 ** jump if jumpIfNull is true or fall through if jumpIfNull is false.
 */
-void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
+void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
   Vdbe *v = pParse->pVdbe;
   int op = 0;
   if( v==0 || pExpr==0 ) return;
@@ -1406,19 +1406,19 @@ void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
   }
   switch( pExpr->op ){
     case TK_AND: {
-      sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
-      sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
       break;
     }
     case TK_OR: {
-      int d2 = sqliteVdbeMakeLabel(v);
-      sqliteExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull);
-      sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
-      sqliteVdbeResolveLabel(v, d2);
+      int d2 = sqlite3VdbeMakeLabel(v);
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull);
+      sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3VdbeResolveLabel(v, d2);
       break;
     }
     case TK_NOT: {
-      sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
       break;
     }
     case TK_LT:
@@ -1427,7 +1427,7 @@ void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
     case TK_GE:
     case TK_NE:
     case TK_EQ: {
-      if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){
+      if( pParse->db->file_format>=4 && sqlite3ExprType(pExpr)==SQLITE_SO_TEXT ){
         /* Convert numeric comparison opcodes into text comparison opcodes.
         ** This step depends on the fact that the text comparision opcodes are
         ** always 6 greater than their corresponding numeric comparison
@@ -1436,47 +1436,47 @@ void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
         assert( OP_Eq+6 == OP_StrEq );
         op += 6;
       }
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteExprCode(pParse, pExpr->pRight);
-      sqliteVdbeAddOp(v, op, jumpIfNull, dest);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3ExprCode(pParse, pExpr->pRight);
+      sqlite3VdbeAddOp(v, op, jumpIfNull, dest);
       break;
     }
     case TK_ISNULL:
     case TK_NOTNULL: {
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, op, 1, dest);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, op, 1, dest);
       break;
     }
     case TK_IN: {
       int addr;
-      sqliteExprCode(pParse, pExpr->pLeft);
-      addr = sqliteVdbeCurrentAddr(v);
-      sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3);
-      sqliteVdbeAddOp(v, OP_Pop, 1, 0);
-      sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      addr = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+3);
+      sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
+      sqlite3VdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4);
       if( pExpr->pSelect ){
-        sqliteVdbeAddOp(v, OP_NotFound, pExpr->iTable, dest);
+        sqlite3VdbeAddOp(v, OP_NotFound, pExpr->iTable, dest);
       }else{
-        sqliteVdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest);
+        sqlite3VdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest);
       }
       break;
     }
     case TK_BETWEEN: {
       int addr;
-      sqliteExprCode(pParse, pExpr->pLeft);
-      sqliteVdbeAddOp(v, OP_Dup, 0, 0);
-      sqliteExprCode(pParse, pExpr->pList->a[0].pExpr);
-      addr = sqliteVdbeCurrentAddr(v);
-      sqliteVdbeAddOp(v, OP_Ge, !jumpIfNull, addr+3);
-      sqliteVdbeAddOp(v, OP_Pop, 1, 0);
-      sqliteVdbeAddOp(v, OP_Goto, 0, dest);
-      sqliteExprCode(pParse, pExpr->pList->a[1].pExpr);
-      sqliteVdbeAddOp(v, OP_Gt, jumpIfNull, dest);
+      sqlite3ExprCode(pParse, pExpr->pLeft);
+      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);
+      sqlite3ExprCode(pParse, pExpr->pList->a[0].pExpr);
+      addr = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp(v, OP_Ge, !jumpIfNull, addr+3);
+      sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
+      sqlite3VdbeAddOp(v, OP_Goto, 0, dest);
+      sqlite3ExprCode(pParse, pExpr->pList->a[1].pExpr);
+      sqlite3VdbeAddOp(v, OP_Gt, jumpIfNull, dest);
       break;
     }
     default: {
-      sqliteExprCode(pParse, pExpr);
-      sqliteVdbeAddOp(v, OP_IfNot, jumpIfNull, dest);
+      sqlite3ExprCode(pParse, pExpr);
+      sqlite3VdbeAddOp(v, OP_IfNot, jumpIfNull, dest);
       break;
     }
   }
@@ -1486,7 +1486,7 @@ void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
 ** Do a deep comparison of two expression trees.  Return TRUE (non-zero)
 ** if they are identical and return FALSE if they differ in any way.
 */
-int sqliteExprCompare(Expr *pA, Expr *pB){
+int sqlite3ExprCompare(Expr *pA, Expr *pB){
   int i;
   if( pA==0 ){
     return pB==0;
@@ -1494,13 +1494,13 @@ int sqliteExprCompare(Expr *pA, Expr *pB){
     return 0;
   }
   if( pA->op!=pB->op ) return 0;
-  if( !sqliteExprCompare(pA->pLeft, pB->pLeft) ) return 0;
-  if( !sqliteExprCompare(pA->pRight, pB->pRight) ) return 0;
+  if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
+  if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
   if( pA->pList ){
     if( pB->pList==0 ) return 0;
     if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
     for(i=0; i<pA->pList->nExpr; i++){
-      if( !sqliteExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
+      if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){
         return 0;
       }
     }
@@ -1512,7 +1512,7 @@ int sqliteExprCompare(Expr *pA, Expr *pB){
   if( pA->token.z ){
     if( pB->token.z==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;
+    if( sqlite3StrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0;
   }
   return 1;
 }
@@ -1539,12 +1539,12 @@ static int appendAggInfo(Parse *pParse){
 ** Make additional entries to the pParse->aAgg[] array as necessary.
 **
 ** This routine should only be called after the expression has been
-** analyzed by sqliteExprResolveIds() and sqliteExprCheck().
+** analyzed by sqlite3ExprResolveIds() and sqlite3ExprCheck().
 **
 ** If errors are seen, leave an error message in zErrMsg and return
 ** the number of errors.
 */
-int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
+int sqlite3ExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
   int i;
   AggExpr *aAgg;
   int nErr = 0;
@@ -1573,7 +1573,7 @@ int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
       aAgg = pParse->aAgg;
       for(i=0; i<pParse->nAgg; i++){
         if( !aAgg[i].isAgg ) continue;
-        if( sqliteExprCompare(aAgg[i].pExpr, pExpr) ){
+        if( sqlite3ExprCompare(aAgg[i].pExpr, pExpr) ){
           break;
         }
       }
@@ -1582,7 +1582,7 @@ int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
         if( i<0 ) return 1;
         pParse->aAgg[i].isAgg = 1;
         pParse->aAgg[i].pExpr = pExpr;
-        pParse->aAgg[i].pFunc = sqliteFindFunction(pParse->db,
+        pParse->aAgg[i].pFunc = sqlite3FindFunction(pParse->db,
              pExpr->token.z, pExpr->token.n,
              pExpr->pList ? pExpr->pList->nExpr : 0, 0);
       }
@@ -1591,16 +1591,16 @@ int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
     }
     default: {
       if( pExpr->pLeft ){
-        nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pLeft);
+        nErr = sqlite3ExprAnalyzeAggregates(pParse, pExpr->pLeft);
       }
       if( nErr==0 && pExpr->pRight ){
-        nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pRight);
+        nErr = sqlite3ExprAnalyzeAggregates(pParse, pExpr->pRight);
       }
       if( nErr==0 && pExpr->pList ){
         int n = pExpr->pList->nExpr;
         int i;
         for(i=0; nErr==0 && i<n; i++){
-          nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pList->a[i].pExpr);
+          nErr = sqlite3ExprAnalyzeAggregates(pParse, pExpr->pList->a[i].pExpr);
         }
       }
       break;
@@ -1624,7 +1624,7 @@ int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){
 ** function found is returned.  A function is valid if either xFunc
 ** or xStep is non-zero.
 */
-FuncDef *sqliteFindFunction(
+FuncDef *sqlite3FindFunction(
   sqlite *db,        /* An open database */
   const char *zName, /* Name of the function.  Not null-terminated */
   int nName,         /* Number of characters in the name */
@@ -1632,7 +1632,7 @@ FuncDef *sqliteFindFunction(
   int createFlag     /* Create new entry if true and does not otherwise exist */
 ){
   FuncDef *pFirst, *p, *pMaybe;
-  pFirst = p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, nName);
+  pFirst = p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, nName);
   if( p && !createFlag && nArg<0 ){
     while( p && p->xFunc==0 && p->xStep==0 ){ p = p->pNext; }
     return p;
@@ -1653,7 +1653,10 @@ FuncDef *sqliteFindFunction(
     p->nArg = nArg;
     p->pNext = pFirst;
     p->dataType = pFirst ? pFirst->dataType : SQLITE_NUMERIC;
-    sqliteHashInsert(&db->aFunc, zName, nName, (void*)p);
+    sqlite3HashInsert(&db->aFunc, zName, nName, (void*)p);
   }
   return p;
 }
+
+
+