Merge trunk into wasi-patches branch.

FossilOrigin-Name: 656d36f50f630da68262469087bad1ac71b10325e233a7963103c8cbc232f61a

18 files changed, 163 insertions, 1309 deletions

diff --git a/src/analyze.c b/src/analyze.c
index 8562b9d7f..f3356ea3c 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -1597,6 +1597,8 @@ static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
 ** and its contents.
 */
 void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
+  assert( db!=0 );
+  assert( pIdx!=0 );
 #ifdef SQLITE_ENABLE_STAT4
   if( pIdx->aSample ){
     int j;
@@ -1606,7 +1608,7 @@ void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
     }
     sqlite3DbFree(db, pIdx->aSample);
   }
-  if( db && db->pnBytesFreed==0 ){
+  if( db->pnBytesFreed==0 ){
     pIdx->nSample = 0;
     pIdx->aSample = 0;
   }
diff --git a/src/btree.c b/src/btree.c
index fae572536..4fbe0b3db 100644
--- a/src/btree.c
+++ b/src/btree.c
@@ -10410,7 +10410,9 @@ static void checkList(
 ** lower 16 bits are the index of the last byte of that range.
 */
 static void btreeHeapInsert(u32 *aHeap, u32 x){
-  u32 j, i = ++aHeap[0];
+  u32 j, i;
+  assert( aHeap!=0 );
+  i = ++aHeap[0];
   aHeap[i] = x;
   while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){
     x = aHeap[j];
diff --git a/src/dbpage.c b/src/dbpage.c
index 9378dd4fc..17e5f44f5 100644
--- a/src/dbpage.c
+++ b/src/dbpage.c
@@ -246,7 +246,7 @@ static int dbpageFilter(
     pCsr->iDb = 0;
   }
   pBt = db->aDb[pCsr->iDb].pBt;
-  if( pBt==0 ) return SQLITE_OK;
+  if( NEVER(pBt==0) ) return SQLITE_OK;
   pCsr->pPager = sqlite3BtreePager(pBt);
   pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
   pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
@@ -337,18 +337,20 @@ static int dbpageUpdate(
     goto update_fail;
   }
   pgno = sqlite3_value_int(argv[0]);
-  if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL
+   || (Pgno)sqlite3_value_int(argv[1])!=pgno
+  ){
     zErr = "cannot insert";
     goto update_fail;
   }
   zSchema = (const char*)sqlite3_value_text(argv[4]);
-  iDb = zSchema ? sqlite3FindDbName(pTab->db, zSchema) : -1;
-  if( iDb<0 ){
+  iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;
+  if( NEVER(iDb<0) ){
     zErr = "no such schema";
     goto update_fail;
   }
   pBt = pTab->db->aDb[iDb].pBt;
-  if( pgno<1 || pBt==0 || pgno>sqlite3BtreeLastPage(pBt) ){
+  if( NEVER(pgno<1) || NEVER(pBt==0) || NEVER(pgno>sqlite3BtreeLastPage(pBt)) ){
     zErr = "bad page number";
     goto update_fail;
   }
@@ -387,12 +389,11 @@ static int dbpageBegin(sqlite3_vtab *pVtab){
   DbpageTable *pTab = (DbpageTable *)pVtab;
   sqlite3 *db = pTab->db;
   int i;
-  int rc = SQLITE_OK;
-  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
+  for(i=0; i<db->nDb; i++){
     Btree *pBt = db->aDb[i].pBt;
-    if( pBt ) rc = sqlite3BtreeBeginTrans(pBt, 1, 0);
+    if( pBt ) (void)sqlite3BtreeBeginTrans(pBt, 1, 0);
   }
-  return rc;
+  return SQLITE_OK;
 }
 
 
diff --git a/src/os_unix.c b/src/os_unix.c
index e430e5df3..6e9ee3263 100644
--- a/src/os_unix.c
+++ b/src/os_unix.c
@@ -1695,7 +1695,7 @@ static int unixFileLock(unixFile *pFile, struct flock *pLock){
 **
 **    UNLOCKED -> SHARED
 **    SHARED -> RESERVED
-**    SHARED -> (PENDING) -> EXCLUSIVE
+**    SHARED -> EXCLUSIVE
 **    RESERVED -> (PENDING) -> EXCLUSIVE
 **    PENDING -> EXCLUSIVE
 **
@@ -1728,19 +1728,20 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   ** A RESERVED lock is implemented by grabbing a write-lock on the
   ** 'reserved byte'. 
   **
-  ** A process may only obtain a PENDING lock after it has obtained a
-  ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
-  ** on the 'pending byte'. This ensures that no new SHARED locks can be
-  ** obtained, but existing SHARED locks are allowed to persist. A process
-  ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
-  ** This property is used by the algorithm for rolling back a journal file
-  ** after a crash.
+  ** An EXCLUSIVE lock may only be requested after either a SHARED or
+  ** RESERVED lock is held. An EXCLUSIVE lock is implemented by obtaining 
+  ** a write-lock on the entire 'shared byte range'. Since all other locks 
+  ** require a read-lock on one of the bytes within this range, this ensures 
+  ** that no other locks are held on the database. 
   **
-  ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
-  ** implemented by obtaining a write-lock on the entire 'shared byte
-  ** range'. Since all other locks require a read-lock on one of the bytes
-  ** within this range, this ensures that no other locks are held on the
-  ** database. 
+  ** If a process that holds a RESERVED lock requests an EXCLUSIVE, then
+  ** a PENDING lock is obtained first. A PENDING lock is implemented by 
+  ** obtaining a write-lock on the 'pending byte'. This ensures that no new 
+  ** SHARED locks can be obtained, but existing SHARED locks are allowed to 
+  ** persist. If the call to this function fails to obtain the EXCLUSIVE
+  ** lock in this case, it holds the PENDING lock intead. The client may
+  ** then re-attempt the EXCLUSIVE lock later on, after existing SHARED
+  ** locks have cleared.
   */
   int rc = SQLITE_OK;
   unixFile *pFile = (unixFile*)id;
@@ -1811,7 +1812,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   lock.l_len = 1L;
   lock.l_whence = SEEK_SET;
   if( eFileLock==SHARED_LOCK 
-      || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
+   || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK)
   ){
     lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
     lock.l_start = PENDING_BYTE;
@@ -1822,6 +1823,9 @@ static int unixLock(sqlite3_file *id, int eFileLock){
         storeLastErrno(pFile, tErrno);
       }
       goto end_lock;
+    }else if( eFileLock==EXCLUSIVE_LOCK ){
+      pFile->eFileLock = PENDING_LOCK;
+      pInode->eFileLock = PENDING_LOCK;
     }
   }
 
@@ -1909,13 +1913,9 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   }
 #endif
 
-
   if( rc==SQLITE_OK ){
     pFile->eFileLock = eFileLock;
     pInode->eFileLock = eFileLock;
-  }else if( eFileLock==EXCLUSIVE_LOCK ){
-    pFile->eFileLock = PENDING_LOCK;
-    pInode->eFileLock = PENDING_LOCK;
   }
 
 end_lock:
diff --git a/src/pager.c b/src/pager.c
index 6e6527e15..5f6e975fd 100644
--- a/src/pager.c
+++ b/src/pager.c
@@ -4693,7 +4693,6 @@ int sqlite3PagerOpen(
   u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE;  /* Default page size */
   const char *zUri = 0;    /* URI args to copy */
   int nUriByte = 1;        /* Number of bytes of URI args at *zUri */
-  int nUri = 0;            /* Number of URI parameters */
 
   /* Figure out how much space is required for each journal file-handle
   ** (there are two of them, the main journal and the sub-journal).  */
@@ -4741,7 +4740,6 @@ int sqlite3PagerOpen(
     while( *z ){
       z += strlen(z)+1;
       z += strlen(z)+1;
-      nUri++;
     }
     nUriByte = (int)(&z[1] - zUri);
     assert( nUriByte>=1 );
@@ -6269,7 +6267,7 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
 # define DIRECT_MODE isDirectMode
 #endif
 
-  if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
+  if( !pPager->changeCountDone && pPager->dbSize>0 ){
     PgHdr *pPgHdr;                /* Reference to page 1 */
 
     assert( !pPager->tempFile && isOpen(pPager->fd) );
diff --git a/src/pragma.c b/src/pragma.c
index 527b2a734..522a12d33 100644
--- a/src/pragma.c
+++ b/src/pragma.c
@@ -1785,12 +1785,21 @@ void sqlite3Pragma(
         ** will also prepopulate the cursor column cache that is used
         ** by the OP_IsType code, so it is a required step.
         */
-        mxCol = pTab->nCol-1;
-        while( mxCol>=0
-            && ((pTab->aCol[mxCol].colFlags & COLFLAG_VIRTUAL)!=0
-                || pTab->iPKey==mxCol) ) mxCol--;
+        assert( !IsVirtual(pTab) );
+        if( HasRowid(pTab) ){
+          mxCol = -1;
+          for(j=0; j<pTab->nCol; j++){
+            if( (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)==0 ) mxCol++;
+          }
+          if( mxCol==pTab->iPKey ) mxCol--;
+        }else{
+          /* COLFLAG_VIRTUAL columns are not included in the WITHOUT ROWID
+          ** PK index column-count, so there is no need to account for them 
+          ** in this case. */
+          mxCol = sqlite3PrimaryKeyIndex(pTab)->nColumn-1;
+        }
         if( mxCol>=0 ){
-          sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, mxCol, 3);
+          sqlite3VdbeAddOp3(v, OP_Column, iDataCur, mxCol, 3);
           sqlite3VdbeTypeofColumn(v, 3);
         }
 
diff --git a/src/resolve.c b/src/resolve.c
index 0d196ac37..9677f9de9 100644
--- a/src/resolve.c
+++ b/src/resolve.c
@@ -203,6 +203,32 @@ static void extendFJMatch(
 }
 
 /*
+** Return TRUE (non-zero) if zTab is a valid name for the schema table pTab.
+*/
+static SQLITE_NOINLINE int isValidSchemaTableName(
+  const char *zTab,         /* Name as it appears in the SQL */
+  Table *pTab,              /* The schema table we are trying to match */
+  Schema *pSchema           /* non-NULL if a database qualifier is present */
+){
+  const char *zLegacy;
+  assert( pTab!=0 );
+  assert( pTab->tnum==1 );
+  if( sqlite3StrNICmp(zTab, "sqlite_", 7)!=0 ) return 0;
+  zLegacy = pTab->zName;
+  if( strcmp(zLegacy+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
+    if( sqlite3StrICmp(zTab+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
+      return 1;
+    }
+    if( pSchema==0 ) return 0;
+    if( sqlite3StrICmp(zTab+7, &LEGACY_SCHEMA_TABLE[7])==0 ) return 1;
+    if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1;
+  }else{
+    if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1;
+  }
+  return 0;
+}
+
+/*
 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
 ** that name in the set of source tables in pSrcList and make the pExpr 
 ** expression node refer back to that source column.  The following changes
@@ -355,15 +381,17 @@ static int lookupName(
         }
         assert( zDb==0 || zTab!=0 );
         if( zTab ){
-          const char *zTabName;
           if( zDb ){
             if( pTab->pSchema!=pSchema ) continue;
             if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue;
           }
-          zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;
-          assert( zTabName!=0 );
-          if( sqlite3StrICmp(zTabName, zTab)!=0 ){
-            continue;
+          if( pItem->zAlias!=0 ){
+            if( sqlite3StrICmp(zTab, pItem->zAlias)!=0 ){
+              continue;
+            }
+          }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
+            if( pTab->tnum!=1 ) continue;
+            if( !isValidSchemaTableName(zTab, pTab, pSchema) ) continue;
           }
           assert( ExprUseYTab(pExpr) );
           if( IN_RENAME_OBJECT && pItem->zAlias ){
diff --git a/src/select.c b/src/select.c
index d27bed026..b0e303066 100644
--- a/src/select.c
+++ b/src/select.c
@@ -5626,9 +5626,6 @@ static int resolveFromTermToCte(
     pFrom->fg.isCte = 1;
     pFrom->u2.pCteUse = pCteUse;
     pCteUse->nUse++;
-    if( pCteUse->nUse>=2 && pCteUse->eM10d==M10d_Any ){
-      pCteUse->eM10d = M10d_Yes;
-    }
 
     /* Check if this is a recursive CTE. */
     pRecTerm = pSel = pFrom->pSelect;
@@ -6911,8 +6908,10 @@ static int sameSrcAlias(SrcItem *p0, SrcList *pSrc){
 **                    being used as the outer loop if the sqlite3WhereBegin()
 **                    routine nominates it to that position.
 **              (iii) The query is not a UPDATE ... FROM
-**    (2)  The subquery is not a CTE that should be materialized because of
-**         the AS MATERIALIZED keywords
+**    (2)  The subquery is not a CTE that should be materialized because
+**         (a) the AS MATERIALIZED keyword is used, or
+**         (b) the CTE is used multiple times and does not have the
+**             NOT MATERIALIZED keyword
 **    (3)  The subquery is not part of a left operand for a RIGHT JOIN
 **    (4)  The SQLITE_Coroutine optimization disable flag is not set
 **    (5)  The subquery is not self-joined
@@ -6924,9 +6923,13 @@ static int fromClauseTermCanBeCoroutine(
   int selFlags            /* Flags on the SELECT statement */
 ){
   SrcItem *pItem = &pTabList->a[i];
-  if( pItem->fg.isCte && pItem->u2.pCteUse->eM10d==M10d_Yes ) return 0;/* (2) */
-  if( pTabList->a[0].fg.jointype & JT_LTORJ ) return 0;                /* (3) */
-  if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0;  /* (4) */
+  if( pItem->fg.isCte ){
+    const CteUse *pCteUse = pItem->u2.pCteUse;
+    if( pCteUse->eM10d==M10d_Yes ) return 0;                          /* (2a) */
+    if( pCteUse->nUse>=2 && pCteUse->eM10d!=M10d_No ) return 0;       /* (2b) */
+  }
+  if( pTabList->a[0].fg.jointype & JT_LTORJ ) return 0;               /* (3)  */
+  if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0; /* (4)  */
   if( isSelfJoinView(pTabList, pItem, i+1, pTabList->nSrc)!=0 ){
     return 0;                                                          /* (5) */
   }
diff --git a/src/shell.c.in b/src/shell.c.in
index 3da0bf3b9..f5a354a2e 100644
--- a/src/shell.c.in
+++ b/src/shell.c.in
@@ -5685,10 +5685,13 @@ static int sql_trace_callback(
 /*
 ** A no-op routine that runs with the ".breakpoint" doc-command.  This is
 ** a useful spot to set a debugger breakpoint.
+**
+** This routine does not do anything practical.  The code are there simply
+** to prevent the compiler from optimizing this routine out.
 */
 static void test_breakpoint(void){
-  static int nCall = 0;
-  nCall++;
+  static unsigned int nCall = 0;
+  if( (nCall++)==0xffffffff ) printf("Many .breakpoints have run\n");
 }
 
 /*
diff --git a/src/test7.c b/src/test7.c
deleted file mode 100644
index d57e4b826..000000000
--- a/src/test7.c
+++ /dev/null
@@ -1,718 +0,0 @@
-/*
-** 2006 January 09
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-** Code for testing the client/server version of the SQLite library.
-** Derived from test4.c.
-*/
-#include "sqliteInt.h"
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#endif
-
-/*
-** This test only works on UNIX with a SQLITE_THREADSAFE build that includes
-** the SQLITE_SERVER option.
-*/
-#if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE) && \
-    SQLITE_OS_UNIX && SQLITE_THREADSAFE
-
-#include <stdlib.h>
-#include <string.h>
-#include <pthread.h>
-#include <sched.h>
-#include <ctype.h>
-
-/*
-** Interfaces defined in server.c
-*/
-int sqlite3_client_open(const char*, sqlite3**);
-int sqlite3_client_prepare(sqlite3*,const char*,int,
-                           sqlite3_stmt**,const char**);
-int sqlite3_client_step(sqlite3_stmt*);
-int sqlite3_client_reset(sqlite3_stmt*);
-int sqlite3_client_finalize(sqlite3_stmt*);
-int sqlite3_client_close(sqlite3*);
-int sqlite3_server_start(void);
-int sqlite3_server_stop(void);
-void sqlite3_server_start2(int *pnDecr);
-
-/*
-** Each thread is controlled by an instance of the following
-** structure.
-*/
-typedef struct Thread Thread;
-struct Thread {
-  /* The first group of fields are writable by the supervisor thread
-  ** and read-only to the client threads
-  */
-  char *zFilename;         /* Name of database file */
-  void (*xOp)(Thread*);    /* next operation to do */
-  char *zArg;              /* argument usable by xOp */
-  volatile int opnum;      /* Operation number */
-  volatile int busy;       /* True if this thread is in use */
-
-  /* The next group of fields are writable by the client threads 
-  ** but read-only to the superviser thread.
-  */
-  volatile int completed;  /* Number of operations completed */
-  sqlite3 *db;             /* Open database */
-  sqlite3_stmt *pStmt;     /* Pending operation */
-  char *zErr;              /* operation error */
-  char *zStaticErr;        /* Static error message */
-  int rc;                  /* operation return code */
-  int argc;                /* number of columns in result */
-  const char *argv[100];   /* result columns */
-  const char *colv[100];   /* result column names */
-
-  /* Initialized to 1 by the supervisor thread when the client is 
-  ** created, and then deemed read-only to the supervisor thread. 
-  ** Is set to 0 by the server thread belonging to this client 
-  ** just before it exits.  
-  */
-  int nServer;             /* Number of server threads running */
-};
-
-/*
-** There can be as many as 26 threads running at once.  Each is named
-** by a capital letter: A, B, C, ..., Y, Z.
-*/
-#define N_THREAD 26
-static Thread threadset[N_THREAD];
-
-/*
-** The main loop for a thread.  Threads use busy waiting. 
-*/
-static void *client_main(void *pArg){
-  Thread *p = (Thread*)pArg;
-  if( p->db ){
-    sqlite3_client_close(p->db);
-  }
-  sqlite3_client_open(p->zFilename, &p->db);
-  if( SQLITE_OK!=sqlite3_errcode(p->db) ){
-    p->zErr = strdup(sqlite3_errmsg(p->db));
-    sqlite3_client_close(p->db);
-    p->db = 0;
-  }
-  p->pStmt = 0;
-  p->completed = 1;
-  while( p->opnum<=p->completed ) sched_yield();
-  while( p->xOp ){
-    if( p->zErr && p->zErr!=p->zStaticErr ){
-      sqlite3_free(p->zErr);
-      p->zErr = 0;
-    }
-    (*p->xOp)(p);
-    p->completed++;
-    while( p->opnum<=p->completed ) sched_yield();
-  }
-  if( p->pStmt ){
-    sqlite3_client_finalize(p->pStmt);
-    p->pStmt = 0;
-  }
-  if( p->db ){
-    sqlite3_client_close(p->db);
-    p->db = 0;
-  }
-  if( p->zErr && p->zErr!=p->zStaticErr ){
-    sqlite3_free(p->zErr);
-    p->zErr = 0;
-  }
-  p->completed++;
-#ifndef SQLITE_OMIT_DEPRECATED
-  sqlite3_thread_cleanup();
-#endif
-  return 0;
-}
-
-/*
-** Get a thread ID which is an upper case letter.  Return the index.
-** If the argument is not a valid thread ID put an error message in
-** the interpreter and return -1.
-*/
-static int parse_client_id(Tcl_Interp *interp, const char *zArg){
-  if( zArg==0 || zArg[0]==0 || zArg[1]!=0 || !isupper((unsigned char)zArg[0]) ){
-    Tcl_AppendResult(interp, "thread ID must be an upper case letter", 0);
-    return -1;
-  }
-  return zArg[0] - 'A';
-}
-
-/*
-** Usage:    client_create NAME  FILENAME
-**
-** NAME should be an upper case letter.  Start the thread running with
-** an open connection to the given database.
-*/
-static int SQLITE_TCLAPI tcl_client_create(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  pthread_t x;
-  int rc;
-
-  if( argc!=3 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID FILENAME", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( threadset[i].busy ){
-    Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);
-    return TCL_ERROR;
-  }
-  threadset[i].busy = 1;
-  sqlite3_free(threadset[i].zFilename);
-  threadset[i].zFilename = sqlite3_mprintf("%s", argv[2]);
-  threadset[i].opnum = 1;
-  threadset[i].completed = 0;
-  rc = pthread_create(&x, 0, client_main, &threadset[i]);
-  if( rc ){
-    Tcl_AppendResult(interp, "failed to create the thread", 0);
-    sqlite3_free(threadset[i].zFilename);
-    threadset[i].busy = 0;
-    return TCL_ERROR;
-  }
-  pthread_detach(x);
-  if( threadset[i].nServer==0 ){
-    threadset[i].nServer = 1;
-    sqlite3_server_start2(&threadset[i].nServer);
-  }
-  return TCL_OK;
-}
-
-/*
-** Wait for a thread to reach its idle state.
-*/
-static void client_wait(Thread *p){
-  while( p->opnum>p->completed ) sched_yield();
-}
-
-/*
-** Usage:  client_wait ID
-**
-** Wait on thread ID to reach its idle state.
-*/
-static int SQLITE_TCLAPI tcl_client_wait(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  return TCL_OK;
-}
-
-/*
-** Stop a thread.
-*/
-static void stop_thread(Thread *p){
-  client_wait(p);
-  p->xOp = 0;
-  p->opnum++;
-  client_wait(p);
-  sqlite3_free(p->zArg);
-  p->zArg = 0;
-  sqlite3_free(p->zFilename);
-  p->zFilename = 0;
-  p->busy = 0;
-}
-
-/*
-** Usage:  client_halt ID
-**
-** Cause a client thread to shut itself down.  Wait for the shutdown to be
-** completed.  If ID is "*" then stop all client threads.
-*/
-static int SQLITE_TCLAPI tcl_client_halt(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID", 0);
-    return TCL_ERROR;
-  }
-  if( argv[1][0]=='*' && argv[1][1]==0 ){
-    for(i=0; i<N_THREAD; i++){
-      if( threadset[i].busy ){
-        stop_thread(&threadset[i]);
-      }
-    }
-  }else{
-    i = parse_client_id(interp, argv[1]);
-    if( i<0 ) return TCL_ERROR;
-    if( !threadset[i].busy ){
-      Tcl_AppendResult(interp, "no such thread", 0);
-      return TCL_ERROR;
-    }
-    stop_thread(&threadset[i]);
-  }
-
-  /* If no client threads are still running, also stop the server */
-  for(i=0; i<N_THREAD && threadset[i].busy==0; i++){}
-  if( i>=N_THREAD ){
-    sqlite3_server_stop();
-    while( 1 ){
-      for(i=0; i<N_THREAD && threadset[i].nServer==0; i++);
-      if( i==N_THREAD ) break;
-      sched_yield();
-    }
-  }
-  return TCL_OK;
-}
-
-/*
-** Usage: client_argc  ID
-**
-** Wait on the most recent client_step to complete, then return the
-** number of columns in the result set.
-*/
-static int SQLITE_TCLAPI tcl_client_argc(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  char zBuf[100];
-
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", threadset[i].argc);
-  Tcl_AppendResult(interp, zBuf, 0);
-  return TCL_OK;
-}
-
-/*
-** Usage: client_argv  ID   N
-**
-** Wait on the most recent client_step to complete, then return the
-** value of the N-th columns in the result set.
-*/
-static int SQLITE_TCLAPI tcl_client_argv(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  int n;
-
-  if( argc!=3 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID N", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
-  client_wait(&threadset[i]);
-  if( n<0 || n>=threadset[i].argc ){
-    Tcl_AppendResult(interp, "column number out of range", 0);
-    return TCL_ERROR;
-  }
-  Tcl_AppendResult(interp, threadset[i].argv[n], 0);
-  return TCL_OK;
-}
-
-/*
-** Usage: client_colname  ID   N
-**
-** Wait on the most recent client_step to complete, then return the
-** name of the N-th columns in the result set.
-*/
-static int SQLITE_TCLAPI tcl_client_colname(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  int n;
-
-  if( argc!=3 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID N", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
-  client_wait(&threadset[i]);
-  if( n<0 || n>=threadset[i].argc ){
-    Tcl_AppendResult(interp, "column number out of range", 0);
-    return TCL_ERROR;
-  }
-  Tcl_AppendResult(interp, threadset[i].colv[n], 0);
-  return TCL_OK;
-}
-
-extern const char *sqlite3ErrName(int);
-
-/*
-** Usage: client_result  ID
-**
-** Wait on the most recent operation to complete, then return the
-** result code from that operation.
-*/
-static int SQLITE_TCLAPI tcl_client_result(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  const char *zName;
-
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  zName = sqlite3ErrName(threadset[i].rc);
-  Tcl_AppendResult(interp, zName, 0);
-  return TCL_OK;
-}
-
-/*
-** Usage: client_error  ID
-**
-** Wait on the most recent operation to complete, then return the
-** error string.
-*/
-static int SQLITE_TCLAPI tcl_client_error(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  Tcl_AppendResult(interp, threadset[i].zErr, 0);
-  return TCL_OK;
-}
-
-/*
-** This procedure runs in the thread to compile an SQL statement.
-*/
-static void do_compile(Thread *p){
-  if( p->db==0 ){
-    p->zErr = p->zStaticErr = "no database is open";
-    p->rc = SQLITE_ERROR;
-    return;
-  }
-  if( p->pStmt ){
-    sqlite3_client_finalize(p->pStmt);
-    p->pStmt = 0;
-  }
-  p->rc = sqlite3_client_prepare(p->db, p->zArg, -1, &p->pStmt, 0);
-}
-
-/*
-** Usage: client_compile ID SQL
-**
-** Compile a new virtual machine.
-*/
-static int SQLITE_TCLAPI tcl_client_compile(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  if( argc!=3 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID SQL", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  threadset[i].xOp = do_compile;
-  sqlite3_free(threadset[i].zArg);
-  threadset[i].zArg = sqlite3_mprintf("%s", argv[2]);
-  threadset[i].opnum++;
-  return TCL_OK;
-}
-
-/*
-** This procedure runs in the thread to step the virtual machine.
-*/
-static void do_step(Thread *p){
-  int i;
-  if( p->pStmt==0 ){
-    p->zErr = p->zStaticErr = "no virtual machine available";
-    p->rc = SQLITE_ERROR;
-    return;
-  }
-  p->rc = sqlite3_client_step(p->pStmt);
-  if( p->rc==SQLITE_ROW ){
-    p->argc = sqlite3_column_count(p->pStmt);
-    for(i=0; i<sqlite3_data_count(p->pStmt); i++){
-      p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);
-    }
-    for(i=0; i<p->argc; i++){
-      p->colv[i] = sqlite3_column_name(p->pStmt, i);
-    }
-  }
-}
-
-/*
-** Usage: client_step ID
-**
-** Advance the virtual machine by one step
-*/
-static int SQLITE_TCLAPI tcl_client_step(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " IDL", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  threadset[i].xOp = do_step;
-  threadset[i].opnum++;
-  return TCL_OK;
-}
-
-/*
-** This procedure runs in the thread to finalize a virtual machine.
-*/
-static void do_finalize(Thread *p){
-  if( p->pStmt==0 ){
-    p->zErr = p->zStaticErr = "no virtual machine available";
-    p->rc = SQLITE_ERROR;
-    return;
-  }
-  p->rc = sqlite3_client_finalize(p->pStmt);
-  p->pStmt = 0;
-}
-
-/*
-** Usage: client_finalize ID
-**
-** Finalize the virtual machine.
-*/
-static int SQLITE_TCLAPI tcl_client_finalize(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " IDL", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  threadset[i].xOp = do_finalize;
-  sqlite3_free(threadset[i].zArg);
-  threadset[i].zArg = 0;
-  threadset[i].opnum++;
-  return TCL_OK;
-}
-
-/*
-** This procedure runs in the thread to reset a virtual machine.
-*/
-static void do_reset(Thread *p){
-  if( p->pStmt==0 ){
-    p->zErr = p->zStaticErr = "no virtual machine available";
-    p->rc = SQLITE_ERROR;
-    return;
-  }
-  p->rc = sqlite3_client_reset(p->pStmt);
-  p->pStmt = 0;
-}
-
-/*
-** Usage: client_reset ID
-**
-** Finalize the virtual machine.
-*/
-static int SQLITE_TCLAPI tcl_client_reset(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i;
-  if( argc!=2 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " IDL", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  threadset[i].xOp = do_reset;
-  sqlite3_free(threadset[i].zArg);
-  threadset[i].zArg = 0;
-  threadset[i].opnum++;
-  return TCL_OK;
-}
-
-/*
-** Usage: client_swap ID ID
-**
-** Interchange the sqlite* pointer between two threads.
-*/
-static int SQLITE_TCLAPI tcl_client_swap(
-  void *NotUsed,
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int argc,              /* Number of arguments */
-  const char **argv      /* Text of each argument */
-){
-  int i, j;
-  sqlite3 *temp;
-  if( argc!=3 ){
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-       " ID1 ID2", 0);
-    return TCL_ERROR;
-  }
-  i = parse_client_id(interp, argv[1]);
-  if( i<0 ) return TCL_ERROR;
-  if( !threadset[i].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[i]);
-  j = parse_client_id(interp, argv[2]);
-  if( j<0 ) return TCL_ERROR;
-  if( !threadset[j].busy ){
-    Tcl_AppendResult(interp, "no such thread", 0);
-    return TCL_ERROR;
-  }
-  client_wait(&threadset[j]);
-  temp = threadset[i].db;
-  threadset[i].db = threadset[j].db;
-  threadset[j].db = temp;
-  return TCL_OK;
-}
-
-/*
-** Register commands with the TCL interpreter.
-*/
-int Sqlitetest7_Init(Tcl_Interp *interp){
-  static struct {
-     char *zName;
-     Tcl_CmdProc *xProc;
-  } aCmd[] = {
-     { "client_create",     (Tcl_CmdProc*)tcl_client_create     },
-     { "client_wait",       (Tcl_CmdProc*)tcl_client_wait       },
-     { "client_halt",       (Tcl_CmdProc*)tcl_client_halt       },
-     { "client_argc",       (Tcl_CmdProc*)tcl_client_argc       },
-     { "client_argv",       (Tcl_CmdProc*)tcl_client_argv       },
-     { "client_colname",    (Tcl_CmdProc*)tcl_client_colname    },
-     { "client_result",     (Tcl_CmdProc*)tcl_client_result     },
-     { "client_error",      (Tcl_CmdProc*)tcl_client_error      },
-     { "client_compile",    (Tcl_CmdProc*)tcl_client_compile    },
-     { "client_step",       (Tcl_CmdProc*)tcl_client_step       },
-     { "client_reset",      (Tcl_CmdProc*)tcl_client_reset      },
-     { "client_finalize",   (Tcl_CmdProc*)tcl_client_finalize   },
-     { "client_swap",       (Tcl_CmdProc*)tcl_client_swap       },
-  };
-  int i;
-
-  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
-    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
-  }
-  return TCL_OK;
-}
-#else
-int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; }
-#endif /* SQLITE_OS_UNIX */
diff --git a/src/test_server.c b/src/test_server.c
deleted file mode 100644
index 4eb1cf196..000000000
--- a/src/test_server.c
+++ /dev/null
@@ -1,516 +0,0 @@
-/*
-** 2006 January 07
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains demonstration code.  Nothing in this file gets compiled
-** or linked into the SQLite library unless you use a non-standard option:
-**
-**      -DSQLITE_SERVER=1
-**
-** The configure script will never generate a Makefile with the option
-** above.  You will need to manually modify the Makefile if you want to
-** include any of the code from this file in your project.  Or, at your
-** option, you may copy and paste the code from this file and
-** thereby avoiding a recompile of SQLite.
-**
-**
-** This source file demonstrates how to use SQLite to create an SQL database 
-** server thread in a multiple-threaded program.  One or more client threads
-** send messages to the server thread and the server thread processes those
-** messages in the order received and returns the results to the client.
-**
-** One might ask:  "Why bother?  Why not just let each thread connect
-** to the database directly?"  There are a several of reasons to
-** prefer the client/server approach.
-**
-**    (1)  Some systems (ex: Redhat9) have broken threading implementations
-**         that prevent SQLite database connections from being used in
-**         a thread different from the one where they were created.  With
-**         the client/server approach, all database connections are created
-**         and used within the server thread.  Client calls to the database
-**         can be made from multiple threads (though not at the same time!)
-**
-**    (2)  Beginning with SQLite version 3.3.0, when two or more 
-**         connections to the same database occur within the same thread,
-**         they can optionally share their database cache.  This reduces
-**         I/O and memory requirements.  Cache shared is controlled using
-**         the sqlite3_enable_shared_cache() API.
-**
-**    (3)  Database connections on a shared cache use table-level locking
-**         instead of file-level locking for improved concurrency.
-**
-**    (4)  Database connections on a shared cache can by optionally
-**         set to READ UNCOMMITTED isolation.  (The default isolation for
-**         SQLite is SERIALIZABLE.)  When this occurs, readers will
-**         never be blocked by a writer and writers will not be
-**         blocked by readers.  There can still only be a single writer
-**         at a time, but multiple readers can simultaneously exist with
-**         that writer.  This is a huge increase in concurrency.
-**
-** To summarize the rational for using a client/server approach: prior
-** to SQLite version 3.3.0 it probably was not worth the trouble.  But
-** with SQLite version 3.3.0 and beyond you can get significant performance
-** and concurrency improvements and memory usage reductions by going
-** client/server.
-**
-** Note:  The extra features of version 3.3.0 described by points (2)
-** through (4) above are only available if you compile without the
-** option -DSQLITE_OMIT_SHARED_CACHE. 
-**
-** Here is how the client/server approach works:  The database server
-** thread is started on this procedure:
-**
-**       void *sqlite3_server(void *NotUsed);
-**
-** The sqlite_server procedure runs as long as the g.serverHalt variable
-** is false.  A mutex is used to make sure no more than one server runs
-** at a time.  The server waits for messages to arrive on a message
-** queue and processes the messages in order.
-**
-** Two convenience routines are provided for starting and stopping the
-** server thread:
-**
-**       void sqlite3_server_start(void);
-**       void sqlite3_server_stop(void);
-**
-** Both of the convenience routines return immediately.  Neither will
-** ever give an error.  If a server is already started or already halted,
-** then the routines are effectively no-ops.
-**
-** Clients use the following interfaces:
-**
-**       sqlite3_client_open
-**       sqlite3_client_prepare
-**       sqlite3_client_step
-**       sqlite3_client_reset
-**       sqlite3_client_finalize
-**       sqlite3_client_close
-**
-** These interfaces work exactly like the standard core SQLite interfaces
-** having the same names without the "_client_" infix.  Many other SQLite
-** interfaces can be used directly without having to send messages to the
-** server as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.
-** The following interfaces fall into this second category:
-**
-**       sqlite3_bind_*
-**       sqlite3_changes
-**       sqlite3_clear_bindings
-**       sqlite3_column_*
-**       sqlite3_complete
-**       sqlite3_create_collation
-**       sqlite3_create_function
-**       sqlite3_data_count
-**       sqlite3_db_handle
-**       sqlite3_errcode
-**       sqlite3_errmsg
-**       sqlite3_last_insert_rowid
-**       sqlite3_total_changes
-**       sqlite3_transfer_bindings
-**
-** A single SQLite connection (an sqlite3* object) or an SQLite statement
-** (an sqlite3_stmt* object) should only be passed to a single interface
-** function at a time.  The connections and statements can be passed from
-** any thread to any of the functions listed in the second group above as
-** long as the same connection is not in use by two threads at once and
-** as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.  Additional
-** information about the SQLITE_ENABLE_MEMORY_MANAGEMENT constraint is
-** below.
-**
-** The busy handler for all database connections should remain turned
-** off.  That means that any lock contention will cause the associated
-** sqlite3_client_step() call to return immediately with an SQLITE_BUSY
-** error code.  If a busy handler is enabled and lock contention occurs,
-** then the entire server thread will block.  This will cause not only
-** the requesting client to block but every other database client as
-** well.  It is possible to enhance the code below so that lock
-** contention will cause the message to be placed back on the top of
-** the queue to be tried again later.  But such enhanced processing is
-** not included here, in order to keep the example simple.
-**
-** This example code assumes the use of pthreads.  Pthreads
-** implementations are available for windows.  (See, for example
-** http://sourceware.org/pthreads-win32/announcement.html.)  Or, you
-** can translate the locking and thread synchronization code to use
-** windows primitives easily enough.  The details are left as an
-** exercise to the reader.
-**
-**** Restrictions Associated With SQLITE_ENABLE_MEMORY_MANAGEMENT ****
-**
-** If you compile with SQLITE_ENABLE_MEMORY_MANAGEMENT defined, then
-** SQLite includes code that tracks how much memory is being used by
-** each thread.  These memory counts can become confused if memory
-** is allocated by one thread and then freed by another.  For that
-** reason, when SQLITE_ENABLE_MEMORY_MANAGEMENT is used, all operations
-** that might allocate or free memory should be performanced in the same
-** thread that originally created the database connection.  In that case,
-** many of the operations that are listed above as safe to be performed
-** in separate threads would need to be sent over to the server to be
-** done there.  If SQLITE_ENABLE_MEMORY_MANAGEMENT is defined, then
-** the following functions can be used safely from different threads
-** without messing up the allocation counts:
-**
-**       sqlite3_bind_parameter_name
-**       sqlite3_bind_parameter_index
-**       sqlite3_changes
-**       sqlite3_column_blob
-**       sqlite3_column_count
-**       sqlite3_complete
-**       sqlite3_data_count
-**       sqlite3_db_handle
-**       sqlite3_errcode
-**       sqlite3_errmsg
-**       sqlite3_last_insert_rowid
-**       sqlite3_total_changes
-**
-** The remaining functions are not thread-safe when memory management
-** is enabled.  So one would have to define some new interface routines
-** along the following lines:
-**
-**       sqlite3_client_bind_*
-**       sqlite3_client_clear_bindings
-**       sqlite3_client_column_*
-**       sqlite3_client_create_collation
-**       sqlite3_client_create_function
-**       sqlite3_client_transfer_bindings
-**
-** The example code in this file is intended for use with memory
-** management turned off.  So the implementation of these additional
-** client interfaces is left as an exercise to the reader.
-**
-** It may seem surprising to the reader that the list of safe functions
-** above does not include things like sqlite3_bind_int() or
-** sqlite3_column_int().  But those routines might, in fact, allocate
-** or deallocate memory.  In the case of sqlite3_bind_int(), if the
-** parameter was previously bound to a string that string might need
-** to be deallocated before the new integer value is inserted.  In
-** the case of sqlite3_column_int(), the value of the column might be
-** a UTF-16 string which will need to be converted to UTF-8 then into
-** an integer.
-*/
-
-/* Include this to get the definition of SQLITE_THREADSAFE, in the
-** case that default values are used.
-*/
-#include "sqliteInt.h"
-
-/*
-** Only compile the code in this file on UNIX with a SQLITE_THREADSAFE build
-** and only if the SQLITE_SERVER macro is defined.
-*/
-#if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE)
-#if SQLITE_OS_UNIX && SQLITE_THREADSAFE
-
-/*
-** We require only pthreads and the public interface of SQLite.
-*/
-#include <pthread.h>
-#include "sqlite3.h"
-
-/*
-** Messages are passed from client to server and back again as 
-** instances of the following structure.
-*/
-typedef struct SqlMessage SqlMessage;
-struct SqlMessage {
-  int op;                      /* Opcode for the message */
-  sqlite3 *pDb;                /* The SQLite connection */
-  sqlite3_stmt *pStmt;         /* A specific statement */
-  int errCode;                 /* Error code returned */
-  const char *zIn;             /* Input filename or SQL statement */
-  int nByte;                   /* Size of the zIn parameter for prepare() */
-  const char *zOut;            /* Tail of the SQL statement */
-  SqlMessage *pNext;           /* Next message in the queue */
-  SqlMessage *pPrev;           /* Previous message in the queue */
-  pthread_mutex_t clientMutex; /* Hold this mutex to access the message */
-  pthread_cond_t clientWakeup; /* Signal to wake up the client */
-};
-
-/*
-** Legal values for SqlMessage.op
-*/
-#define MSG_Open       1  /* sqlite3_open(zIn, &pDb) */
-#define MSG_Prepare    2  /* sqlite3_prepare(pDb, zIn, nByte, &pStmt, &zOut) */
-#define MSG_Step       3  /* sqlite3_step(pStmt) */
-#define MSG_Reset      4  /* sqlite3_reset(pStmt) */
-#define MSG_Finalize   5  /* sqlite3_finalize(pStmt) */
-#define MSG_Close      6  /* sqlite3_close(pDb) */
-#define MSG_Done       7  /* Server has finished with this message */
-
-
-/*
-** State information about the server is stored in a static variable
-** named "g" as follows:
-*/
-static struct ServerState {
-  pthread_mutex_t queueMutex;   /* Hold this mutex to access the msg queue */
-  pthread_mutex_t serverMutex;  /* Held by the server while it is running */
-  pthread_cond_t serverWakeup;  /* Signal this condvar to wake up the server */
-  volatile int serverHalt;      /* Server halts itself when true */
-  SqlMessage *pQueueHead;       /* Head of the message queue */
-  SqlMessage *pQueueTail;       /* Tail of the message queue */
-} g = {
-  PTHREAD_MUTEX_INITIALIZER,
-  PTHREAD_MUTEX_INITIALIZER,
-  PTHREAD_COND_INITIALIZER,
-};
-
-/*
-** Send a message to the server.  Block until we get a reply.
-**
-** The mutex and condition variable in the message are uninitialized
-** when this routine is called.  This routine takes care of 
-** initializing them and destroying them when it has finished.
-*/
-static void sendToServer(SqlMessage *pMsg){
-  /* Initialize the mutex and condition variable on the message
-  */
-  pthread_mutex_init(&pMsg->clientMutex, 0);
-  pthread_cond_init(&pMsg->clientWakeup, 0);
-
-  /* Add the message to the head of the server's message queue.
-  */
-  pthread_mutex_lock(&g.queueMutex);
-  pMsg->pNext = g.pQueueHead;
-  if( g.pQueueHead==0 ){
-    g.pQueueTail = pMsg;
-  }else{
-    g.pQueueHead->pPrev = pMsg;
-  }
-  pMsg->pPrev = 0;
-  g.pQueueHead = pMsg;
-  pthread_mutex_unlock(&g.queueMutex);
-
-  /* Signal the server that the new message has be queued, then
-  ** block waiting for the server to process the message.
-  */
-  pthread_mutex_lock(&pMsg->clientMutex);
-  pthread_cond_signal(&g.serverWakeup);
-  while( pMsg->op!=MSG_Done ){
-    pthread_cond_wait(&pMsg->clientWakeup, &pMsg->clientMutex);
-  }
-  pthread_mutex_unlock(&pMsg->clientMutex);
-
-  /* Destroy the mutex and condition variable of the message.
-  */
-  pthread_mutex_destroy(&pMsg->clientMutex);
-  pthread_cond_destroy(&pMsg->clientWakeup);
-}
-
-/*
-** The following 6 routines are client-side implementations of the
-** core SQLite interfaces:
-**
-**        sqlite3_open
-**        sqlite3_prepare
-**        sqlite3_step
-**        sqlite3_reset
-**        sqlite3_finalize
-**        sqlite3_close
-**
-** Clients should use the following client-side routines instead of 
-** the core routines above.
-**
-**        sqlite3_client_open
-**        sqlite3_client_prepare
-**        sqlite3_client_step
-**        sqlite3_client_reset
-**        sqlite3_client_finalize
-**        sqlite3_client_close
-**
-** Each of these routines creates a message for the desired operation,
-** sends that message to the server, waits for the server to process
-** then message and return a response.
-*/
-int sqlite3_client_open(const char *zDatabaseName, sqlite3 **ppDb){
-  SqlMessage msg;
-  msg.op = MSG_Open;
-  msg.zIn = zDatabaseName;
-  sendToServer(&msg);
-  *ppDb = msg.pDb;
-  return msg.errCode;
-}
-int sqlite3_client_prepare(
-  sqlite3 *pDb,
-  const char *zSql,
-  int nByte,
-  sqlite3_stmt **ppStmt,
-  const char **pzTail
-){
-  SqlMessage msg;
-  msg.op = MSG_Prepare;
-  msg.pDb = pDb;
-  msg.zIn = zSql;
-  msg.nByte = nByte;
-  sendToServer(&msg);
-  *ppStmt = msg.pStmt;
-  if( pzTail ) *pzTail = msg.zOut;
-  return msg.errCode;
-}
-int sqlite3_client_step(sqlite3_stmt *pStmt){
-  SqlMessage msg;
-  msg.op = MSG_Step;
-  msg.pStmt = pStmt;
-  sendToServer(&msg);
-  return msg.errCode;
-}
-int sqlite3_client_reset(sqlite3_stmt *pStmt){
-  SqlMessage msg;
-  msg.op = MSG_Reset;
-  msg.pStmt = pStmt;
-  sendToServer(&msg);
-  return msg.errCode;
-}
-int sqlite3_client_finalize(sqlite3_stmt *pStmt){
-  SqlMessage msg;
-  msg.op = MSG_Finalize;
-  msg.pStmt = pStmt;
-  sendToServer(&msg);
-  return msg.errCode;
-}
-int sqlite3_client_close(sqlite3 *pDb){
-  SqlMessage msg;
-  msg.op = MSG_Close;
-  msg.pDb = pDb;
-  sendToServer(&msg);
-  return msg.errCode;
-}
-
-/*
-** This routine implements the server.  To start the server, first
-** make sure g.serverHalt is false, then create a new detached thread
-** on this procedure.  See the sqlite3_server_start() routine below
-** for an example.  This procedure loops until g.serverHalt becomes
-** true.
-*/
-void *sqlite3_server(void *NotUsed){
-  if( pthread_mutex_trylock(&g.serverMutex) ){
-    return 0;  /* Another server is already running */
-  }
-  sqlite3_enable_shared_cache(1);
-  while( !g.serverHalt ){
-    SqlMessage *pMsg;
-
-    /* Remove the last message from the message queue.
-    */
-    pthread_mutex_lock(&g.queueMutex);
-    while( g.pQueueTail==0 && g.serverHalt==0 ){
-      pthread_cond_wait(&g.serverWakeup, &g.queueMutex);
-    }
-    pMsg = g.pQueueTail;
-    if( pMsg ){
-      if( pMsg->pPrev ){
-        pMsg->pPrev->pNext = 0;
-      }else{
-        g.pQueueHead = 0;
-      }
-      g.pQueueTail = pMsg->pPrev;
-    }
-    pthread_mutex_unlock(&g.queueMutex);
-    if( pMsg==0 ) break;
-
-    /* Process the message just removed
-    */
-    pthread_mutex_lock(&pMsg->clientMutex);
-    switch( pMsg->op ){
-      case MSG_Open: {
-        pMsg->errCode = sqlite3_open(pMsg->zIn, &pMsg->pDb);
-        break;
-      }
-      case MSG_Prepare: {
-        pMsg->errCode = sqlite3_prepare(pMsg->pDb, pMsg->zIn, pMsg->nByte,
-                                        &pMsg->pStmt, &pMsg->zOut);
-        break;
-      }
-      case MSG_Step: {
-        pMsg->errCode = sqlite3_step(pMsg->pStmt);
-        break;
-      }
-      case MSG_Reset: {
-        pMsg->errCode = sqlite3_reset(pMsg->pStmt);
-        break;
-      }
-      case MSG_Finalize: {
-        pMsg->errCode = sqlite3_finalize(pMsg->pStmt);
-        break;
-      }
-      case MSG_Close: {
-        pMsg->errCode = sqlite3_close(pMsg->pDb);
-        break;
-      }
-    }
-
-    /* Signal the client that the message has been processed.
-    */
-    pMsg->op = MSG_Done;
-    pthread_mutex_unlock(&pMsg->clientMutex);
-    pthread_cond_signal(&pMsg->clientWakeup);
-  }
-  pthread_mutex_unlock(&g.serverMutex);
-  return 0;
-}
-
-/*
-** Start a server thread if one is not already running.  If there
-** is aleady a server thread running, the new thread will quickly
-** die and this routine is effectively a no-op.
-*/
-void sqlite3_server_start(void){
-  pthread_t x;
-  int rc;
-  g.serverHalt = 0;
-  rc = pthread_create(&x, 0, sqlite3_server, 0);
-  if( rc==0 ){
-    pthread_detach(x);
-  }
-}
-
-/*
-** A wrapper around sqlite3_server() that decrements the int variable
-** pointed to by the first argument after the sqlite3_server() call
-** returns.
-*/
-static void *serverWrapper(void *pnDecr){
-  void *p = sqlite3_server(0);
-  (*(int*)pnDecr)--;
-  return p;
-}
-
-/*
-** This function is the similar to sqlite3_server_start(), except that
-** the integer pointed to by the first argument is decremented when
-** the server thread exits. 
-*/
-void sqlite3_server_start2(int *pnDecr){
-  pthread_t x;
-  int rc;
-  g.serverHalt = 0;
-  rc = pthread_create(&x, 0, serverWrapper, (void*)pnDecr);
-  if( rc==0 ){
-    pthread_detach(x);
-  }
-}
-
-/*
-** If a server thread is running, then stop it.  If no server is
-** running, this routine is effectively a no-op.
-**
-** This routine waits until the server has actually stopped before
-** returning.
-*/
-void sqlite3_server_stop(void){
-  g.serverHalt = 1;
-  pthread_cond_broadcast(&g.serverWakeup);
-  pthread_mutex_lock(&g.serverMutex);
-  pthread_mutex_unlock(&g.serverMutex);
-}
-
-#endif /* SQLITE_OS_UNIX && SQLITE_THREADSAFE */
-#endif /* defined(SQLITE_SERVER) */
diff --git a/src/test_tclsh.c b/src/test_tclsh.c
index c133deca2..32aee4267 100644
--- a/src/test_tclsh.c
+++ b/src/test_tclsh.c
@@ -64,7 +64,6 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
   extern int Sqlitetest4_Init(Tcl_Interp*);
   extern int Sqlitetest5_Init(Tcl_Interp*);
   extern int Sqlitetest6_Init(Tcl_Interp*);
-  extern int Sqlitetest7_Init(Tcl_Interp*);
   extern int Sqlitetest8_Init(Tcl_Interp*);
   extern int Sqlitetest9_Init(Tcl_Interp*);
   extern int Sqlitetestasync_Init(Tcl_Interp*);
@@ -136,7 +135,6 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
   Sqlitetest4_Init(interp);
   Sqlitetest5_Init(interp);
   Sqlitetest6_Init(interp);
-  Sqlitetest7_Init(interp);
   Sqlitetest8_Init(interp);
   Sqlitetest9_Init(interp);
   Sqlitetestasync_Init(interp);
diff --git a/src/test_thread.c b/src/test_thread.c
index de0fdb434..126fd9836 100644
--- a/src/test_thread.c
+++ b/src/test_thread.c
@@ -384,6 +384,27 @@ static int SQLITE_TCLAPI clock_seconds_proc(
   return TCL_OK;
 }
 
+/*
+** The [clock_milliseconds] command. This is more or less the same as the
+** regular tcl [clock milliseconds]. 
+*/ 
+static int SQLITE_TCLAPI clock_milliseconds_proc(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Tcl_Time now;
+  Tcl_GetTime(&now);
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj(
+    ((Tcl_WideInt)now.sec * 1000) + (now.usec / 1000)
+  ));
+  UNUSED_PARAMETER(clientData);
+  UNUSED_PARAMETER(objc);
+  UNUSED_PARAMETER(objv);
+  return TCL_OK;
+}
+
 /*************************************************************************
 ** This block contains the implementation of the [sqlite3_blocking_step]
 ** command available to threads created by [sqlthread spawn] commands. It
@@ -617,15 +638,26 @@ static int SQLITE_TCLAPI blocking_prepare_v2_proc(
 ** Register commands with the TCL interpreter.
 */
 int SqlitetestThread_Init(Tcl_Interp *interp){
-  Tcl_CreateObjCommand(interp, "sqlthread", sqlthread_proc, 0, 0);
-  Tcl_CreateObjCommand(interp, "clock_seconds", clock_seconds_proc, 0, 0);
+  struct TclCmd {
+    int (*xProc)(void*, Tcl_Interp*, int, Tcl_Obj*const*);
+    const char *zName;
+    int iCtx;
+  } aCmd[] = {
+    { sqlthread_proc,           "sqlthread",                      0 },
+    { clock_seconds_proc,       "clock_second",                   0 },
+    { clock_milliseconds_proc,  "clock_milliseconds",             0 },
 #if SQLITE_OS_UNIX && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
-  Tcl_CreateObjCommand(interp, "sqlite3_blocking_step", blocking_step_proc,0,0);
-  Tcl_CreateObjCommand(interp, 
-      "sqlite3_blocking_prepare_v2", blocking_prepare_v2_proc, (void *)1, 0);
-  Tcl_CreateObjCommand(interp, 
-      "sqlite3_nonblocking_prepare_v2", blocking_prepare_v2_proc, 0, 0);
+    { blocking_step_proc,       "sqlite3_blocking_step",          0 },
+    { blocking_prepare_v2_proc, "sqlite3_blocking_prepare_v2",    1 },
+    { blocking_prepare_v2_proc, "sqlite3_nonblocking_prepare_v2", 0 },
 #endif
+  };
+  int ii;
+
+  for(ii=0; ii<sizeof(aCmd)/sizeof(aCmd[0]); ii++){
+    void *p = SQLITE_INT_TO_PTR(aCmd[ii].iCtx);
+    Tcl_CreateObjCommand(interp, aCmd[ii].zName, aCmd[ii].xProc, p, 0);
+  }
   return TCL_OK;
 }
 #else
diff --git a/src/test_vfs.c b/src/test_vfs.c
index f3e8297ac..312e1a1be 100644
--- a/src/test_vfs.c
+++ b/src/test_vfs.c
@@ -485,6 +485,9 @@ static int tvfsLock(sqlite3_file *pFile, int eLock){
     tvfsExecTcl(p, "xLock", Tcl_NewStringObj(pFd->zFilename, -1), 
                    Tcl_NewStringObj(zLock, -1), 0, 0);
   }
+  if( p->mask&TESTVFS_LOCK_MASK && tvfsInjectIoerr(p) ){
+    return SQLITE_IOERR_LOCK;
+  }
   return sqlite3OsLock(pFd->pReal, eLock);
 }
 
@@ -500,7 +503,7 @@ static int tvfsUnlock(sqlite3_file *pFile, int eLock){
     tvfsExecTcl(p, "xUnlock", Tcl_NewStringObj(pFd->zFilename, -1), 
                    Tcl_NewStringObj(zLock, -1), 0, 0);
   }
-  if( p->mask&TESTVFS_WRITE_MASK && tvfsInjectIoerr(p) ){
+  if( p->mask&TESTVFS_UNLOCK_MASK && tvfsInjectIoerr(p) ){
     return SQLITE_IOERR_UNLOCK;
   }
   return sqlite3OsUnlock(pFd->pReal, eLock);
diff --git a/src/treeview.c b/src/treeview.c
index 9df16a12b..9f630b156 100644
--- a/src/treeview.c
+++ b/src/treeview.c
@@ -218,6 +218,13 @@ void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
     if( pItem->fg.isOn || (pItem->fg.isUsing==0 && pItem->u3.pOn!=0) ){
       sqlite3_str_appendf(&x, " ON");
     }
+    if( pItem->fg.isTabFunc )      sqlite3_str_appendf(&x, " isTabFunc");
+    if( pItem->fg.isCorrelated )   sqlite3_str_appendf(&x, " isCorrelated");
+    if( pItem->fg.isMaterialized ) sqlite3_str_appendf(&x, " isMaterialized");
+    if( pItem->fg.viaCoroutine )   sqlite3_str_appendf(&x, " viaCoroutine");
+    if( pItem->fg.notCte )         sqlite3_str_appendf(&x, " notCte");
+    if( pItem->fg.isNestedFrom )   sqlite3_str_appendf(&x, " isNestedFrom");
+
     sqlite3StrAccumFinish(&x);
     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
     n = 0;
diff --git a/src/vdbemem.c b/src/vdbemem.c
index d9909decc..d415f9f72 100644
--- a/src/vdbemem.c
+++ b/src/vdbemem.c
@@ -1508,8 +1508,6 @@ static int valueFromFunction(
     goto value_from_function_out;
   }
 
-  testcase( pCtx->pParse->rc==SQLITE_ERROR );
-  testcase( pCtx->pParse->rc==SQLITE_OK );
   memset(&ctx, 0, sizeof(ctx));
   ctx.pOut = pVal;
   ctx.pFunc = pFunc;
@@ -1521,11 +1519,14 @@ static int valueFromFunction(
   }else{
     sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
     assert( rc==SQLITE_OK );
+    assert( enc==pVal->enc || db->mallocFailed );
+#if 0  /* Not reachable except after a prior failure */
     rc = sqlite3VdbeChangeEncoding(pVal, enc);
     if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){
       rc = SQLITE_TOOBIG;
       pCtx->pParse->nErr++;
     }
+#endif
   }
   pCtx->pParse->rc = rc;
 
diff --git a/src/where.c b/src/where.c
index 6a9edd028..df2a13b66 100644
--- a/src/where.c
+++ b/src/where.c
@@ -3595,7 +3595,8 @@ static int whereLoopAddBtree(
         if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
           pNew->rSetup += 28;
         }else{
-          pNew->rSetup -= 10;
+          pNew->rSetup -= 25;  /* Greatly reduced setup cost for auto indexes
+                               ** on ephemeral materializations of views */
         }
         ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
         if( pNew->rSetup<0 ) pNew->rSetup = 0;
@@ -5595,24 +5596,23 @@ static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful(
   const WhereInfo *pWInfo
 ){
   int i;
-  LogEst nSearch;
+  LogEst nSearch = 0;
 
   assert( pWInfo->nLevel>=2 );
   assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) );
-  nSearch = pWInfo->a[0].pWLoop->nOut;
-  for(i=1; i<pWInfo->nLevel; i++){
+  for(i=0; i<pWInfo->nLevel; i++){
     WhereLoop *pLoop = pWInfo->a[i].pWLoop;
     const unsigned int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ);
-    if( (pLoop->wsFlags & reqFlags)==reqFlags
+    SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];
+    Table *pTab = pItem->pTab;
+    if( (pTab->tabFlags & TF_HasStat1)==0 ) break;
+    pTab->tabFlags |= TF_StatsUsed;
+    if( i>=1
+     && (pLoop->wsFlags & reqFlags)==reqFlags
      /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */
      && ALWAYS((pLoop->wsFlags & (WHERE_IPK|WHERE_INDEXED))!=0)
     ){
-      SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];
-      Table *pTab = pItem->pTab;
-      pTab->tabFlags |= TF_StatsUsed;
-      if( nSearch > pTab->nRowLogEst
-       && (pTab->tabFlags & TF_HasStat1)!=0
-      ){
+      if( nSearch > pTab->nRowLogEst ){
         testcase( pItem->fg.jointype & JT_LEFT );
         pLoop->wsFlags |= WHERE_BLOOMFILTER;
         pLoop->wsFlags &= ~WHERE_IDX_ONLY;
diff --git a/src/window.c b/src/window.c
index 8dd35ee30..56de38ba3 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1079,6 +1079,7 @@ int sqlite3WindowRewrite(Parse *pParse, Select *p){
     if( p->pSrc ){
       Table *pTab2;
       p->pSrc->a[0].pSelect = pSub;
+      p->pSrc->a[0].fg.isCorrelated = 1;
       sqlite3SrcListAssignCursors(pParse, p->pSrc);
       pSub->selFlags |= SF_Expanded|SF_OrderByReqd;
       pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);