Change the names of external symbols from sqlite_XXX to sqlite3_XXX. (CVS 1338)

FossilOrigin-Name: 2242423e31a5e81e89ffcc99e62307c5cc0120d5

19 files changed, 434 insertions, 434 deletions

diff --git a/src/md5.c b/src/md5.c
index 0c4ead755..f716dd8dd 100644
--- a/src/md5.c
+++ b/src/md5.c
@@ -360,9 +360,9 @@ static void md5step(sqlite_func *context, int argc, const char **argv){
   MD5Context *p;
   int i;
   if( argc<1 ) return;
-  p = sqlite_aggregate_context(context, sizeof(*p));
+  p = sqlite3_aggregate_context(context, sizeof(*p));
   if( p==0 ) return;
-  if( sqlite_aggregate_count(context)==1 ){
+  if( sqlite3_aggregate_count(context)==1 ){
     MD5Init(p);
   }
   for(i=0; i<argc; i++){
@@ -375,13 +375,13 @@ static void md5finalize(sqlite_func *context){
   MD5Context *p;
   unsigned char digest[16];
   char zBuf[33];
-  p = sqlite_aggregate_context(context, sizeof(*p));
+  p = sqlite3_aggregate_context(context, sizeof(*p));
   MD5Final(digest,p);
   DigestToBase16(digest, zBuf);
-  sqlite_set_result_string(context, zBuf, strlen(zBuf));
+  sqlite3_set_result_string(context, zBuf, strlen(zBuf));
 }
 void Md5_Register(sqlite *db){
-  sqlite_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0);
+  sqlite3_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0);
 }
 
 
diff --git a/src/os.c b/src/os.c
index 697217ff3..157b4cff9 100644
--- a/src/os.c
+++ b/src/os.c
@@ -362,12 +362,12 @@ int findLockInfo(
 ** is used for testing the I/O recovery logic.
 */
 #ifdef SQLITE_TEST
-int sqlite_io_error_pending = 0;
+int sqlite3_io_error_pending = 0;
 #define SimulateIOError(A)  \
-   if( sqlite_io_error_pending ) \
-     if( sqlite_io_error_pending-- == 1 ){ local_ioerr(); return A; }
+   if( sqlite3_io_error_pending ) \
+     if( sqlite3_io_error_pending-- == 1 ){ local_ioerr(); return A; }
 static void local_ioerr(){
-  sqlite_io_error_pending = 0;  /* Really just a place to set a breakpoint */
+  sqlite3_io_error_pending = 0;  /* Really just a place to set a breakpoint */
 }
 #else
 #define SimulateIOError(A)
@@ -377,8 +377,8 @@ static void local_ioerr(){
 ** When testing, keep a count of the number of open files.
 */
 #ifdef SQLITE_TEST
-int sqlite_open_file_count = 0;
-#define OpenCounter(X)  sqlite_open_file_count+=(X)
+int sqlite3_open_file_count = 0;
+#define OpenCounter(X)  sqlite3_open_file_count+=(X)
 #else
 #define OpenCounter(X)
 #endif
@@ -1785,7 +1785,7 @@ char *sqlite3OsFullPathname(const char *zRelative){
 ** returned from sqlite3OsCurrentTime().  This is used for testing.
 */
 #ifdef SQLITE_TEST
-int sqlite_current_time = 0;
+int sqlite3_current_time = 0;
 #endif
 
 /*
@@ -1810,8 +1810,8 @@ int sqlite3OsCurrentTime(double *prNow){
   *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
 #endif
 #ifdef SQLITE_TEST
-  if( sqlite_current_time ){
-    *prNow = sqlite_current_time/86400.0 + 2440587.5;
+  if( sqlite3_current_time ){
+    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
   }
 #endif
   return 0;
diff --git a/src/pager.c b/src/pager.c
index f8c7ba06f..e098aeafe 100644
--- a/src/pager.c
+++ b/src/pager.c
@@ -18,7 +18,7 @@
 ** file simultaneously, or one process from reading the database while
 ** another is writing.
 **
-** @(#) $Id: pager.c,v 1.105 2004/05/08 20:07:40 drh Exp $
+** @(#) $Id: pager.c,v 1.106 2004/05/10 10:34:49 danielk1977 Exp $
 */
 #include "os.h"         /* Must be first to enable large file support */
 #include "sqliteInt.h"
@@ -932,7 +932,7 @@ int sqlite3pager_open(
   char zTemp[SQLITE_TEMPNAME_SIZE];
 
   *ppPager = 0;
-  if( sqlite_malloc_failed ){
+  if( sqlite3_malloc_failed ){
     return SQLITE_NOMEM;
   }
   if( zFilename && zFilename[0] ){
@@ -945,7 +945,7 @@ int sqlite3pager_open(
     zFullPathname = sqlite3OsFullPathname(zFilename);
     tempFile = 1;
   }
-  if( sqlite_malloc_failed ){
+  if( sqlite3_malloc_failed ){
     return SQLITE_NOMEM;
   }
   if( rc!=SQLITE_OK ){
diff --git a/src/printf.c b/src/printf.c
index 6aee66d21..bce1770b7 100644
--- a/src/printf.c
+++ b/src/printf.c
@@ -753,7 +753,7 @@ char *sqlite3MPrintf(const char *zFormat, ...){
 ** Print into memory obtained from malloc().  Do not use the internal
 ** %-conversion extensions.  This routine is for use by external users.
 */
-char *sqlite_mprintf(const char *zFormat, ...){
+char *sqlite3_mprintf(const char *zFormat, ...){
   va_list ap;
   char *z;
   char zBuf[200];
@@ -765,21 +765,21 @@ char *sqlite_mprintf(const char *zFormat, ...){
   return z;
 }
 
-/* This is the varargs version of sqlite_mprintf.  
+/* This is the varargs version of sqlite3_mprintf.  
 */
-char *sqlite_vmprintf(const char *zFormat, va_list ap){
+char *sqlite3_vmprintf(const char *zFormat, va_list ap){
   char zBuf[200];
   return base_vprintf((void*(*)(void*,int))realloc, 0,
                       zBuf, sizeof(zBuf), zFormat, ap);
 }
 
 /*
-** sqlite_snprintf() works like snprintf() except that it ignores the
+** sqlite3_snprintf() works like snprintf() except that it ignores the
 ** current locale settings.  This is important for SQLite because we
 ** are not able to use a "," as the decimal point in place of "." as
 ** specified by some locales.
 */
-char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){
+char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
   char *z;
   va_list ap;
 
@@ -791,13 +791,13 @@ char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){
 
 /*
 ** The following four routines implement the varargs versions of the
-** sqlite_exec() and sqlite_get_table() interfaces.  See the sqlite.h
+** sqlite3_exec() and sqlite3_get_table() interfaces.  See the sqlite.h
 ** header files for a more detailed description of how these interfaces
 ** work.
 **
 ** These routines are all just simple wrappers.
 */
-int sqlite_exec_printf(
+int sqlite3_exec_printf(
   sqlite *db,                   /* An open database */
   const char *sqlFormat,        /* printf-style format string for the SQL */
   sqlite_callback xCallback,    /* Callback function */
@@ -809,11 +809,11 @@ int sqlite_exec_printf(
   int rc;
 
   va_start(ap, errmsg);
-  rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap);
+  rc = sqlite3_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap);
   va_end(ap);
   return rc;
 }
-int sqlite_exec_vprintf(
+int sqlite3_exec_vprintf(
   sqlite *db,                   /* An open database */
   const char *sqlFormat,        /* printf-style format string for the SQL */
   sqlite_callback xCallback,    /* Callback function */
@@ -824,12 +824,12 @@ int sqlite_exec_vprintf(
   char *zSql;
   int rc;
 
-  zSql = sqlite_vmprintf(sqlFormat, ap);
-  rc = sqlite_exec(db, zSql, xCallback, pArg, errmsg);
+  zSql = sqlite3_vmprintf(sqlFormat, ap);
+  rc = sqlite3_exec(db, zSql, xCallback, pArg, errmsg);
   free(zSql);
   return rc;
 }
-int sqlite_get_table_printf(
+int sqlite3_get_table_printf(
   sqlite *db,            /* An open database */
   const char *sqlFormat, /* printf-style format string for the SQL */
   char ***resultp,       /* Result written to a char *[]  that this points to */
@@ -842,11 +842,11 @@ int sqlite_get_table_printf(
   int rc;
 
   va_start(ap, errmsg);
-  rc = sqlite_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap);
+  rc = sqlite3_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap);
   va_end(ap);
   return rc;
 }
-int sqlite_get_table_vprintf(
+int sqlite3_get_table_vprintf(
   sqlite *db,            /* An open database */
   const char *sqlFormat, /* printf-style format string for the SQL */
   char ***resultp,       /* Result written to a char *[]  that this points to */
@@ -858,8 +858,8 @@ int sqlite_get_table_vprintf(
   char *zSql;
   int rc;
 
-  zSql = sqlite_vmprintf(sqlFormat, ap);
-  rc = sqlite_get_table(db, zSql, resultp, nrow, ncolumn, errmsg);
+  zSql = sqlite3_vmprintf(sqlFormat, ap);
+  rc = sqlite3_get_table(db, zSql, resultp, nrow, ncolumn, errmsg);
   free(zSql);
   return rc;
 }
diff --git a/src/select.c b/src/select.c
index bd3d7ae51..e913d5dee 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.162 2004/05/08 08:23:32 danielk1977 Exp $
+** $Id: select.c,v 1.163 2004/05/10 10:34:49 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 
@@ -692,7 +692,7 @@ static void generateColumnNames(
   int fullNames, shortNames;
 
   assert( v!=0 );
-  if( pParse->colNamesSet || v==0 || sqlite_malloc_failed ) return;
+  if( pParse->colNamesSet || v==0 || sqlite3_malloc_failed ) return;
   pParse->colNamesSet = 1;
   fullNames = (db->flags & SQLITE_FullColNames)!=0;
   shortNames = (db->flags & SQLITE_ShortColNames)!=0;
@@ -2007,7 +2007,7 @@ int sqlite3Select(
   int distinct;          /* Table to use for the distinct set */
   int rc = 1;            /* Value to return from this function */
 
-  if( sqlite_malloc_failed || pParse->nErr || p==0 ) return 1;
+  if( sqlite3_malloc_failed || pParse->nErr || p==0 ) return 1;
   if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
 
   /* If there is are a sequence of queries, do the earlier ones first.
diff --git a/src/shell.c b/src/shell.c
index 08ba508df..648a9bbec 100644
--- a/src/shell.c
+++ b/src/shell.c
@@ -12,7 +12,7 @@
 ** This file contains code to implement the "sqlite" command line
 ** utility for accessing SQLite databases.
 **
-** $Id: shell.c,v 1.94 2004/05/08 08:23:32 danielk1977 Exp $
+** $Id: shell.c,v 1.95 2004/05/10 10:34:52 danielk1977 Exp $
 */
 #include <stdlib.h>
 #include <string.h>
@@ -271,7 +271,7 @@ static void output_html_string(FILE *out, const char *z){
 */
 static void interrupt_handler(int NotUsed){
   seenInterrupt = 1;
-  if( db ) sqlite_interrupt(db);
+  if( db ) sqlite3_interrupt(db);
 }
 
 /*
@@ -460,7 +460,7 @@ static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
     d2.mode = MODE_Insert;
     d2.zDestTable = 0;
     set_table_name(&d2, azArg[0]);
-    sqlite_exec_printf(p->db,
+    sqlite3_exec_printf(p->db,
        "SELECT * FROM '%q'",
        callback, &d2, 0, azArg[0]
     );
@@ -513,9 +513,9 @@ static void open_db(struct callback_data *p){
     char *zErrMsg = 0;
 #ifdef SQLITE_HAS_CODEC
     int n = p->zKey ? strlen(p->zKey) : 0;
-    db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg);
+    db = p->db = sqlite3_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg);
 #else
-    db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg);
+    db = p->db = sqlite3_open(p->zDbFilename, 0, &zErrMsg);
 #endif
     if( p->db==0 ){
       if( zErrMsg ){
@@ -576,10 +576,10 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     data.colWidth[0] = 3;
     data.colWidth[1] = 15;
     data.colWidth[2] = 58;
-    sqlite_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
+    sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
     if( zErrMsg ){
       fprintf(stderr,"Error: %s\n", zErrMsg);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }
   }else
 
@@ -588,7 +588,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     open_db(p);
     fprintf(p->out, "BEGIN TRANSACTION;\n");
     if( nArg==1 ){
-      sqlite_exec(p->db,
+      sqlite3_exec(p->db,
         "SELECT name, type, sql FROM sqlite_master "
         "WHERE type!='meta' AND sql NOT NULL "
         "ORDER BY substr(type,2,1), name",
@@ -597,7 +597,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     }else{
       int i;
       for(i=1; i<nArg && zErrMsg==0; i++){
-        sqlite_exec_printf(p->db,
+        sqlite3_exec_printf(p->db,
           "SELECT name, type, sql FROM sqlite_master "
           "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOT NULL "
           "ORDER BY substr(type,2,1), name",
@@ -607,7 +607,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     }
     if( zErrMsg ){
       fprintf(stderr,"Error: %s\n", zErrMsg);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }else{
       fprintf(p->out, "COMMIT;\n");
     }
@@ -702,7 +702,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     memcpy(&data, p, sizeof(data));
     data.showHeader = 0;
     data.mode = MODE_List;
-    sqlite_exec_printf(p->db,
+    sqlite3_exec_printf(p->db,
       "SELECT name FROM sqlite_master "
       "WHERE type='index' AND tbl_name LIKE '%q' "
       "UNION ALL "
@@ -713,7 +713,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     );
     if( zErrMsg ){
       fprintf(stderr,"Error: %s\n", zErrMsg);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }
   }else
 
@@ -797,8 +797,8 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     }else if( strcmp(azArg[2], azArg[3]) ){
       fprintf(stderr,"2nd copy of new key does not match the 1st\n");
     }else{
-      sqlite_freemem(p->zKey);
-      p->zKey = sqlite_mprintf("%s", azArg[2]);
+      sqlite3_freemem(p->zKey);
+      p->zKey = sqlite3_mprintf("%s", azArg[2]);
       sqlite_rekey(p->db, p->zKey, strlen(p->zKey));
     }
   }else
@@ -840,7 +840,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
         new_colv[1] = 0;
         callback(&data, 1, new_argv, new_colv);
       }else{
-        sqlite_exec_printf(p->db,
+        sqlite3_exec_printf(p->db,
           "SELECT sql FROM "
           "  (SELECT * FROM sqlite_master UNION ALL"
           "   SELECT * FROM sqlite_temp_master) "
@@ -849,7 +849,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
           callback, &data, &zErrMsg, azArg[1]);
       }
     }else{
-      sqlite_exec(p->db,
+      sqlite3_exec(p->db,
          "SELECT sql FROM "
          "  (SELECT * FROM sqlite_master UNION ALL"
          "   SELECT * FROM sqlite_temp_master) "
@@ -860,7 +860,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     }
     if( zErrMsg ){
       fprintf(stderr,"Error: %s\n", zErrMsg);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }
   }else
 
@@ -891,7 +891,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     char *zErrMsg;
     open_db(p);
     if( nArg==1 ){
-      rc = sqlite_get_table(p->db,
+      rc = sqlite3_get_table(p->db,
         "SELECT name FROM sqlite_master "
         "WHERE type IN ('table','view') "
         "UNION ALL "
@@ -901,7 +901,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
         &azResult, &nRow, 0, &zErrMsg
       );
     }else{
-      rc = sqlite_get_table_printf(p->db,
+      rc = sqlite3_get_table_printf(p->db,
         "SELECT name FROM sqlite_master "
         "WHERE type IN ('table','view') AND name LIKE '%%%q%%' "
         "UNION ALL "
@@ -913,7 +913,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){
     }
     if( zErrMsg ){
       fprintf(stderr,"Error: %s\n", zErrMsg);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }
     if( rc==SQLITE_OK ){
       int len, maxlen = 0;
@@ -935,12 +935,12 @@ static int do_meta_command(char *zLine, struct callback_data *p){
         printf("\n");
       }
     }
-    sqlite_free_table(azResult);
+    sqlite3_free_table(azResult);
   }else
 
   if( c=='t' && n>1 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){
     open_db(p);
-    sqlite_busy_timeout(p->db, atoi(azArg[1]));
+    sqlite3_busy_timeout(p->db, atoi(azArg[1]));
   }else
 
   if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
@@ -1055,18 +1055,18 @@ static void process_input(struct callback_data *p, FILE *in){
       nSql += len;
     }
     free(zLine);
-    if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite_complete(zSql) ){
+    if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite3_complete(zSql) ){
       p->cnt = 0;
       open_db(p);
-      rc = sqlite_exec(p->db, zSql, callback, p, &zErrMsg);
+      rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg);
       if( rc || zErrMsg ){
         if( in!=0 && !p->echoOn ) printf("%s\n",zSql);
         if( zErrMsg!=0 ){
           printf("SQL error: %s\n", zErrMsg);
-          sqlite_freemem(zErrMsg);
+          sqlite3_freemem(zErrMsg);
           zErrMsg = 0;
         }else{
-          printf("SQL error: %s\n", sqlite_error_string(rc));
+          printf("SQL error: %s\n", sqlite3_error_string(rc));
         }
       }
       free(zSql);
@@ -1239,7 +1239,7 @@ int main(int argc, char **argv){
       zInitFile = argv[i];
     }else if( strcmp(argv[i],"-key")==0 ){
       i++;
-      data.zKey = sqlite_mprintf("%s",argv[i]);
+      data.zKey = sqlite3_mprintf("%s",argv[i]);
     }
   }
   if( i<argc ){
@@ -1297,7 +1297,7 @@ int main(int argc, char **argv){
     }else if( strcmp(z,"-echo")==0 ){
       data.echoOn = 1;
     }else if( strcmp(z,"-version")==0 ){
-      printf("%s\n", sqlite_version);
+      printf("%s\n", sqlite3_version);
       return 1;
     }else if( strcmp(z,"-help")==0 ){
       usage(1);
@@ -1317,7 +1317,7 @@ int main(int argc, char **argv){
     }else{
       int rc;
       open_db(&data);
-      rc = sqlite_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
+      rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
       if( rc!=0 && zErrMsg!=0 ){
         fprintf(stderr,"SQL error: %s\n", zErrMsg);
         exit(1);
@@ -1332,7 +1332,7 @@ int main(int argc, char **argv){
       printf(
         "SQLite version %s\n"
         "Enter \".help\" for instructions\n",
-        sqlite_version
+        sqlite3_version
       );
       zHome = find_home_dir();
       if( zHome && (zHistory = malloc(strlen(zHome)+20))!=0 ){
@@ -1349,7 +1349,7 @@ int main(int argc, char **argv){
     }
   }
   set_table_name(&data, 0);
-  if( db ) sqlite_close(db);
+  if( db ) sqlite3_close(db);
   return 0;
 }
 
diff --git a/src/sqlite.h.in b/src/sqlite.h.in
index 3b210ebe0..272735d83 100644
--- a/src/sqlite.h.in
+++ b/src/sqlite.h.in
@@ -12,7 +12,7 @@
 ** This header file defines the interface that the SQLite library
 ** presents to client programs.
 **
-** @(#) $Id: sqlite.h.in,v 1.61 2004/05/08 08:23:33 danielk1977 Exp $
+** @(#) $Id: sqlite.h.in,v 1.62 2004/05/10 10:34:52 danielk1977 Exp $
 */
 #ifndef _SQLITE_H_
 #define _SQLITE_H_
@@ -35,7 +35,7 @@ extern "C" {
 ** can check to make sure that the lib*.a file and the *.h file are from
 ** the same version.
 */
-extern const char sqlite_version[];
+extern const char sqlite3_version[];
 
 /*
 ** The SQLITE_UTF8 macro is defined if the library expects to see
@@ -50,7 +50,7 @@ extern const char sqlite_version[];
 ** see.  The character encoding makes a difference for the LIKE and GLOB
 ** operators and for the LENGTH() and SUBSTR() functions.
 */
-extern const char sqlite_encoding[];
+extern const char sqlite3_encoding[];
 
 /*
 ** Each open sqlite database is represented by an instance of the
@@ -75,15 +75,15 @@ typedef struct sqlite sqlite;
 ** ability to open a database readonly.  The mode parameters is
 ** provided in anticipation of that enhancement.
 */
-sqlite *sqlite_open(const char *filename, int mode, char **errmsg);
+sqlite *sqlite3_open(const char *filename, int mode, char **errmsg);
 
 /*
 ** A function to close the database.
 **
 ** Call this function with a pointer to a structure that was previously
-** returned from sqlite_open() and the corresponding database will by closed.
+** returned from sqlite3_open() and the corresponding database will by closed.
 */
-void sqlite_close(sqlite *);
+void sqlite3_close(sqlite *);
 
 /*
 ** The type for a callback function.
@@ -98,7 +98,7 @@ typedef int (*sqlite_callback)(void*,int,char**, char**);
 ** invoked once for each row of the query result.  This callback
 ** should normally return 0.  If the callback returns a non-zero
 ** value then the query is aborted, all subsequent SQL statements
-** are skipped and the sqlite_exec() function returns the SQLITE_ABORT.
+** are skipped and the sqlite3_exec() function returns the SQLITE_ABORT.
 **
 ** The 4th parameter is an arbitrary pointer that is passed
 ** to the callback function as its first parameter.
@@ -118,7 +118,7 @@ typedef int (*sqlite_callback)(void*,int,char**, char**);
 ** message is written into memory obtained from malloc() and
 ** *errmsg is made to point to that message.  The calling function
 ** is responsible for freeing the memory that holds the error
-** message.   Use sqlite_freemem() for this.  If errmsg==NULL,
+** message.   Use sqlite3_freemem() for this.  If errmsg==NULL,
 ** then no error message is ever written.
 **
 ** The return value is is SQLITE_OK if there are no errors and
@@ -127,10 +127,10 @@ typedef int (*sqlite_callback)(void*,int,char**, char**);
 **
 ** If the query could not be executed because a database file is
 ** locked or busy, then this function returns SQLITE_BUSY.  (This
-** behavior can be modified somewhat using the sqlite_busy_handler()
-** and sqlite_busy_timeout() functions below.)
+** behavior can be modified somewhat using the sqlite3_busy_handler()
+** and sqlite3_busy_timeout() functions below.)
 */
-int sqlite_exec(
+int sqlite3_exec(
   sqlite*,                      /* An open database */
   const char *sql,              /* SQL to be executed */
   sqlite_callback,              /* Callback function */
@@ -139,7 +139,7 @@ int sqlite_exec(
 );
 
 /*
-** Return values for sqlite_exec() and sqlite_step()
+** Return values for sqlite3_exec() and sqlite3_step()
 */
 #define SQLITE_OK           0   /* Successful result */
 #define SQLITE_ERROR        1   /* SQL error or missing database */
@@ -150,7 +150,7 @@ int sqlite_exec(
 #define SQLITE_LOCKED       6   /* A table in the database is locked */
 #define SQLITE_NOMEM        7   /* A malloc() failed */
 #define SQLITE_READONLY     8   /* Attempt to write a readonly database */
-#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite_interrupt() */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt() */
 #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
 #define SQLITE_CORRUPT     11   /* The database disk image is malformed */
 #define SQLITE_NOTFOUND    12   /* (Internal Only) Table or record not found */
@@ -166,10 +166,10 @@ int sqlite_exec(
 #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
 #define SQLITE_AUTH        23   /* Authorization denied */
 #define SQLITE_FORMAT      24   /* Auxiliary database format error */
-#define SQLITE_RANGE       25   /* 2nd parameter to sqlite_bind out of range */
+#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
 #define SQLITE_NOTADB      26   /* File opened that is not a database file */
-#define SQLITE_ROW         100  /* sqlite_step() has another row ready */
-#define SQLITE_DONE        101  /* sqlite_step() has finished executing */
+#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
 
 /*
 ** Each entry in an SQLite table has a unique integer key.  (The key is
@@ -180,17 +180,17 @@ int sqlite_exec(
 **
 ** This function is similar to the mysql_insert_id() function from MySQL.
 */
-int sqlite_last_insert_rowid(sqlite*);
+int sqlite3_last_insert_rowid(sqlite*);
 
 /*
 ** This function returns the number of database rows that were changed
-** (or inserted or deleted) by the most recent called sqlite_exec().
+** (or inserted or deleted) by the most recent called sqlite3_exec().
 **
 ** All changes are counted, even if they were later undone by a
 ** ROLLBACK or ABORT.  Except, changes associated with creating and
 ** dropping tables are not counted.
 **
-** If a callback invokes sqlite_exec() recursively, then the changes
+** If a callback invokes sqlite3_exec() recursively, then the changes
 ** in the inner, recursive call are counted together with the changes
 ** in the outer call.
 **
@@ -202,11 +202,11 @@ int sqlite_last_insert_rowid(sqlite*);
 ** table. To get an accurate count of the number of rows deleted, use
 ** "DELETE FROM table WHERE 1" instead.
 */
-int sqlite_changes(sqlite*);
+int sqlite3_changes(sqlite*);
 
 /*
 ** This function returns the number of database rows that were changed
-** by the last INSERT, UPDATE, or DELETE statment executed by sqlite_exec(),
+** by the last INSERT, UPDATE, or DELETE statment executed by sqlite3_exec(),
 ** or by the last VM to run to completion. The change count is not updated
 ** by SQL statements other than INSERT, UPDATE or DELETE.
 **
@@ -214,7 +214,7 @@ int sqlite_changes(sqlite*);
 ** ABORT. Changes associated with trigger programs that execute as a
 ** result of the INSERT, UPDATE, or DELETE statement are not counted.
 **
-** If a callback invokes sqlite_exec() recursively, then the changes
+** If a callback invokes sqlite3_exec() recursively, then the changes
 ** in the inner, recursive call are counted together with the changes
 ** in the outer call.
 **
@@ -228,14 +228,14 @@ int sqlite_changes(sqlite*);
 **
 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
 */
-int sqlite_last_statement_changes(sqlite*);
+int sqlite3_last_statement_changes(sqlite*);
 
 /* If the parameter to this routine is one of the return value constants
 ** defined above, then this routine returns a constant text string which
 ** descripts (in English) the meaning of the return value.
 */
-const char *sqlite_error_string(int);
-#define sqliteErrStr sqlite_error_string  /* Legacy. Do not use in new code. */
+const char *sqlite3_error_string(int);
+#define sqliteErrStr sqlite3_error_string  /* Legacy. Do not use in new code. */
 
 /* This function causes any pending database operation to abort and
 ** return at its earliest opportunity.  This routine is typically
@@ -243,7 +243,7 @@ const char *sqlite_error_string(int);
 ** or Ctrl-C where the user wants a long query operation to halt
 ** immediately.
 */
-void sqlite_interrupt(sqlite*);
+void sqlite3_interrupt(sqlite*);
 
 
 /* This function returns true if the given input string comprises
@@ -253,19 +253,19 @@ void sqlite_interrupt(sqlite*);
 ** and comments is a semicolon, then return true.  otherwise return
 ** false.
 */
-int sqlite_complete(const char *sql);
+int sqlite3_complete(const char *sql);
 
 /*
 ** This routine identifies a callback function that is invoked
 ** whenever an attempt is made to open a database table that is
 ** currently locked by another process or thread.  If the busy callback
-** is NULL, then sqlite_exec() returns SQLITE_BUSY immediately if
+** is NULL, then sqlite3_exec() returns SQLITE_BUSY immediately if
 ** it finds a locked table.  If the busy callback is not NULL, then
-** sqlite_exec() invokes the callback with three arguments.  The
+** sqlite3_exec() invokes the callback with three arguments.  The
 ** second argument is the name of the locked table and the third
 ** argument is the number of times the table has been busy.  If the
-** busy callback returns 0, then sqlite_exec() immediately returns
-** SQLITE_BUSY.  If the callback returns non-zero, then sqlite_exec()
+** busy callback returns 0, then sqlite3_exec() immediately returns
+** SQLITE_BUSY.  If the callback returns non-zero, then sqlite3_exec()
 ** tries to open the table again and the cycle repeats.
 **
 ** The default busy callback is NULL.
@@ -277,22 +277,22 @@ int sqlite_complete(const char *sql);
 ** data structures out from under the executing query and will 
 ** probably result in a coredump.
 */
-void sqlite_busy_handler(sqlite*, int(*)(void*,const char*,int), void*);
+void sqlite3_busy_handler(sqlite*, int(*)(void*,const char*,int), void*);
 
 /*
 ** This routine sets a busy handler that sleeps for a while when a
 ** table is locked.  The handler will sleep multiple times until 
 ** at least "ms" milleseconds of sleeping have been done.  After
 ** "ms" milleseconds of sleeping, the handler returns 0 which
-** causes sqlite_exec() to return SQLITE_BUSY.
+** causes sqlite3_exec() to return SQLITE_BUSY.
 **
 ** Calling this routine with an argument less than or equal to zero
 ** turns off all busy handlers.
 */
-void sqlite_busy_timeout(sqlite*, int ms);
+void sqlite3_busy_timeout(sqlite*, int ms);
 
 /*
-** This next routine is really just a wrapper around sqlite_exec().
+** This next routine is really just a wrapper around sqlite3_exec().
 ** Instead of invoking a user-supplied callback for each row of the
 ** result, this routine remembers each row of the result in memory
 ** obtained from malloc(), then returns all of the result after the
@@ -324,15 +324,15 @@ void sqlite_busy_timeout(sqlite*, int ms);
 ** will be ((*nrow) + 1)*(*ncolumn).
 **
 ** After the calling function has finished using the result, it should 
-** pass the result data pointer to sqlite_free_table() in order to 
+** pass the result data pointer to sqlite3_free_table() in order to 
 ** release the memory that was malloc-ed.  Because of the way the 
 ** malloc() happens, the calling function must not try to call 
-** malloc() directly.  Only sqlite_free_table() is able to release 
+** malloc() directly.  Only sqlite3_free_table() is able to release 
 ** the memory properly and safely.
 **
-** The return value of this routine is the same as from sqlite_exec().
+** The return value of this routine is the same as from sqlite3_exec().
 */
-int sqlite_get_table(
+int sqlite3_get_table(
   sqlite*,               /* An open database */
   const char *sql,       /* SQL to be executed */
   char ***resultp,       /* Result written to a char *[]  that this points to */
@@ -342,13 +342,13 @@ int sqlite_get_table(
 );
 
 /*
-** Call this routine to free the memory that sqlite_get_table() allocated.
+** Call this routine to free the memory that sqlite3_get_table() allocated.
 */
-void sqlite_free_table(char **result);
+void sqlite3_free_table(char **result);
 
 /*
-** The following routines are wrappers around sqlite_exec() and
-** sqlite_get_table().  The only difference between the routines that
+** The following routines are wrappers around sqlite3_exec() and
+** sqlite3_get_table().  The only difference between the routines that
 ** follow and the originals is that the second argument to the 
 ** routines that follow is really a printf()-style format
 ** string describing the SQL to be executed.  Arguments to the format
@@ -367,7 +367,7 @@ void sqlite_free_table(char **result);
 **
 ** We can use this text in an SQL statement as follows:
 **
-**      sqlite_exec_printf(db, "INSERT INTO table VALUES('%q')",
+**      sqlite3_exec_printf(db, "INSERT INTO table VALUES('%q')",
 **          callback1, 0, 0, zText);
 **
 ** Because the %q format string is used, the '\'' character in zText
@@ -384,7 +384,7 @@ void sqlite_free_table(char **result);
 ** should always use %q instead of %s when inserting text into a string 
 ** literal.
 */
-int sqlite_exec_printf(
+int sqlite3_exec_printf(
   sqlite*,                      /* An open database */
   const char *sqlFormat,        /* printf-style format string for the SQL */
   sqlite_callback,              /* Callback function */
@@ -392,7 +392,7 @@ int sqlite_exec_printf(
   char **errmsg,                /* Error msg written here */
   ...                           /* Arguments to the format string. */
 );
-int sqlite_exec_vprintf(
+int sqlite3_exec_vprintf(
   sqlite*,                      /* An open database */
   const char *sqlFormat,        /* printf-style format string for the SQL */
   sqlite_callback,              /* Callback function */
@@ -400,7 +400,7 @@ int sqlite_exec_vprintf(
   char **errmsg,                /* Error msg written here */
   va_list ap                    /* Arguments to the format string. */
 );
-int sqlite_get_table_printf(
+int sqlite3_get_table_printf(
   sqlite*,               /* An open database */
   const char *sqlFormat, /* printf-style format string for the SQL */
   char ***resultp,       /* Result written to a char *[]  that this points to */
@@ -409,7 +409,7 @@ int sqlite_get_table_printf(
   char **errmsg,         /* Error msg written here */
   ...                    /* Arguments to the format string */
 );
-int sqlite_get_table_vprintf(
+int sqlite3_get_table_vprintf(
   sqlite*,               /* An open database */
   const char *sqlFormat, /* printf-style format string for the SQL */
   char ***resultp,       /* Result written to a char *[]  that this points to */
@@ -418,23 +418,23 @@ int sqlite_get_table_vprintf(
   char **errmsg,         /* Error msg written here */
   va_list ap             /* Arguments to the format string */
 );
-char *sqlite_mprintf(const char*,...);
-char *sqlite_vmprintf(const char*, va_list);
+char *sqlite3_mprintf(const char*,...);
+char *sqlite3_vmprintf(const char*, va_list);
 
 /*
 ** Windows systems should call this routine to free memory that
-** is returned in the in the errmsg parameter of sqlite_open() when
+** is returned in the in the errmsg parameter of sqlite3_open() when
 ** SQLite is a DLL.  For some reason, it does not work to call free()
 ** directly.
 */
-void sqlite_freemem(void *p);
+void sqlite3_freemem(void *p);
 
 /*
-** Windows systems need functions to call to return the sqlite_version
-** and sqlite_encoding strings.
+** Windows systems need functions to call to return the sqlite3_version
+** and sqlite3_encoding strings.
 */
-const char *sqlite_libversion(void);
-const char *sqlite_libencoding(void);
+const char *sqlite3_libversion(void);
+const char *sqlite3_libencoding(void);
 
 /*
 ** A pointer to the following structure is used to communicate with
@@ -446,20 +446,20 @@ typedef struct sqlite_func sqlite_func;
 ** Use the following routines to create new user-defined functions.  See
 ** the documentation for details.
 */
-int sqlite_create_function(
+int sqlite3_create_function(
   sqlite*,                  /* Database where the new function is registered */
   const char *zName,        /* Name of the new function */
   int nArg,                 /* Number of arguments.  -1 means any number */
   void (*xFunc)(sqlite_func*,int,const char**),  /* C code to implement */
-  void *pUserData           /* Available via the sqlite_user_data() call */
+  void *pUserData           /* Available via the sqlite3_user_data() call */
 );
-int sqlite_create_aggregate(
+int sqlite3_create_aggregate(
   sqlite*,                  /* Database where the new function is registered */
   const char *zName,        /* Name of the function */
   int nArg,                 /* Number of arguments */
   void (*xStep)(sqlite_func*,int,const char**), /* Called for each row */
   void (*xFinalize)(sqlite_func*),       /* Called once to get final result */
-  void *pUserData           /* Available via the sqlite_user_data() call */
+  void *pUserData           /* Available via the sqlite3_user_data() call */
 );
 
 /*
@@ -473,7 +473,7 @@ int sqlite_create_aggregate(
 ** the result is always text.  If datatype==SQLITE_ARGS then the result
 ** is numeric if any argument is numeric and is text otherwise.
 */
-int sqlite_function_type(
+int sqlite3_function_type(
   sqlite *db,               /* The database there the function is registered */
   const char *zName,        /* Name of the function */
   int datatype              /* The datatype for this function */
@@ -487,30 +487,30 @@ int sqlite_function_type(
 ** in order to return their results.  The first parameter to each of these
 ** routines is a copy of the first argument to xFunc() or xFinialize().
 ** The second parameter to these routines is the result to be returned.
-** A NULL can be passed as the second parameter to sqlite_set_result_string()
+** A NULL can be passed as the second parameter to sqlite3_set_result_string()
 ** in order to return a NULL result.
 **
 ** The 3rd argument to _string and _error is the number of characters to
 ** take from the string.  If this argument is negative, then all characters
 ** up to and including the first '\000' are used.
 **
-** The sqlite_set_result_string() function allocates a buffer to hold the
+** The sqlite3_set_result_string() function allocates a buffer to hold the
 ** result and returns a pointer to this buffer.  The calling routine
 ** (that is, the implmentation of a user function) can alter the content
 ** of this buffer if desired.
 */
-char *sqlite_set_result_string(sqlite_func*,const char*,int);
-void sqlite_set_result_int(sqlite_func*,int);
-void sqlite_set_result_double(sqlite_func*,double);
-void sqlite_set_result_error(sqlite_func*,const char*,int);
+char *sqlite3_set_result_string(sqlite_func*,const char*,int);
+void sqlite3_set_result_int(sqlite_func*,int);
+void sqlite3_set_result_double(sqlite_func*,double);
+void sqlite3_set_result_error(sqlite_func*,const char*,int);
 
 /*
-** The pUserData parameter to the sqlite_create_function() and
-** sqlite_create_aggregate() routines used to register user functions
+** The pUserData parameter to the sqlite3_create_function() and
+** sqlite3_create_aggregate() routines used to register user functions
 ** is available to the implementation of the function using this
 ** call.
 */
-void *sqlite_user_data(sqlite_func*);
+void *sqlite3_user_data(sqlite_func*);
 
 /*
 ** Aggregate functions use the following routine to allocate
@@ -522,14 +522,14 @@ void *sqlite_user_data(sqlite_func*);
 **
 ** The buffer allocated is freed automatically be SQLite.
 */
-void *sqlite_aggregate_context(sqlite_func*, int nBytes);
+void *sqlite3_aggregate_context(sqlite_func*, int nBytes);
 
 /*
 ** The next routine returns the number of calls to xStep for a particular
 ** aggregate function instance.  The current call to xStep counts so this
 ** routine always returns at least 1.
 */
-int sqlite_aggregate_count(sqlite_func*);
+int sqlite3_aggregate_count(sqlite_func*);
 
 /*
 ** This routine registers a callback with the SQLite library.  The
@@ -539,7 +539,7 @@ int sqlite_aggregate_count(sqlite_func*);
 ** SQL statement should be aborted with an error and SQLITE_IGNORE
 ** if the column should be treated as a NULL value.
 */
-int sqlite_set_authorizer(
+int sqlite3_set_authorizer(
   sqlite*,
   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   void *pUserData
@@ -595,11 +595,11 @@ int sqlite_set_authorizer(
 #define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
 
 /*
-** Register a function that is called at every invocation of sqlite_exec()
-** or sqlite_compile().  This function can be used (for example) to generate
+** Register a function that is called at every invocation of sqlite3_exec()
+** or sqlite3_compile().  This function can be used (for example) to generate
 ** a log file of all SQL executed against a database.
 */
-void *sqlite_trace(sqlite*, void(*xTrace)(void*,const char*), void*);
+void *sqlite3_trace(sqlite*, void(*xTrace)(void*,const char*), void*);
 
 /*** The Callback-Free API
 ** 
@@ -614,7 +614,7 @@ typedef struct sqlite_vm sqlite_vm;
 /*
 ** To execute an SQLite query without the use of callbacks, you first have
 ** to compile the SQL using this routine.  The 1st parameter "db" is a pointer
-** to an sqlite object obtained from sqlite_open().  The 2nd parameter
+** to an sqlite object obtained from sqlite3_open().  The 2nd parameter
 ** "zSql" is the text of the SQL to be compiled.   The remaining parameters
 ** are all outputs.
 **
@@ -630,13 +630,13 @@ typedef struct sqlite_vm sqlite_vm;
 ** If any errors are detected during compilation, an error message is written
 ** into space obtained from malloc() and *pzErrMsg is made to point to that
 ** error message.  The calling routine is responsible for freeing the text
-** of this message when it has finished with it.  Use sqlite_freemem() to
+** of this message when it has finished with it.  Use sqlite3_freemem() to
 ** free the message.  pzErrMsg may be NULL in which case no error message
 ** will be generated.
 **
 ** On success, SQLITE_OK is returned.  Otherwise and error code is returned.
 */
-int sqlite_compile(
+int sqlite3_compile(
   sqlite *db,                   /* The open database */
   const char *zSql,             /* SQL statement to be compiled */
   const char **pzTail,          /* OUT: uncompiled tail of zSql */
@@ -651,7 +651,7 @@ int sqlite_compile(
 ** SQLITE_ERROR, SQLITE_BUSY, SQLITE_ROW, or SQLITE_MISUSE.
 **
 ** SQLITE_DONE means that the execute of the SQL statement is complete
-** an no errors have occurred.  sqlite_step() should not be called again
+** an no errors have occurred.  sqlite3_step() should not be called again
 ** for the same virtual machine.  *pN is set to the number of columns in
 ** the result set and *pazColName is set to an array of strings that
 ** describe the column names and datatypes.  The name of the i-th column
@@ -659,16 +659,16 @@ int sqlite_compile(
 ** (*pazColName)[i+*pN].  *pazValue is set to NULL.
 **
 ** SQLITE_ERROR means that the virtual machine encountered a run-time
-** error.  sqlite_step() should not be called again for the same
+** error.  sqlite3_step() should not be called again for the same
 ** virtual machine.  *pN is set to 0 and *pazColName and *pazValue are set
-** to NULL.  Use sqlite_finalize() to obtain the specific error code
+** to NULL.  Use sqlite3_finalize() to obtain the specific error code
 ** and the error message text for the error.
 **
 ** SQLITE_BUSY means that an attempt to open the database failed because
 ** another thread or process is holding a lock.  The calling routine
-** can try again to open the database by calling sqlite_step() again.
+** can try again to open the database by calling sqlite3_step() again.
 ** The return code will only be SQLITE_BUSY if no busy handler is registered
-** using the sqlite_busy_handler() or sqlite_busy_timeout() routines.  If
+** using the sqlite3_busy_handler() or sqlite3_busy_timeout() routines.  If
 ** a busy handler callback has been registered but returns 0, then this
 ** routine will return SQLITE_ERROR and sqltie_finalize() will return
 ** SQLITE_BUSY when it is called.
@@ -676,16 +676,16 @@ int sqlite_compile(
 ** SQLITE_ROW means that a single row of the result is now available.
 ** The data is contained in *pazValue.  The value of the i-th column is
 ** (*azValue)[i].  *pN and *pazColName are set as described in SQLITE_DONE.
-** Invoke sqlite_step() again to advance to the next row.
+** Invoke sqlite3_step() again to advance to the next row.
 **
-** SQLITE_MISUSE is returned if sqlite_step() is called incorrectly.
-** For example, if you call sqlite_step() after the virtual machine
-** has halted (after a prior call to sqlite_step() has returned SQLITE_DONE)
-** or if you call sqlite_step() with an incorrectly initialized virtual
+** SQLITE_MISUSE is returned if sqlite3_step() is called incorrectly.
+** For example, if you call sqlite3_step() after the virtual machine
+** has halted (after a prior call to sqlite3_step() has returned SQLITE_DONE)
+** or if you call sqlite3_step() with an incorrectly initialized virtual
 ** machine or a virtual machine that has been deleted or that is associated
 ** with an sqlite structure that has been closed.
 */
-int sqlite_step(
+int sqlite3_step(
   sqlite_vm *pVm,              /* The virtual machine to execute */
   int *pN,                     /* OUT: Number of columns in result */
   const char ***pazValue,      /* OUT: Column data */
@@ -699,39 +699,39 @@ int sqlite_step(
 ** there was any kind of error.  If an error occurred and pzErrMsg is not
 ** NULL, then an error message is written into memory obtained from malloc()
 ** and *pzErrMsg is made to point to that error message.  The calling routine
-** should use sqlite_freemem() to delete this message when it has finished
+** should use sqlite3_freemem() to delete this message when it has finished
 ** with it.
 **
 ** This routine can be called at any point during the execution of the
 ** virtual machine.  If the virtual machine has not completed execution
 ** when this routine is called, that is like encountering an error or
-** an interrupt.  (See sqlite_interrupt().)  Incomplete updates may be
+** an interrupt.  (See sqlite3_interrupt().)  Incomplete updates may be
 ** rolled back and transactions cancelled,  depending on the circumstances,
 ** and the result code returned will be SQLITE_ABORT.
 */
-int sqlite_finalize(sqlite_vm*, char **pzErrMsg);
+int sqlite3_finalize(sqlite_vm*, char **pzErrMsg);
 
 /*
 ** This routine deletes the virtual machine, writes any error message to
 ** *pzErrMsg and returns an SQLite return code in the same way as the
-** sqlite_finalize() function.
+** sqlite3_finalize() function.
 **
 ** Additionally, if ppVm is not NULL, *ppVm is left pointing to a new virtual
 ** machine loaded with the compiled version of the original query ready for
 ** execution.
 **
-** If sqlite_reset() returns SQLITE_SCHEMA, then *ppVm is set to NULL.
+** If sqlite3_reset() returns SQLITE_SCHEMA, then *ppVm is set to NULL.
 **
 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
 */
-int sqlite_reset(sqlite_vm*, char **pzErrMsg);
+int sqlite3_reset(sqlite_vm*, char **pzErrMsg);
 
 /*
-** If the SQL that was handed to sqlite_compile contains variables that
+** If the SQL that was handed to sqlite3_compile contains variables that
 ** are represeted in the SQL text by a question mark ('?').  This routine
 ** is used to assign values to those variables.
 **
-** The first parameter is a virtual machine obtained from sqlite_compile().
+** The first parameter is a virtual machine obtained from sqlite3_compile().
 ** The 2nd "idx" parameter determines which variable in the SQL statement
 ** to bind the value to.  The left most '?' is 1.  The 3rd parameter is
 ** the value to assign to that variable.  The 4th parameter is the number
@@ -748,17 +748,17 @@ int sqlite_reset(sqlite_vm*, char **pzErrMsg);
 ** If the 4th "len" parameter is -1, then strlen() is used to find the
 ** length.
 **
-** This routine can only be called immediately after sqlite_compile()
-** or sqlite_reset() and before any calls to sqlite_step().
+** This routine can only be called immediately after sqlite3_compile()
+** or sqlite3_reset() and before any calls to sqlite3_step().
 **
 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
 */
-int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy);
+int sqlite3_bind(sqlite_vm*, int idx, const char *value, int len, int copy);
 
 /*
 ** This routine configures a callback function - the progress callback - that
-** is invoked periodically during long running calls to sqlite_exec(),
-** sqlite_step() and sqlite_get_table(). An example use for this API is to keep
+** is invoked periodically during long running calls to sqlite3_exec(),
+** sqlite3_step() and sqlite3_get_table(). An example use for this API is to keep
 ** a GUI updated during a large query.
 **
 ** The progress callback is invoked once for every N virtual machine opcodes,
@@ -767,7 +767,7 @@ int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy);
 ** argument to this function is a void pointer passed to the progress callback
 ** function each time it is invoked.
 **
-** If a call to sqlite_exec(), sqlite_step() or sqlite_get_table() results 
+** If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results 
 ** in less than N opcodes being executed, then the progress callback is not
 ** invoked.
 ** 
@@ -778,11 +778,11 @@ int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy);
 ** If the progress callback returns a result other than 0, then the current 
 ** query is immediately terminated and any database changes rolled back. If the
 ** query was part of a larger transaction, then the transaction is not rolled
-** back and remains active. The sqlite_exec() call returns SQLITE_ABORT. 
+** back and remains active. The sqlite3_exec() call returns SQLITE_ABORT. 
 **
 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
 */
-void sqlite_progress_handler(sqlite*, int, int(*)(void*), void*);
+void sqlite3_progress_handler(sqlite*, int, int(*)(void*), void*);
 
 /*
 ** Register a callback function to be invoked whenever a new transaction
@@ -797,16 +797,16 @@ void sqlite_progress_handler(sqlite*, int, int(*)(void*), void*);
 **
 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
 */
-void *sqlite_commit_hook(sqlite*, int(*)(void*), void*);
+void *sqlite3_commit_hook(sqlite*, int(*)(void*), void*);
 
 /*
 ** Open an encrypted SQLite database.  If pKey==0 or nKey==0, this routine
-** is the same as sqlite_open().
+** is the same as sqlite3_open().
 **
 ** The code to implement this API is not available in the public release
 ** of SQLite.
 */
-sqlite *sqlite_open_encrypted(
+sqlite *sqlite3_open_encrypted(
   const char *zFilename,   /* Name of the encrypted database */
   const void *pKey,        /* Pointer to the key */
   int nKey,                /* Number of bytes in the key */
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index c2a5be917..a04fb2c98 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -11,7 +11,7 @@
 *************************************************************************
 ** Internal interface definitions for SQLite.
 **
-** @(#) $Id: sqliteInt.h,v 1.227 2004/05/10 10:05:54 danielk1977 Exp $
+** @(#) $Id: sqliteInt.h,v 1.228 2004/05/10 10:34:52 danielk1977 Exp $
 */
 #include "config.h"
 #include "sqlite.h"
@@ -197,16 +197,16 @@ typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */
 ** This variable gets set if malloc() ever fails.  After it gets set,
 ** the SQLite library shuts down permanently.
 */
-extern int sqlite_malloc_failed;
+extern int sqlite3_malloc_failed;
 
 /*
 ** The following global variables are used for testing and debugging
 ** only.  They only work if MEMORY_DEBUG is defined.
 */
 #ifdef MEMORY_DEBUG
-extern int sqlite_nMalloc;       /* Number of sqliteMalloc() calls */
-extern int sqlite_nFree;         /* Number of sqliteFree() calls */
-extern int sqlite_iMallocFail;   /* Fail sqliteMalloc() after this many calls */
+extern int sqlite3_nMalloc;       /* Number of sqliteMalloc() calls */
+extern int sqlite3_nFree;         /* Number of sqliteFree() calls */
+extern int sqlite3_iMallocFail;   /* Fail sqliteMalloc() after this many calls */
 #endif
 
 /*
@@ -339,7 +339,7 @@ struct Db {
 ** longer (since after version 2.8.12) reset to -1.
 **
 ** The sqlite.nChange does not count changes within triggers and keeps no
-** context.  It is reset at start of sqlite_exec.
+** context.  It is reset at start of sqlite3_exec.
 ** The sqlite.lsChange represents the number of changes made by the last
 ** insert, update, or delete statement.  It remains constant throughout the
 ** length of a statement and is then updated by OP_SetCounts.  It keeps a
@@ -1276,7 +1276,7 @@ int sqlite3FixExpr(DbFixer*, Expr*);
 int sqlite3FixExprList(DbFixer*, ExprList*);
 int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
 double sqlite3AtoF(const char *z, const char **);
-char *sqlite_snprintf(int,char*,const char*,...);
+char *sqlite3_snprintf(int,char*,const char*,...);
 int sqlite3FitsIn32Bits(const char *);
 
 unsigned char *sqlite3utf16to8(const void *pData, int N);
diff --git a/src/table.c b/src/table.c
index 39692c220..f47ba60a2 100644
--- a/src/table.c
+++ b/src/table.c
@@ -9,9 +9,9 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** This file contains the sqlite_get_table() and sqlite_free_table()
+** This file contains the sqlite3_get_table() and sqlite3_free_table()
 ** interface routines.  These are just wrappers around the main
-** interface routine of sqlite_exec().
+** interface routine of sqlite3_exec().
 **
 ** These routines are in a separate files so that they will not be linked
 ** if they are not used.
@@ -21,7 +21,7 @@
 #include "sqliteInt.h"
 
 /*
-** This structure is used to pass data from sqlite_get_table() through
+** This structure is used to pass data from sqlite3_get_table() through
 ** to the callback function is uses to build the result.
 */
 typedef struct TabResult {
@@ -40,7 +40,7 @@ typedef struct TabResult {
 ** is to fill in the TabResult structure appropriately, allocating new
 ** memory as necessary.
 */
-static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
+static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
   TabResult *p = (TabResult*)pArg;
   int need;
   int i;
@@ -85,7 +85,7 @@ static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
     }
   }else if( p->nColumn!=nCol ){
     sqlite3SetString(&p->zErrMsg,
-       "sqlite_get_table() called with two or more incompatible queries",
+       "sqlite3_get_table() called with two or more incompatible queries",
        (char*)0);
     p->rc = SQLITE_ERROR;
     return 1;
@@ -119,10 +119,10 @@ static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
 **
 ** The result that is written to ***pazResult is held in memory obtained
 ** from malloc().  But the caller cannot free this memory directly.  
-** Instead, the entire table should be passed to sqlite_free_table() when
+** Instead, the entire table should be passed to sqlite3_free_table() when
 ** the calling procedure is finished using it.
 */
-int sqlite_get_table(
+int sqlite3_get_table(
   sqlite *db,                 /* The database on which the SQL executes */
   const char *zSql,           /* The SQL to be executed */
   char ***pazResult,          /* Write the result table here */
@@ -148,12 +148,12 @@ int sqlite_get_table(
     return SQLITE_NOMEM;
   }
   res.azResult[0] = 0;
-  rc = sqlite_exec(db, zSql, sqlite_get_table_cb, &res, pzErrMsg);
+  rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
   if( res.azResult ){
     res.azResult[0] = (char*)res.nData;
   }
   if( rc==SQLITE_ABORT ){
-    sqlite_free_table(&res.azResult[1]);
+    sqlite3_free_table(&res.azResult[1]);
     if( res.zErrMsg ){
       if( pzErrMsg ){
         free(*pzErrMsg);
@@ -167,14 +167,14 @@ int sqlite_get_table(
   }
   sqliteFree(res.zErrMsg);
   if( rc!=SQLITE_OK ){
-    sqlite_free_table(&res.azResult[1]);
+    sqlite3_free_table(&res.azResult[1]);
     return rc;
   }
   if( res.nAlloc>res.nData ){
     char **azNew;
     azNew = realloc( res.azResult, sizeof(char*)*(res.nData+1) );
     if( azNew==0 ){
-      sqlite_free_table(&res.azResult[1]);
+      sqlite3_free_table(&res.azResult[1]);
       return SQLITE_NOMEM;
     }
     res.nAlloc = res.nData+1;
@@ -187,10 +187,10 @@ int sqlite_get_table(
 }
 
 /*
-** This routine frees the space the sqlite_get_table() malloced.
+** This routine frees the space the sqlite3_get_table() malloced.
 */
-void sqlite_free_table(
-  char **azResult             /* Result returned from from sqlite_get_table() */
+void sqlite3_free_table(
+  char **azResult             /* Result returned from from sqlite3_get_table() */
 ){
   if( azResult ){
     int i, n;
diff --git a/src/tclsqlite.c b/src/tclsqlite.c
index 474a72b84..2c3b9211d 100644
--- a/src/tclsqlite.c
+++ b/src/tclsqlite.c
@@ -11,7 +11,7 @@
 *************************************************************************
 ** A TCL Interface to SQLite
 **
-** $Id: tclsqlite.c,v 1.63 2004/05/08 08:23:37 danielk1977 Exp $
+** $Id: tclsqlite.c,v 1.64 2004/05/10 10:34:53 danielk1977 Exp $
 */
 #ifndef NO_TCL     /* Omit this whole file if TCL is unavailable */
 
@@ -56,7 +56,7 @@ struct SqliteDb {
   char *zProgress;      /* The progress callback routine */
   char *zAuth;          /* The authorization callback routine */
   SqlFunc *pFunc;       /* List of SQL functions */
-  int rc;               /* Return code of most recent sqlite_exec() */
+  int rc;               /* Return code of most recent sqlite3_exec() */
 };
 
 /*
@@ -185,10 +185,10 @@ static int DbEvalCallback(
       Tcl_SetVar2(cbData->interp, cbData->zArray, "*", azN[i],
          TCL_LIST_ELEMENT|TCL_APPEND_VALUE);
       if( azN[nCol] ){
-        char *z = sqlite_mprintf("typeof:%s", azN[i]);
+        char *z = sqlite3_mprintf("typeof:%s", azN[i]);
         Tcl_SetVar2(cbData->interp, cbData->zArray, z, azN[i+nCol],
            TCL_LIST_ELEMENT|TCL_APPEND_VALUE);
-        sqlite_freemem(z);
+        sqlite3_freemem(z);
       }
     }
     cbData->once = 0;
@@ -284,7 +284,7 @@ static int DbEvalCallback3(
 */
 static void DbDeleteCmd(void *db){
   SqliteDb *pDb = (SqliteDb*)db;
-  sqlite_close(pDb->db);
+  sqlite3_close(pDb->db);
   while( pDb->pFunc ){
     SqlFunc *pFunc = pDb->pFunc;
     pDb->pFunc = pFunc->pNext;
@@ -380,7 +380,7 @@ static int DbCommitHandler(void *cd){
 ** using TCL script.
 */
 static void tclSqlFunc(sqlite_func *context, int argc, const char **argv){
-  SqlFunc *p = sqlite_user_data(context);
+  SqlFunc *p = sqlite3_user_data(context);
   Tcl_DString cmd;
   int i;
   int rc;
@@ -392,9 +392,9 @@ static void tclSqlFunc(sqlite_func *context, int argc, const char **argv){
   }
   rc = Tcl_Eval(p->interp, Tcl_DStringValue(&cmd));
   if( rc ){
-    sqlite_set_result_error(context, Tcl_GetStringResult(p->interp), -1); 
+    sqlite3_set_result_error(context, Tcl_GetStringResult(p->interp), -1); 
   }else{
-    sqlite_set_result_string(context, Tcl_GetStringResult(p->interp), -1);
+    sqlite3_set_result_string(context, Tcl_GetStringResult(p->interp), -1);
   }
 }
 #ifndef SQLITE_OMIT_AUTHORIZATION
@@ -556,9 +556,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
 #ifndef SQLITE_OMIT_AUTHORIZATION
       if( pDb->zAuth ){
         pDb->interp = interp;
-        sqlite_set_authorizer(pDb->db, auth_callback, pDb);
+        sqlite3_set_authorizer(pDb->db, auth_callback, pDb);
       }else{
-        sqlite_set_authorizer(pDb->db, 0, 0);
+        sqlite3_set_authorizer(pDb->db, 0, 0);
       }
 #endif
     }
@@ -593,9 +593,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       }
       if( pDb->zBusy ){
         pDb->interp = interp;
-        sqlite_busy_handler(pDb->db, DbBusyHandler, pDb);
+        sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);
       }else{
-        sqlite_busy_handler(pDb->db, 0, 0);
+        sqlite3_busy_handler(pDb->db, 0, 0);
       }
     }
     break;
@@ -631,9 +631,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
       if( pDb->zProgress ){
         pDb->interp = interp;
-        sqlite_progress_handler(pDb->db, N, DbProgressHandler, pDb);
+        sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb);
       }else{
-        sqlite_progress_handler(pDb->db, 0, 0, 0);
+        sqlite3_progress_handler(pDb->db, 0, 0, 0);
       }
 #endif
     }else{
@@ -656,7 +656,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       Tcl_WrongNumArgs(interp, 2, objv, "");
       return TCL_ERROR;
     }
-    nChange = sqlite_changes(pDb->db);
+    nChange = sqlite3_changes(pDb->db);
     pResult = Tcl_GetObjResult(interp);
     Tcl_SetIntObj(pResult, nChange);
     break;
@@ -676,7 +676,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       Tcl_WrongNumArgs(interp, 2, objv, "");
       return TCL_ERROR;
     }
-    lsChange = sqlite_last_statement_changes(pDb->db);
+    lsChange = sqlite3_last_statement_changes(pDb->db);
     pResult = Tcl_GetObjResult(interp);
     Tcl_SetIntObj(pResult, lsChange);
     break;
@@ -720,9 +720,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       }
       if( pDb->zCommit ){
         pDb->interp = interp;
-        sqlite_commit_hook(pDb->db, DbCommitHandler, pDb);
+        sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);
       }else{
-        sqlite_commit_hook(pDb->db, 0, 0);
+        sqlite3_commit_hook(pDb->db, 0, 0);
       }
     }
     break;
@@ -741,7 +741,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       Tcl_WrongNumArgs(interp, 2, objv, "SQL");
       return TCL_ERROR;
     }
-    isComplete = sqlite_complete( Tcl_GetStringFromObj(objv[2], 0) );
+    isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );
     pResult = Tcl_GetObjResult(interp);
     Tcl_SetBooleanObj(pResult, isComplete);
     break;
@@ -751,7 +751,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
   **    $db errorcode
   **
   ** Return the numeric error code that was returned by the most recent
-  ** call to sqlite_exec().
+  ** call to sqlite3_exec().
   */
   case DB_ERRORCODE: {
     Tcl_SetObjResult(interp, Tcl_NewIntObj(pDb->rc));
@@ -799,14 +799,14 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       zErrMsg = 0;
       Tcl_IncrRefCount(objv[3]);
       Tcl_IncrRefCount(objv[4]);
-      rc = sqlite_exec(pDb->db, zSql, DbEvalCallback, &cbData, &zErrMsg);
+      rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback, &cbData, &zErrMsg);
       Tcl_DecrRefCount(objv[4]);
       Tcl_DecrRefCount(objv[3]);
       if( cbData.tcl_rc==TCL_BREAK ){ cbData.tcl_rc = TCL_OK; }
     }else{
       Tcl_Obj *pList = Tcl_NewObj();
       cbData.tcl_rc = TCL_OK;
-      rc = sqlite_exec(pDb->db, zSql, DbEvalCallback2, pList, &zErrMsg);
+      rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback2, pList, &zErrMsg);
       Tcl_SetObjResult(interp, pList);
     }
     pDb->rc = rc;
@@ -818,7 +818,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       free(zErrMsg);
       rc = TCL_ERROR;
     }else if( rc!=SQLITE_OK ){
-      Tcl_AppendResult(interp, sqlite_error_string(rc), 0);
+      Tcl_AppendResult(interp, sqlite3_error_string(rc), 0);
       rc = TCL_ERROR;
     }else{
     }
@@ -859,8 +859,8 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
     pFunc->pNext = pDb->pFunc;
     pFunc->zScript = (char*)&pFunc[1];
     strcpy(pFunc->zScript, zScript);
-    sqlite_create_function(pDb->db, zName, -1, tclSqlFunc, pFunc);
-    sqlite_function_type(pDb->db, zName, SQLITE_NUMERIC);
+    sqlite3_create_function(pDb->db, zName, -1, tclSqlFunc, pFunc);
+    sqlite3_function_type(pDb->db, zName, SQLITE_NUMERIC);
     break;
   }
 
@@ -876,7 +876,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       Tcl_WrongNumArgs(interp, 2, objv, "");
       return TCL_ERROR;
     }
-    rowid = sqlite_last_insert_rowid(pDb->db);
+    rowid = sqlite3_last_insert_rowid(pDb->db);
     pResult = Tcl_GetObjResult(interp);
     Tcl_SetIntObj(pResult, rowid);
     break;
@@ -895,7 +895,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       return TCL_ERROR;
     }
     zSql = Tcl_GetStringFromObj(objv[2], 0);
-    rc = sqlite_exec(pDb->db, zSql, DbEvalCallback3, interp, &zErrMsg);
+    rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback3, interp, &zErrMsg);
     if( rc==SQLITE_ABORT ){
       rc = SQLITE_OK;
     }else if( zErrMsg ){
@@ -903,7 +903,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       free(zErrMsg);
       rc = TCL_ERROR;
     }else if( rc!=SQLITE_OK ){
-      Tcl_AppendResult(interp, sqlite_error_string(rc), 0);
+      Tcl_AppendResult(interp, sqlite3_error_string(rc), 0);
       rc = TCL_ERROR;
     }
     break;
@@ -925,7 +925,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
 #ifdef SQLITE_HAS_CODEC
     rc = sqlite_rekey(pDb->db, pKey, nKey);
     if( rc ){
-      Tcl_AppendResult(interp, sqlite_error_string(rc), 0);
+      Tcl_AppendResult(interp, sqlite3_error_string(rc), 0);
       rc = TCL_ERROR;
     }
 #endif
@@ -944,7 +944,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       return TCL_ERROR;
     }
     if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR;
-    sqlite_busy_timeout(pDb->db, ms);
+    sqlite3_busy_timeout(pDb->db, ms);
     break;
   }
 
@@ -976,9 +976,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
       }
       if( pDb->zTrace ){
         pDb->interp = interp;
-        sqlite_trace(pDb->db, DbTraceHandler, pDb);
+        sqlite3_trace(pDb->db, DbTraceHandler, pDb);
       }else{
-        sqlite_trace(pDb->db, 0, 0);
+        sqlite3_trace(pDb->db, 0, 0);
       }
     }
     break;
@@ -1031,11 +1031,11 @@ static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
   if( objc==2 ){
     zArg = Tcl_GetStringFromObj(objv[1], 0);
     if( strcmp(zArg,"-encoding")==0 ){
-      Tcl_AppendResult(interp,sqlite_encoding,0);
+      Tcl_AppendResult(interp,sqlite3_encoding,0);
       return TCL_OK;
     }
     if( strcmp(zArg,"-version")==0 ){
-      Tcl_AppendResult(interp,sqlite_version,0);
+      Tcl_AppendResult(interp,sqlite3_version,0);
       return TCL_OK;
     }
     if( strcmp(zArg,"-has-codec")==0 ){
@@ -1086,9 +1086,9 @@ static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
   memset(p, 0, sizeof(*p));
   zFile = Tcl_GetStringFromObj(objv[2], 0);
 #ifdef SQLITE_HAS_CODEC
-  p->db = sqlite_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg);
+  p->db = sqlite3_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg);
 #else
-  p->db = sqlite_open(zFile, mode, &zErrMsg);
+  p->db = sqlite3_open(zFile, mode, &zErrMsg);
 #endif
   if( p->db==0 ){
     Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);
diff --git a/src/test1.c b/src/test1.c
index 3436bc75c..109beb979 100644
--- a/src/test1.c
+++ b/src/test1.c
@@ -13,7 +13,7 @@
 ** is not included in the SQLite library.  It is used for automated
 ** testing of the SQLite library.
 **
-** $Id: test1.c,v 1.37 2004/05/08 08:23:39 danielk1977 Exp $
+** $Id: test1.c,v 1.38 2004/05/10 10:34:53 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include "tcl.h"
@@ -82,7 +82,7 @@ static int makePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
 }
 
 /*
-** Usage:   sqlite_open filename
+** Usage:   sqlite3_open filename
 **
 ** Returns:  The name of an open database.
 */
@@ -100,7 +100,7 @@ static int sqlite_test_open(
        " FILENAME\"", 0);
     return TCL_ERROR;
   }
-  db = sqlite_open(argv[1], 0666, &zErr);
+  db = sqlite3_open(argv[1], 0666, &zErr);
   if( db==0 ){
     Tcl_AppendResult(interp, zErr, 0);
     free(zErr);
@@ -112,7 +112,7 @@ static int sqlite_test_open(
 }
 
 /*
-** The callback routine for sqlite_exec_printf().
+** The callback routine for sqlite3_exec_printf().
 */
 static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){
   Tcl_DString *str = (Tcl_DString*)pArg;
@@ -130,9 +130,9 @@ static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){
 }
 
 /*
-** Usage:  sqlite_exec_printf  DB  FORMAT  STRING
+** Usage:  sqlite3_exec_printf  DB  FORMAT  STRING
 **
-** Invoke the sqlite_exec_printf() interface using the open database
+** Invoke the sqlite3_exec_printf() interface using the open database
 ** DB.  The SQL is the string FORMAT.  The format string should contain
 ** one %s or %q.  STRING is the value inserted into %s or %q.
 */
@@ -154,7 +154,7 @@ static int test_exec_printf(
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   Tcl_DStringInit(&str);
-  rc = sqlite_exec_printf(db, argv[2], exec_printf_cb, &str, &zErr, argv[3]);
+  rc = sqlite3_exec_printf(db, argv[2], exec_printf_cb, &str, &zErr, argv[3]);
   sprintf(zBuf, "%d", rc);
   Tcl_AppendElement(interp, zBuf);
   Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
@@ -164,7 +164,7 @@ static int test_exec_printf(
 }
 
 /*
-** Usage:  sqlite_mprintf_z_test  SEPARATOR  ARG0  ARG1 ...
+** Usage:  sqlite3_mprintf_z_test  SEPARATOR  ARG0  ARG1 ...
 **
 ** Test the %z format of mprintf().  Use multiple mprintf() calls to 
 ** concatenate arg0 through argn using separator as the separator.
@@ -188,9 +188,9 @@ static int test_mprintf_z(
 }
 
 /*
-** Usage:  sqlite_get_table_printf  DB  FORMAT  STRING
+** Usage:  sqlite3_get_table_printf  DB  FORMAT  STRING
 **
-** Invoke the sqlite_get_table_printf() interface using the open database
+** Invoke the sqlite3_get_table_printf() interface using the open database
 ** DB.  The SQL is the string FORMAT.  The format string should contain
 ** one %s or %q.  STRING is the value inserted into %s or %q.
 */
@@ -215,7 +215,7 @@ static int test_get_table_printf(
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
   Tcl_DStringInit(&str);
-  rc = sqlite_get_table_printf(db, argv[2], &aResult, &nRow, &nCol, 
+  rc = sqlite3_get_table_printf(db, argv[2], &aResult, &nRow, &nCol, 
                &zErr, argv[3]);
   sprintf(zBuf, "%d", rc);
   Tcl_AppendElement(interp, zBuf);
@@ -230,14 +230,14 @@ static int test_get_table_printf(
   }else{
     Tcl_AppendElement(interp, zErr);
   }
-  sqlite_free_table(aResult);
+  sqlite3_free_table(aResult);
   if( zErr ) free(zErr);
   return TCL_OK;
 }
 
 
 /*
-** Usage:  sqlite_last_insert_rowid DB
+** Usage:  sqlite3_last_insert_rowid DB
 **
 ** Returns the integer ROWID of the most recent insert.
 */
@@ -255,15 +255,15 @@ static int test_last_rowid(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  sprintf(zBuf, "%d", sqlite_last_insert_rowid(db));
+  sprintf(zBuf, "%d", sqlite3_last_insert_rowid(db));
   Tcl_AppendResult(interp, zBuf, 0);
   return SQLITE_OK;
 }
 
 /*
-** Usage:  sqlite_close DB
+** Usage:  sqlite3_close DB
 **
-** Closes the database opened by sqlite_open.
+** Closes the database opened by sqlite3_open.
 */
 static int sqlite_test_close(
   void *NotUsed,
@@ -278,7 +278,7 @@ static int sqlite_test_close(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  sqlite_close(db);
+  sqlite3_close(db);
   return TCL_OK;
 }
 
@@ -290,7 +290,7 @@ static void ifnullFunc(sqlite_func *context, int argc, const char **argv){
   int i;
   for(i=0; i<argc; i++){
     if( argv[i] ){
-      sqlite_set_result_string(context, argv[i], -1);
+      sqlite3_set_result_string(context, argv[i], -1);
       break;
     }
   }
@@ -345,11 +345,11 @@ static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){
 }
 
 /*
-** Implementation of the x_sqlite_exec() function.  This function takes
+** Implementation of the x_sqlite3_exec() function.  This function takes
 ** a single argument and attempts to execute that argument as SQL code.
 ** This is illegal and should set the SQLITE_MISUSE flag on the database.
 **
-** 2004-Jan-07:  We have changed this to make it legal to call sqlite_exec()
+** 2004-Jan-07:  We have changed this to make it legal to call sqlite3_exec()
 ** from within a function call.  
 ** 
 ** This routine simulates the effect of having two threads attempt to
@@ -358,25 +358,25 @@ static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){
 static void sqlite3ExecFunc(sqlite_func *context, int argc, const char **argv){
   struct dstr x;
   memset(&x, 0, sizeof(x));
-  sqlite_exec((sqlite*)sqlite_user_data(context), argv[0], 
+  sqlite3_exec((sqlite*)sqlite3_user_data(context), argv[0], 
       execFuncCallback, &x, 0);
-  sqlite_set_result_string(context, x.z, x.nUsed);
+  sqlite3_set_result_string(context, x.z, x.nUsed);
   sqliteFree(x.z);
 }
 
 /*
 ** Usage:  sqlite_test_create_function DB
 **
-** Call the sqlite_create_function API on the given database in order
+** Call the sqlite3_create_function API on the given database in order
 ** to create a function named "x_coalesce".  This function does the same thing
 ** as the "coalesce" function.  This function also registers an SQL function
-** named "x_sqlite_exec" that invokes sqlite_exec().  Invoking sqlite_exec()
+** named "x_sqlite3_exec" that invokes sqlite3_exec().  Invoking sqlite3_exec()
 ** in this way is illegal recursion and should raise an SQLITE_MISUSE error.
 ** The effect is similar to trying to use the same database connection from
 ** two threads at the same time.
 **
 ** The original motivation for this routine was to be able to call the
-** sqlite_create_function function while a query is in progress in order
+** sqlite3_create_function function while a query is in progress in order
 ** to test the SQLITE_MISUSE detection logic.
 */
 static int test_create_function(
@@ -393,8 +393,8 @@ static int test_create_function(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  sqlite_create_function(db, "x_coalesce", -1, ifnullFunc, 0);
-  sqlite_create_function(db, "x_sqlite_exec", 1, sqlite3ExecFunc, db);
+  sqlite3_create_function(db, "x_coalesce", -1, ifnullFunc, 0);
+  sqlite3_create_function(db, "x_sqlite3_exec", 1, sqlite3ExecFunc, db);
   return TCL_OK;
 }
 
@@ -407,26 +407,26 @@ struct CountCtx {
 };
 static void countStep(sqlite_func *context, int argc, const char **argv){
   CountCtx *p;
-  p = sqlite_aggregate_context(context, sizeof(*p));
+  p = sqlite3_aggregate_context(context, sizeof(*p));
   if( (argc==0 || argv[0]) && p ){
     p->n++;
   }
 }   
 static void countFinalize(sqlite_func *context){
   CountCtx *p;
-  p = sqlite_aggregate_context(context, sizeof(*p));
-  sqlite_set_result_int(context, p ? p->n : 0);
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  sqlite3_set_result_int(context, p ? p->n : 0);
 }
 
 /*
 ** Usage:  sqlite_test_create_aggregate DB
 **
-** Call the sqlite_create_function API on the given database in order
+** Call the sqlite3_create_function API on the given database in order
 ** to create a function named "x_count".  This function does the same thing
 ** as the "md5sum" function.
 **
 ** The original motivation for this routine was to be able to call the
-** sqlite_create_aggregate function while a query is in progress in order
+** sqlite3_create_aggregate function while a query is in progress in order
 ** to test the SQLITE_MISUSE detection logic.
 */
 static int test_create_aggregate(
@@ -442,19 +442,19 @@ static int test_create_aggregate(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  sqlite_create_aggregate(db, "x_count", 0, countStep, countFinalize, 0);
-  sqlite_create_aggregate(db, "x_count", 1, countStep, countFinalize, 0);
+  sqlite3_create_aggregate(db, "x_count", 0, countStep, countFinalize, 0);
+  sqlite3_create_aggregate(db, "x_count", 1, countStep, countFinalize, 0);
   return TCL_OK;
 }
 
 
 
 /*
-** Usage:  sqlite_mprintf_int FORMAT INTEGER INTEGER INTEGER
+** Usage:  sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER
 **
 ** Call mprintf with three integer arguments
 */
-static int sqlite_mprintf_int(
+static int sqlite3_mprintf_int(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
@@ -470,18 +470,18 @@ static int sqlite_mprintf_int(
   for(i=2; i<5; i++){
     if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
   }
-  z = sqlite_mprintf(argv[1], a[0], a[1], a[2]);
+  z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
   Tcl_AppendResult(interp, z, 0);
-  sqlite_freemem(z);
+  sqlite3_freemem(z);
   return TCL_OK;
 }
 
 /*
-** Usage:  sqlite_mprintf_str FORMAT INTEGER INTEGER STRING
+** Usage:  sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING
 **
 ** Call mprintf with two integer arguments and one string argument
 */
-static int sqlite_mprintf_str(
+static int sqlite3_mprintf_str(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
@@ -497,18 +497,18 @@ static int sqlite_mprintf_str(
   for(i=2; i<4; i++){
     if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
   }
-  z = sqlite_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
+  z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
   Tcl_AppendResult(interp, z, 0);
-  sqlite_freemem(z);
+  sqlite3_freemem(z);
   return TCL_OK;
 }
 
 /*
-** Usage:  sqlite_mprintf_str FORMAT INTEGER INTEGER DOUBLE
+** Usage:  sqlite3_mprintf_str FORMAT INTEGER INTEGER DOUBLE
 **
 ** Call mprintf with two integer arguments and one double argument
 */
-static int sqlite_mprintf_double(
+static int sqlite3_mprintf_double(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
@@ -526,20 +526,20 @@ static int sqlite_mprintf_double(
     if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
   }
   if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR;
-  z = sqlite_mprintf(argv[1], a[0], a[1], r);
+  z = sqlite3_mprintf(argv[1], a[0], a[1], r);
   Tcl_AppendResult(interp, z, 0);
-  sqlite_freemem(z);
+  sqlite3_freemem(z);
   return TCL_OK;
 }
 
 /*
-** Usage:  sqlite_mprintf_str FORMAT DOUBLE DOUBLE
+** Usage:  sqlite3_mprintf_str FORMAT DOUBLE DOUBLE
 **
 ** Call mprintf with a single double argument which is the product of the
 ** two arguments given above.  This is used to generate overflow and underflow
 ** doubles to test that they are converted properly.
 */
-static int sqlite_mprintf_scaled(
+static int sqlite3_mprintf_scaled(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
@@ -556,9 +556,9 @@ static int sqlite_mprintf_scaled(
   for(i=2; i<4; i++){
     if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR;
   }
-  z = sqlite_mprintf(argv[1], r[0]*r[1]);
+  z = sqlite3_mprintf(argv[1], r[0]*r[1]);
   Tcl_AppendResult(interp, z, 0);
-  sqlite_freemem(z);
+  sqlite3_freemem(z);
   return TCL_OK;
 }
 
@@ -566,7 +566,7 @@ static int sqlite_mprintf_scaled(
 ** Usage: sqlite_malloc_fail N
 **
 ** Rig sqliteMalloc() to fail on the N-th call.  Turn off this mechanism
-** and reset the sqlite_malloc_failed variable is N==0.
+** and reset the sqlite3_malloc_failed variable is N==0.
 */
 #ifdef MEMORY_DEBUG
 static int sqlite_malloc_fail(
@@ -581,8 +581,8 @@ static int sqlite_malloc_fail(
     return TCL_ERROR;
   }
   if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
-  sqlite_iMallocFail = n;
-  sqlite_malloc_failed = 0;
+  sqlite3_iMallocFail = n;
+  sqlite3_malloc_failed = 0;
   return TCL_OK;
 }
 #endif
@@ -600,7 +600,7 @@ static int sqlite_malloc_stat(
   char **argv            /* Text of each argument */
 ){
   char zBuf[200];
-  sprintf(zBuf, "%d %d %d", sqlite_nMalloc, sqlite_nFree, sqlite_iMallocFail);
+  sprintf(zBuf, "%d %d %d", sqlite3_nMalloc, sqlite3_nFree, sqlite3_iMallocFail);
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
 }
@@ -630,19 +630,19 @@ static int sqlite_abort(
 static void testFunc(sqlite_func *context, int argc, const char **argv){
   while( argc>=2 ){
     if( argv[0]==0 ){
-      sqlite_set_result_error(context, "first argument to test function "
+      sqlite3_set_result_error(context, "first argument to test function "
          "may not be NULL", -1);
     }else if( sqlite3StrICmp(argv[0],"string")==0 ){
-      sqlite_set_result_string(context, argv[1], -1);
+      sqlite3_set_result_string(context, argv[1], -1);
     }else if( argv[1]==0 ){
-      sqlite_set_result_error(context, "2nd argument may not be NULL if the "
+      sqlite3_set_result_error(context, "2nd argument may not be NULL if the "
          "first argument is not \"string\"", -1);
     }else if( sqlite3StrICmp(argv[0],"int")==0 ){
-      sqlite_set_result_int(context, atoi(argv[1]));
+      sqlite3_set_result_int(context, atoi(argv[1]));
     }else if( sqlite3StrICmp(argv[0],"double")==0 ){
-      sqlite_set_result_double(context, sqlite3AtoF(argv[1], 0));
+      sqlite3_set_result_double(context, sqlite3AtoF(argv[1], 0));
     }else{
-      sqlite_set_result_error(context,"first argument should be one of: "
+      sqlite3_set_result_error(context,"first argument should be one of: "
           "string int double", -1);
     }
     argc -= 2;
@@ -669,9 +669,9 @@ static int test_register_func(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  rc = sqlite_create_function(db, argv[2], -1, testFunc, 0);
+  rc = sqlite3_create_function(db, argv[2], -1, testFunc, 0);
   if( rc!=0 ){
-    Tcl_AppendResult(interp, sqlite_error_string(rc), 0);
+    Tcl_AppendResult(interp, sqlite3_error_string(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
@@ -722,16 +722,16 @@ static int sqlite_datatypes(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  rc = sqlite_exec(db, argv[2], rememberDataTypes, interp, 0);
+  rc = sqlite3_exec(db, argv[2], rememberDataTypes, interp, 0);
   if( rc!=0 && rc!=SQLITE_ABORT ){
-    Tcl_AppendResult(interp, sqlite_error_string(rc), 0);
+    Tcl_AppendResult(interp, sqlite3_error_string(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
 /*
-** Usage:  sqlite_compile  DB  SQL  ?TAILVAR?
+** Usage:  sqlite3_compile  DB  SQL  ?TAILVAR?
 **
 ** Attempt to compile an SQL statement.  Return a pointer to the virtual
 ** machine used to execute that statement.  Unprocessed SQL is written
@@ -755,13 +755,13 @@ static int test_compile(
     return TCL_ERROR;
   }
   if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
-  rc = sqlite_compile(db, argv[2], argc==4 ? &zTail : 0, &vm, &zErr);
+  rc = sqlite3_compile(db, argv[2], argc==4 ? &zTail : 0, &vm, &zErr);
   if( argc==4 ) Tcl_SetVar(interp, argv[3], zTail, 0);
   if( rc ){
     assert( vm==0 );
     sprintf(zBuf, "(%d) ", rc);
     Tcl_AppendResult(interp, zBuf, zErr, 0);
-    sqlite_freemem(zErr);
+    sqlite3_freemem(zErr);
     return TCL_ERROR;
   }
   if( vm ){
@@ -772,7 +772,7 @@ static int test_compile(
 }
 
 /*
-** Usage:  sqlite_step  VM  ?NVAR?  ?VALUEVAR?  ?COLNAMEVAR?
+** Usage:  sqlite3_step  VM  ?NVAR?  ?VALUEVAR?  ?COLNAMEVAR?
 **
 ** Step a virtual machine.  Return a the result code as a string.
 ** Column results are written into three variables.
@@ -796,7 +796,7 @@ static int test_step(
     return TCL_ERROR;
   }
   if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR;
-  rc = sqlite_step(vm, argc>=3?&N:0, argc>=4?&azValue:0, argc==5?&azColName:0);
+  rc = sqlite3_step(vm, argc>=3?&N:0, argc>=4?&azValue:0, argc==5?&azColName:0);
   if( argc>=3 ){
     sprintf(zBuf, "%d", N);
     Tcl_SetVar(interp, argv[2], zBuf, 0);
@@ -832,7 +832,7 @@ static int test_step(
 }
 
 /*
-** Usage:  sqlite_finalize  VM 
+** Usage:  sqlite3_finalize  VM 
 **
 ** Shutdown a virtual machine.
 */
@@ -851,19 +851,19 @@ static int test_finalize(
     return TCL_ERROR;
   }
   if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR;
-  rc = sqlite_finalize(vm, &zErrMsg);
+  rc = sqlite3_finalize(vm, &zErrMsg);
   if( rc ){
     char zBuf[50];
     sprintf(zBuf, "(%d) ", rc);
     Tcl_AppendResult(interp, zBuf, zErrMsg, 0);
-    sqlite_freemem(zErrMsg);
+    sqlite3_freemem(zErrMsg);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
 /*
-** Usage:  sqlite_reset   VM 
+** Usage:  sqlite3_reset   VM 
 **
 ** Reset a virtual machine and prepare it to be run again.
 */
@@ -882,12 +882,12 @@ static int test_reset(
     return TCL_ERROR;
   }
   if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR;
-  rc = sqlite_reset(vm, &zErrMsg);
+  rc = sqlite3_reset(vm, &zErrMsg);
   if( rc ){
     char zBuf[50];
     sprintf(zBuf, "(%d) ", rc);
     Tcl_AppendResult(interp, zBuf, zErrMsg, 0);
-    sqlite_freemem(zErrMsg);
+    sqlite3_freemem(zErrMsg);
     return TCL_ERROR;
   }
   return TCL_OK;
@@ -895,12 +895,12 @@ static int test_reset(
 
 /*
 ** This is the "static_bind_value" that variables are bound to when
-** the FLAG option of sqlite_bind is "static"
+** the FLAG option of sqlite3_bind is "static"
 */
 static char *sqlite_static_bind_value = 0;
 
 /*
-** Usage:  sqlite_bind  VM  IDX  VALUE  FLAGS
+** Usage:  sqlite3_bind  VM  IDX  VALUE  FLAGS
 **
 ** Sets the value of the IDX-th occurance of "?" in the original SQL
 ** string.  VALUE is the new value.  If FLAGS=="null" then VALUE is
@@ -926,11 +926,11 @@ static int test_bind(
   if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR;
   if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR;
   if( strcmp(argv[4],"null")==0 ){
-    rc = sqlite_bind(vm, idx, 0, 0, 0);
+    rc = sqlite3_bind(vm, idx, 0, 0, 0);
   }else if( strcmp(argv[4],"static")==0 ){
-    rc = sqlite_bind(vm, idx, sqlite_static_bind_value, -1, 0);
+    rc = sqlite3_bind(vm, idx, sqlite_static_bind_value, -1, 0);
   }else if( strcmp(argv[4],"normal")==0 ){
-    rc = sqlite_bind(vm, idx, argv[3], -1, 1);
+    rc = sqlite3_bind(vm, idx, argv[3], -1, 1);
   }else{
     Tcl_AppendResult(interp, "4th argument should be "
         "\"null\" or \"static\" or \"normal\"", 0);
@@ -939,7 +939,7 @@ static int test_bind(
   if( rc ){
     char zBuf[50];
     sprintf(zBuf, "(%d) ", rc);
-    Tcl_AppendResult(interp, zBuf, sqlite_error_string(rc), 0);
+    Tcl_AppendResult(interp, zBuf, sqlite3_error_string(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
@@ -971,26 +971,26 @@ static int test_breakpoint(
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetest1_Init(Tcl_Interp *interp){
-  extern int sqlite_search_count;
-  extern int sqlite_interrupt_count;
-  extern int sqlite_open_file_count;
-  extern int sqlite_current_time;
+  extern int sqlite3_search_count;
+  extern int sqlite3_interrupt_count;
+  extern int sqlite3_open_file_count;
+  extern int sqlite3_current_time;
   static struct {
      char *zName;
      Tcl_CmdProc *xProc;
   } aCmd[] = {
-     { "sqlite_mprintf_int",             (Tcl_CmdProc*)sqlite_mprintf_int    },
-     { "sqlite_mprintf_str",             (Tcl_CmdProc*)sqlite_mprintf_str    },
-     { "sqlite_mprintf_double",          (Tcl_CmdProc*)sqlite_mprintf_double },
-     { "sqlite_mprintf_scaled",          (Tcl_CmdProc*)sqlite_mprintf_scaled },
-     { "sqlite_mprintf_z_test",          (Tcl_CmdProc*)test_mprintf_z        },
-     { "sqlite_open",                    (Tcl_CmdProc*)sqlite_test_open      },
-     { "sqlite_last_insert_rowid",       (Tcl_CmdProc*)test_last_rowid       },
-     { "sqlite_exec_printf",             (Tcl_CmdProc*)test_exec_printf      },
-     { "sqlite_get_table_printf",        (Tcl_CmdProc*)test_get_table_printf },
-     { "sqlite_close",                   (Tcl_CmdProc*)sqlite_test_close     },
-     { "sqlite_create_function",         (Tcl_CmdProc*)test_create_function  },
-     { "sqlite_create_aggregate",        (Tcl_CmdProc*)test_create_aggregate },
+     { "sqlite3_mprintf_int",             (Tcl_CmdProc*)sqlite3_mprintf_int    },
+     { "sqlite3_mprintf_str",             (Tcl_CmdProc*)sqlite3_mprintf_str    },
+     { "sqlite3_mprintf_double",          (Tcl_CmdProc*)sqlite3_mprintf_double },
+     { "sqlite3_mprintf_scaled",          (Tcl_CmdProc*)sqlite3_mprintf_scaled },
+     { "sqlite3_mprintf_z_test",          (Tcl_CmdProc*)test_mprintf_z        },
+     { "sqlite3_open",                    (Tcl_CmdProc*)sqlite_test_open      },
+     { "sqlite3_last_insert_rowid",       (Tcl_CmdProc*)test_last_rowid       },
+     { "sqlite3_exec_printf",             (Tcl_CmdProc*)test_exec_printf      },
+     { "sqlite3_get_table_printf",        (Tcl_CmdProc*)test_get_table_printf },
+     { "sqlite3_close",                   (Tcl_CmdProc*)sqlite_test_close     },
+     { "sqlite3_create_function",         (Tcl_CmdProc*)test_create_function  },
+     { "sqlite3_create_aggregate",        (Tcl_CmdProc*)test_create_aggregate },
      { "sqlite_register_test_function",  (Tcl_CmdProc*)test_register_func    },
      { "sqlite_abort",                   (Tcl_CmdProc*)sqlite_abort          },
      { "sqlite_datatypes",               (Tcl_CmdProc*)sqlite_datatypes      },
@@ -998,11 +998,11 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
      { "sqlite_malloc_fail",             (Tcl_CmdProc*)sqlite_malloc_fail    },
      { "sqlite_malloc_stat",             (Tcl_CmdProc*)sqlite_malloc_stat    },
 #endif
-     { "sqlite_compile",                 (Tcl_CmdProc*)test_compile          },
-     { "sqlite_step",                    (Tcl_CmdProc*)test_step             },
-     { "sqlite_finalize",                (Tcl_CmdProc*)test_finalize         },
-     { "sqlite_bind",                    (Tcl_CmdProc*)test_bind             },
-     { "sqlite_reset",                   (Tcl_CmdProc*)test_reset            },
+     { "sqlite3_compile",                 (Tcl_CmdProc*)test_compile          },
+     { "sqlite3_step",                    (Tcl_CmdProc*)test_step             },
+     { "sqlite3_finalize",                (Tcl_CmdProc*)test_finalize         },
+     { "sqlite3_bind",                    (Tcl_CmdProc*)test_bind             },
+     { "sqlite3_reset",                   (Tcl_CmdProc*)test_reset            },
      { "breakpoint",                     (Tcl_CmdProc*)test_breakpoint       },
   };
   int i;
@@ -1010,14 +1010,14 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
   }
-  Tcl_LinkVar(interp, "sqlite_search_count", 
-      (char*)&sqlite_search_count, TCL_LINK_INT);
-  Tcl_LinkVar(interp, "sqlite_interrupt_count", 
-      (char*)&sqlite_interrupt_count, TCL_LINK_INT);
-  Tcl_LinkVar(interp, "sqlite_open_file_count", 
-      (char*)&sqlite_open_file_count, TCL_LINK_INT);
-  Tcl_LinkVar(interp, "sqlite_current_time", 
-      (char*)&sqlite_current_time, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_search_count", 
+      (char*)&sqlite3_search_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_interrupt_count", 
+      (char*)&sqlite3_interrupt_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_open_file_count", 
+      (char*)&sqlite3_open_file_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_current_time", 
+      (char*)&sqlite3_current_time, TCL_LINK_INT);
   Tcl_LinkVar(interp, "sqlite_static_bind_value",
       (char*)&sqlite_static_bind_value, TCL_LINK_STRING);
   return TCL_OK;
diff --git a/src/test2.c b/src/test2.c
index 13a7dae82..72b68c56b 100644
--- a/src/test2.c
+++ b/src/test2.c
@@ -13,7 +13,7 @@
 ** is not included in the SQLite library.  It is used for automated
 ** testing of the SQLite library.
 **
-** $Id: test2.c,v 1.18 2004/05/08 08:23:39 danielk1977 Exp $
+** $Id: test2.c,v 1.19 2004/05/10 10:34:53 danielk1977 Exp $
 */
 #include "os.h"
 #include "sqliteInt.h"
@@ -524,7 +524,7 @@ static int fake_big_file(
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetest2_Init(Tcl_Interp *interp){
-  extern int sqlite_io_error_pending;
+  extern int sqlite3_io_error_pending;
   char zBuf[100];
   static struct {
     char *zName;
@@ -551,8 +551,8 @@ int Sqlitetest2_Init(Tcl_Interp *interp){
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
   }
-  Tcl_LinkVar(interp, "sqlite_io_error_pending",
-     (char*)&sqlite_io_error_pending, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_io_error_pending",
+     (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
 #ifdef SQLITE_TEST
   {
     extern int journal_format;
diff --git a/src/test4.c b/src/test4.c
index b1161e81b..c547ea11d 100644
--- a/src/test4.c
+++ b/src/test4.c
@@ -11,7 +11,7 @@
 *************************************************************************
 ** Code for testing the the SQLite library in a multithreaded environment.
 **
-** $Id: test4.c,v 1.4 2004/05/08 08:23:39 danielk1977 Exp $
+** $Id: test4.c,v 1.5 2004/05/10 10:34:53 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include "tcl.h"
@@ -63,15 +63,15 @@ static Thread threadset[N_THREAD];
 static void *thread_main(void *pArg){
   Thread *p = (Thread*)pArg;
   if( p->db ){
-    sqlite_close(p->db);
+    sqlite3_close(p->db);
   }
-  p->db = sqlite_open(p->zFilename, 0, &p->zErr);
+  p->db = sqlite3_open(p->zFilename, 0, &p->zErr);
   p->vm = 0;
   p->completed = 1;
   while( p->opnum<=p->completed ) sched_yield();
   while( p->xOp ){
     if( p->zErr && p->zErr!=p->zStaticErr ){
-      sqlite_freemem(p->zErr);
+      sqlite3_freemem(p->zErr);
       p->zErr = 0;
     }
     (*p->xOp)(p);
@@ -79,15 +79,15 @@ static void *thread_main(void *pArg){
     while( p->opnum<=p->completed ) sched_yield();
   }
   if( p->vm ){
-    sqlite_finalize(p->vm, 0);
+    sqlite3_finalize(p->vm, 0);
     p->vm = 0;
   }
   if( p->db ){
-    sqlite_close(p->db);
+    sqlite3_close(p->db);
     p->db = 0;
   }
   if( p->zErr && p->zErr!=p->zStaticErr ){
-    sqlite_freemem(p->zErr);
+    sqlite3_freemem(p->zErr);
     p->zErr = 0;
   }
   p->completed++;
@@ -441,10 +441,10 @@ static void do_compile(Thread *p){
     return;
   }
   if( p->vm ){
-    sqlite_finalize(p->vm, 0);
+    sqlite3_finalize(p->vm, 0);
     p->vm = 0;
   }
-  p->rc = sqlite_compile(p->db, p->zArg, 0, &p->vm, &p->zErr);
+  p->rc = sqlite3_compile(p->db, p->zArg, 0, &p->vm, &p->zErr);
 }
 
 /*
@@ -487,7 +487,7 @@ static void do_step(Thread *p){
     p->rc = SQLITE_ERROR;
     return;
   }
-  p->rc = sqlite_step(p->vm, &p->argc, &p->argv, &p->colv);
+  p->rc = sqlite3_step(p->vm, &p->argc, &p->argv, &p->colv);
 }
 
 /*
@@ -528,7 +528,7 @@ static void do_finalize(Thread *p){
     p->rc = SQLITE_ERROR;
     return;
   }
-  p->rc = sqlite_finalize(p->vm, &p->zErr);
+  p->rc = sqlite3_finalize(p->vm, &p->zErr);
   p->vm = 0;
 }
 
diff --git a/src/tokenize.c b/src/tokenize.c
index 065d1b408..4ccc98f65 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.69 2004/05/08 08:23:39 danielk1977 Exp $
+** $Id: tokenize.c,v 1.70 2004/05/10 10:34:53 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
@@ -416,7 +416,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
   }
   pParse->sLastToken.dyn = 0;
   pParse->zTail = zSql;
-  while( sqlite_malloc_failed==0 && zSql[i]!=0 ){
+  while( sqlite3_malloc_failed==0 && zSql[i]!=0 ){
     assert( i>=0 );
     pParse->sLastToken.z = &zSql[i];
     assert( pParse->sLastToken.dyn==0 );
@@ -462,7 +462,7 @@ abort_parse:
   }
   sqlite3ParserFree(pEngine, free);
   if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
-    sqlite3SetString(&pParse->zErrMsg, sqlite_error_string(pParse->rc),
+    sqlite3SetString(&pParse->zErrMsg, sqlite3_error_string(pParse->rc),
                     (char*)0);
   }
   if( pParse->zErrMsg ){
@@ -493,7 +493,7 @@ abort_parse:
 }
 
 /*
-** Token types used by the sqlite_complete() routine.  See the header
+** Token types used by the sqlite3_complete() routine.  See the header
 ** comments on that procedure for additional information.
 */
 #define tkEXPLAIN 0
@@ -551,7 +551,7 @@ abort_parse:
 **
 ** Whitespace never causes a state transition and is always ignored.
 */
-int sqlite_complete(const char *zSql){
+int sqlite3_complete(const char *zSql){
   u8 state = 0;   /* Current state, using numbers defined in header comment */
   u8 token;       /* Value of the next token */
 
diff --git a/src/trigger.c b/src/trigger.c
index d15225583..985b0b43c 100644
--- a/src/trigger.c
+++ b/src/trigger.c
@@ -63,7 +63,7 @@ void sqlite3BeginTrigger(
   ** 4. That we are not trying to create an INSTEAD OF trigger on a table.
   ** 5. That we are not trying to create a BEFORE or AFTER trigger on a view.
   */
-  if( sqlite_malloc_failed ) goto trigger_cleanup;
+  if( sqlite3_malloc_failed ) goto trigger_cleanup;
   assert( pTableName->nSrc==1 );
   if( db->init.busy
    && sqlite3FixInit(&sFix, pParse, db->init.iDb, "trigger", pName)
@@ -133,7 +133,7 @@ void sqlite3BeginTrigger(
   nt->name = zName;
   zName = 0;
   nt->table = sqliteStrDup(pTableName->a[0].zName);
-  if( sqlite_malloc_failed ) goto trigger_cleanup;
+  if( sqlite3_malloc_failed ) goto trigger_cleanup;
   nt->iDb = iDb;
   nt->iTabDb = tab->iDb;
   nt->op = op;
@@ -234,10 +234,10 @@ triggerfinish_cleanup:
 ** the effect of copying all Expr.token.z values into memory obtained
 ** from sqliteMalloc().  As initially created, the Expr.token.z values
 ** all point to the input string that was fed to the parser.  But that
-** string is ephemeral - it will go away as soon as the sqlite_exec()
+** string is ephemeral - it will go away as soon as the sqlite3_exec()
 ** call that started the parser exits.  This routine makes a persistent
 ** copy of all the Expr.token.z strings so that the TriggerStep structure
-** will be valid even after the sqlite_exec() call returns.
+** will be valid even after the sqlite3_exec() call returns.
 */
 static void sqlitePersistTriggerStep(TriggerStep *p){
   if( p->target.z ){
@@ -393,7 +393,7 @@ void sqlite3DropTrigger(Parse *pParse, SrcList *pName){
   int nName;
   sqlite *db = pParse->db;
 
-  if( sqlite_malloc_failed ) goto drop_trigger_cleanup;
+  if( sqlite3_malloc_failed ) goto drop_trigger_cleanup;
   assert( pName->nSrc==1 );
   zDb = pName->a[0].zDatabase;
   zName = pName->a[0].zName;
diff --git a/src/update.c b/src/update.c
index 128b6ed4d..71d893899 100644
--- a/src/update.c
+++ b/src/update.c
@@ -12,7 +12,7 @@
 ** This file contains C code routines that are called by the parser
 ** to handle UPDATE statements.
 **
-** $Id: update.c,v 1.71 2004/05/08 08:23:40 danielk1977 Exp $
+** $Id: update.c,v 1.72 2004/05/10 10:35:00 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 
@@ -59,7 +59,7 @@ void sqlite3Update(
   int oldIdx      = -1;  /* index of trigger "old" temp table       */
 
   sContext.pParse = 0;
-  if( pParse->nErr || sqlite_malloc_failed ) goto update_cleanup;
+  if( pParse->nErr || sqlite3_malloc_failed ) goto update_cleanup;
   db = pParse->db;
   assert( pTabList->nSrc==1 );
 
diff --git a/src/util.c b/src/util.c
index 420a7c207..3052116bb 100644
--- a/src/util.c
+++ b/src/util.c
@@ -14,7 +14,7 @@
 ** This file contains functions for allocating memory, comparing
 ** strings, and stuff like that.
 **
-** $Id: util.c,v 1.78 2004/05/10 10:05:54 danielk1977 Exp $
+** $Id: util.c,v 1.79 2004/05/10 10:35:00 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include <stdarg.h>
@@ -24,7 +24,7 @@
 ** If malloc() ever fails, this global variable gets set to 1.
 ** This causes the library to abort and never again function.
 */
-int sqlite_malloc_failed = 0;
+int sqlite3_malloc_failed = 0;
 
 /*
 ** If MEMORY_DEBUG is defined, then use versions of malloc() and
@@ -36,9 +36,9 @@ int sqlite_malloc_failed = 0;
 ** For keeping track of the number of mallocs and frees.   This
 ** is used to check for memory leaks.
 */
-int sqlite_nMalloc;         /* Number of sqliteMalloc() calls */
-int sqlite_nFree;           /* Number of sqliteFree() calls */
-int sqlite_iMallocFail;     /* Fail sqliteMalloc() after this many calls */
+int sqlite3_nMalloc;         /* Number of sqliteMalloc() calls */
+int sqlite3_nFree;           /* Number of sqliteFree() calls */
+int sqlite3_iMallocFail;     /* Fail sqliteMalloc() after this many calls */
 #if MEMORY_DEBUG>1
 static int memcnt = 0;
 #endif
@@ -56,15 +56,15 @@ void *sqlite3Malloc_(int n, int bZero, char *zFile, int line){
   void *p;
   int *pi;
   int i, k;
-  if( sqlite_iMallocFail>=0 ){
-    sqlite_iMallocFail--;
-    if( sqlite_iMallocFail==0 ){
-      sqlite_malloc_failed++;
+  if( sqlite3_iMallocFail>=0 ){
+    sqlite3_iMallocFail--;
+    if( sqlite3_iMallocFail==0 ){
+      sqlite3_malloc_failed++;
 #if MEMORY_DEBUG>1
       fprintf(stderr,"**** failed to allocate %d bytes at %s:%d\n",
               n, zFile,line);
 #endif
-      sqlite_iMallocFail--;
+      sqlite3_iMallocFail--;
       return 0;
     }
   }
@@ -72,10 +72,10 @@ void *sqlite3Malloc_(int n, int bZero, char *zFile, int line){
   k = (n+sizeof(int)-1)/sizeof(int);
   pi = malloc( (N_GUARD*2+1+k)*sizeof(int));
   if( pi==0 ){
-    sqlite_malloc_failed++;
+    sqlite3_malloc_failed++;
     return 0;
   }
-  sqlite_nMalloc++;
+  sqlite3_nMalloc++;
   for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122;
   pi[N_GUARD] = n;
   for(i=0; i<N_GUARD; i++) pi[k+1+N_GUARD+i] = 0xdead3344;
@@ -118,7 +118,7 @@ void sqlite3Free_(void *p, char *zFile, int line){
     int *pi, i, k, n;
     pi = p;
     pi -= N_GUARD+1;
-    sqlite_nFree++;
+    sqlite3_nFree++;
     for(i=0; i<N_GUARD; i++){
       if( pi[i]!=0xdead1122 ){
         fprintf(stderr,"Low-end memory corruption at 0x%x\n", (int)p);
@@ -175,7 +175,7 @@ void *sqlite3Realloc_(void *oldP, int n, char *zFile, int line){
   k = (n + sizeof(int) - 1)/sizeof(int);
   pi = malloc( (k+N_GUARD*2+1)*sizeof(int) );
   if( pi==0 ){
-    sqlite_malloc_failed++;
+    sqlite3_malloc_failed++;
     return 0;
   }
   for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122;
@@ -208,7 +208,7 @@ void sqlite3StrRealloc(char **pz){
   if( pz==0 || *pz==0 ) return;
   zNew = malloc( strlen(*pz) + 1 );
   if( zNew==0 ){
-    sqlite_malloc_failed++;
+    sqlite3_malloc_failed++;
     sqliteFree(*pz);
     *pz = 0;
   }
@@ -252,7 +252,7 @@ char *sqlite3StrNDup_(const char *z, int n, char *zFile, int line){
 void *sqliteMalloc(int n){
   void *p;
   if( (p = malloc(n))==0 ){
-    if( n>0 ) sqlite_malloc_failed++;
+    if( n>0 ) sqlite3_malloc_failed++;
   }else{
     memset(p, 0, n);
   }
@@ -266,7 +266,7 @@ void *sqliteMalloc(int n){
 void *sqliteMallocRaw(int n){
   void *p;
   if( (p = malloc(n))==0 ){
-    if( n>0 ) sqlite_malloc_failed++;
+    if( n>0 ) sqlite3_malloc_failed++;
   }
   return p;
 }
@@ -296,7 +296,7 @@ void *sqliteRealloc(void *p, int n){
   }
   p2 = realloc(p, n);
   if( p2==0 ){
-    sqlite_malloc_failed++;
+    sqlite3_malloc_failed++;
   }
   return p2;
 }
@@ -1085,7 +1085,7 @@ sqlite3LikeCompare(const unsigned char *zPattern, const unsigned char *zString){
 ** Ticket #202:  If db->magic is not a valid open value, take care not
 ** to modify the db structure at all.  It could be that db is a stale
 ** pointer.  In other words, it could be that there has been a prior
-** call to sqlite_close(db) and db has been deallocated.  And we do
+** call to sqlite3_close(db) and db has been deallocated.  And we do
 ** not want to write into deallocated memory.
 */
 int sqlite3SafetyOn(sqlite *db){
@@ -1118,8 +1118,8 @@ int sqlite3SafetyOff(sqlite *db){
 }
 
 /*
-** Check to make sure we are not currently executing an sqlite_exec().
-** If we are currently in an sqlite_exec(), return true and set
+** Check to make sure we are not currently executing an sqlite3_exec().
+** If we are currently in an sqlite3_exec(), return true and set
 ** sqlite.magic to SQLITE_MAGIC_ERROR.  This will cause a complete
 ** shutdown of the database.
 **
diff --git a/src/vacuum.c b/src/vacuum.c
index 0822ac344..52ca39b09 100644
--- a/src/vacuum.c
+++ b/src/vacuum.c
@@ -14,7 +14,7 @@
 ** Most of the code in this file may be omitted by defining the
 ** SQLITE_OMIT_VACUUM macro.
 **
-** $Id: vacuum.c,v 1.14 2004/05/08 08:23:40 danielk1977 Exp $
+** $Id: vacuum.c,v 1.15 2004/05/10 10:35:00 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
@@ -93,10 +93,10 @@ static int execsql(char **pzErrMsg, sqlite *db, const char *zSql){
   int rc;
 
   /* printf("***** executing *****\n%s\n", zSql); */
-  rc = sqlite_exec(db, zSql, 0, 0, &zErrMsg);
+  rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg);
   if( zErrMsg ){
     sqlite3SetString(pzErrMsg, zErrMsg, (char*)0);
-    sqlite_freemem(zErrMsg);
+    sqlite3_freemem(zErrMsg);
   }
   return rc;
 }
@@ -153,10 +153,10 @@ static int vacuumCallback1(void *pArg, int argc, char **argv, char **NotUsed){
     appendText(&p->s1, "SELECT * FROM ", -1);
     appendQuoted(&p->s1, argv[1]);
     p->zTable = argv[1];
-    rc = sqlite_exec(p->dbOld, p->s1.z, vacuumCallback2, p, &zErrMsg);
+    rc = sqlite3_exec(p->dbOld, p->s1.z, vacuumCallback2, p, &zErrMsg);
     if( zErrMsg ){
       sqlite3SetString(p->pzErrMsg, zErrMsg, (char*)0);
-      sqlite_freemem(zErrMsg);
+      sqlite3_freemem(zErrMsg);
     }
   }
   if( rc!=SQLITE_ABORT ) p->rc = rc;
@@ -266,7 +266,7 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){
   }
 
   
-  dbNew = sqlite_open(zTemp, 0, &zErrMsg);
+  dbNew = sqlite3_open(zTemp, 0, &zErrMsg);
   if( dbNew==0 ){
     sqlite3SetString(pzErrMsg, "unable to open a temporary database at ",
        zTemp, " - ", zErrMsg, (char*)0);
@@ -285,10 +285,10 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){
     assert( strlen(zPragma[i])<100 );
     sprintf(zBuf, "PRAGMA %s;", zPragma[i]);
     sVac.zPragma = zPragma[i];
-    rc = sqlite_exec(db, zBuf, vacuumCallback3, &sVac, &zErrMsg);
+    rc = sqlite3_exec(db, zBuf, vacuumCallback3, &sVac, &zErrMsg);
   }
   if( rc==SQLITE_OK ){
-    rc = sqlite_exec(db, 
+    rc = sqlite3_exec(db, 
       "SELECT type, name, sql FROM sqlite_master "
       "WHERE sql NOT NULL AND type!='view' "
       "UNION ALL "
@@ -298,7 +298,7 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){
   }
   if( rc==SQLITE_OK ){
     rc = sqlite3BtreeCopyFile(db->aDb[0].pBt, dbNew->aDb[0].pBt);
-    sqlite_exec(db, "COMMIT", 0, 0, 0);
+    sqlite3_exec(db, "COMMIT", 0, 0, 0);
     sqlite3ResetInternalSchema(db, 0);
   }
 
@@ -307,13 +307,13 @@ end_of_vacuum:
     sqlite3SetString(pzErrMsg, "unable to vacuum database - ", 
        zErrMsg, (char*)0);
   }
-  sqlite_exec(db, "ROLLBACK", 0, 0, 0);
-  if( dbNew ) sqlite_close(dbNew);
+  sqlite3_exec(db, "ROLLBACK", 0, 0, 0);
+  if( dbNew ) sqlite3_close(dbNew);
   sqlite3OsDelete(zTemp);
   sqliteFree(zTemp);
   sqliteFree(sVac.s1.z);
   sqliteFree(sVac.s2.z);
-  if( zErrMsg ) sqlite_freemem(zErrMsg);
+  if( zErrMsg ) sqlite3_freemem(zErrMsg);
   if( rc==SQLITE_ABORT ) sVac.rc = SQLITE_ERROR;
   return sVac.rc;
 #endif
diff --git a/src/vdbe.c b/src/vdbe.c
index b9b558d9f..4193a9bc2 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -43,7 +43,7 @@
 ** in this file for details.  If in doubt, do not deviate from existing
 ** commenting and indentation practices when changing or adding code.
 **
-** $Id: vdbe.c,v 1.272 2004/05/10 07:17:32 danielk1977 Exp $
+** $Id: vdbe.c,v 1.273 2004/05/10 10:35:00 danielk1977 Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
@@ -57,7 +57,7 @@
 ** working correctly.  This variable has no function other than to
 ** help verify the correct operation of the library.
 */
-int sqlite_search_count = 0;
+int sqlite3_search_count = 0;
 
 /*
 ** When this global variable is positive, it gets decremented once before
@@ -67,7 +67,7 @@ int sqlite_search_count = 0;
 ** This facility is used for testing purposes only.  It does not function
 ** in an ordinary build.
 */
-int sqlite_interrupt_count = 0;
+int sqlite3_interrupt_count = 0;
 
 /*
 ** Advance the virtual machine to the next output row.
@@ -77,11 +77,11 @@ int sqlite_interrupt_count = 0;
 **
 ** SQLITE_BUSY means that the virtual machine attempted to open
 ** a locked database and there is no busy callback registered.
-** Call sqlite_step() again to retry the open.  *pN is set to 0
+** Call sqlite3_step() again to retry the open.  *pN is set to 0
 ** and *pazColName and *pazValue are both set to NULL.
 **
 ** SQLITE_DONE means that the virtual machine has finished
-** executing.  sqlite_step() should not be called again on this
+** executing.  sqlite3_step() should not be called again on this
 ** virtual machine.  *pN and *pazColName are set appropriately
 ** but *pazValue is set to NULL.
 **
@@ -95,7 +95,7 @@ int sqlite_interrupt_count = 0;
 **
 ** SQLITE_ERROR means that a run-time error (such as a constraint
 ** violation) has occurred.  The details of the error will be returned
-** by the next call to sqlite_finalize().  sqlite_step() should not
+** by the next call to sqlite3_finalize().  sqlite3_step() should not
 ** be called again on the VM.
 **
 ** SQLITE_MISUSE means that the this routine was called inappropriately.
@@ -104,7 +104,7 @@ int sqlite_interrupt_count = 0;
 ** SQLITE_DONE.  Or it could be the case the the same database connection
 ** is being used simulataneously by two or more threads.
 */
-int sqlite_step(
+int sqlite3_step(
   sqlite_vm *pVm,              /* The virtual machine to execute */
   int *pN,                     /* OUT: Number of columns in result */
   const char ***pazValue,      /* OUT: Column data */
@@ -197,9 +197,9 @@ static AggElem *_AggInFocus(Agg *p){
 static int hardStringify(Mem *pStack){
   int fg = pStack->flags;
   if( fg & MEM_Real ){
-    sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
+    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
   }else if( fg & MEM_Int ){
-    sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i);
+    sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i);
   }else{
     pStack->zShort[0] = 0;
   }
@@ -439,7 +439,7 @@ __inline__ unsigned long long int hwtime(void){
 
 /*
 ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
-** sqlite_interrupt() routine has been called.  If it has been, then
+** sqlite3_interrupt() routine has been called.  If it has been, then
 ** processing of the VDBE program is interrupted.
 **
 ** This macro added to every instruction that does a jump in order to
@@ -504,7 +504,7 @@ int sqlite3VdbeExec(
   assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
   p->rc = SQLITE_OK;
   assert( p->explain==0 );
-  if( sqlite_malloc_failed ) goto no_mem;
+  if( sqlite3_malloc_failed ) goto no_mem;
   pTos = p->pTos;
   if( p->popStack ){
     popStack(&pTos, p->popStack);
@@ -532,10 +532,10 @@ int sqlite3VdbeExec(
     ** if we have a special test build.
     */
 #ifdef SQLITE_TEST
-    if( sqlite_interrupt_count>0 ){
-      sqlite_interrupt_count--;
-      if( sqlite_interrupt_count==0 ){
-        sqlite_interrupt(db);
+    if( sqlite3_interrupt_count>0 ){
+      sqlite3_interrupt_count--;
+      if( sqlite3_interrupt_count==0 ){
+        sqlite3_interrupt(db);
       }
     }
 #endif
@@ -645,7 +645,7 @@ case OP_Return: {
 ** Exit immediately.  All open cursors, Lists, Sorts, etc are closed
 ** automatically.
 **
-** P1 is the result code returned by sqlite_exec().  For a normal
+** P1 is the result code returned by sqlite3_exec().  For a normal
 ** halt, this should be SQLITE_OK (0).  For errors, it can be some
 ** other value.  If P1!=0 then P2 will determine whether or not to
 ** rollback the current transaction.  Do not rollback if P2==OE_Fail.
@@ -711,11 +711,11 @@ case OP_String: {
 /* Opcode: Variable P1 * *
 **
 ** Push the value of variable P1 onto the stack.  A variable is
-** an unknown in the original SQL string as handed to sqlite_compile().
+** an unknown in the original SQL string as handed to sqlite3_compile().
 ** Any occurance of the '?' character in the original SQL is considered
 ** a variable.  Variables in the SQL string are number from left to
 ** right beginning with 1.  The values of variables are set using the
-** sqlite_bind() API.
+** sqlite3_bind() API.
 */
 case OP_Variable: {
   int j = pOp->p1 - 1;
@@ -770,7 +770,7 @@ case OP_Dup: {
       pTos->z = pTos->zShort;
     }else if( (pTos->flags & MEM_Static)==0 ){
       pTos->z = sqliteMallocRaw(pFrom->n);
-      if( sqlite_malloc_failed ) goto no_mem;
+      if( sqlite3_malloc_failed ) goto no_mem;
       memcpy(pTos->z, pFrom->z, pFrom->n);
       pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short);
       pTos->flags |= MEM_Dyn;
@@ -2441,7 +2441,7 @@ case OP_Transaction: {
           p->pTos = pTos;
           return SQLITE_BUSY;
         }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){
-          sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+          sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0);
           busy = 0;
         }
         break;
@@ -2701,7 +2701,7 @@ case OP_OpenWrite: {
           p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */
           return SQLITE_BUSY;
         }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){
-          sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+          sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0);
           busy = 0;
         }
         break;
@@ -2855,7 +2855,7 @@ case OP_MoveTo: {
       pC->recnoIsValid = 0;
     }
     pC->deferredMoveto = 0;
-    sqlite_search_count++;
+    sqlite3_search_count++;
     oc = pOp->opcode;
     if( oc==OP_MoveTo && res<0 ){
       sqlite3BtreeNext(pC->pCursor, &res);
@@ -3187,7 +3187,7 @@ case OP_NewRecno: {
 ** incremented (otherwise not).  If the OPFLAG_CSCHANGE flag is set,
 ** then the current statement change count is incremented (otherwise not).
 ** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is
-** stored for subsequent return by the sqlite_last_insert_rowid() function
+** stored for subsequent return by the sqlite3_last_insert_rowid() function
 ** (otherwise it's unmodified).
 */
 /* Opcode: PutStrKey P1 * *
@@ -3694,7 +3694,7 @@ case OP_Next: {
     }
     if( res==0 ){
       pc = pOp->p2 - 1;
-      sqlite_search_count++;
+      sqlite3_search_count++;
     }
   }else{
     pC->nullRow = 1;
@@ -4780,7 +4780,7 @@ case OP_AggFocus: {
     pc = pOp->p2 - 1;
   }else{
     AggInsert(&p->agg, zKey, nKey);
-    if( sqlite_malloc_failed ) goto no_mem;
+    if( sqlite3_malloc_failed ) goto no_mem;
   }
   Release(pTos);
   pTos--;
@@ -4913,7 +4913,7 @@ case OP_SetInsert: {
     Release(pTos);
     pTos--;
   }
-  if( sqlite_malloc_failed ) goto no_mem;
+  if( sqlite3_malloc_failed ) goto no_mem;
   break;
 }
 
@@ -5013,7 +5013,7 @@ case OP_Vacuum: {
 /* An other opcode is illegal...
 */
 default: {
-  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);
   sqlite3SetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0);
   rc = SQLITE_INTERNAL;
   break;
@@ -5151,12 +5151,12 @@ abort_due_to_misuse:
   */
 abort_due_to_error:
   if( p->zErrMsg==0 ){
-    if( sqlite_malloc_failed ) rc = SQLITE_NOMEM;
-    sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+    if( sqlite3_malloc_failed ) rc = SQLITE_NOMEM;
+    sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0);
   }
   goto vdbe_halt;
 
-  /* Jump to here if the sqlite_interrupt() API sets the interrupt
+  /* Jump to here if the sqlite3_interrupt() API sets the interrupt
   ** flag.
   */
 abort_due_to_interrupt:
@@ -5167,6 +5167,6 @@ abort_due_to_interrupt:
   }else{
     rc = SQLITE_INTERRUPT;
   }
-  sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+  sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0);
   goto vdbe_halt;
 }