diff --git a/Makefile.in b/Makefile.in
index 2c91b8252d..4dfe381af4 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -345,8 +345,8 @@ SRC += \
   $(TOP)/ext/rtree/rtree.h \
   $(TOP)/ext/rtree/rtree.c
 SRC += \
-  $(TOP)/ext/ota/sqlite3ota.h \
-  $(TOP)/ext/ota/sqlite3ota.c
+  $(TOP)/ext/rbu/sqlite3rbu.h \
+  $(TOP)/ext/rbu/sqlite3rbu.c
 
 
 # Generated source code files
@@ -404,7 +404,7 @@ TESTSRC = \
   $(TOP)/src/test_wsd.c       \
   $(TOP)/ext/fts3/fts3_term.c \
   $(TOP)/ext/fts3/fts3_test.c \
-  $(TOP)/ext/ota/test_ota.c 
+  $(TOP)/ext/rbu/test_rbu.c 
 
 # Statically linked extensions
 #
@@ -1039,15 +1039,18 @@ soaktest:	$(TESTPROGS)
 	./testfixture$(TEXE) $(TOP)/test/all.test -soak=1 $(TESTOPTS)
 
 # Do extra testing but not everything.
-fulltestonly:	$(TESTPROGS)
+fulltestonly:	$(TESTPROGS) fuzztest
 	./testfixture$(TEXE) $(TOP)/test/full.test
 
 # Fuzz testing
 fuzztest:	fuzzcheck$(TEXE) $(FUZZDATA)
 	./fuzzcheck$(TEXE) $(FUZZDATA)
 
+fastfuzztest:	fuzzcheck$(TEXE) $(FUZZDATA)
+	./fuzzcheck$(TEXE) --limit-mem 100M $(FUZZDATA)
+
 valgrindfuzz:	fuzzcheck$(TEXT) $(FUZZDATA)
-	valgrind ./fuzzcheck$(TEXE) --cell-size-check --quiet $(FUZZDATA)
+	valgrind ./fuzzcheck$(TEXE) --cell-size-check --limit-mem 10M $(FUZZDATA)
 
 # Minimal testing that runs in less than 3 minutes
 #
@@ -1057,7 +1060,7 @@ quicktest:	./testfixture$(TEXE)
 # This is the common case.  Run many tests that do not take too long,
 # including fuzzcheck, sqlite3_analyzer, and sqldiff tests.
 #
-test:	$(TESTPROGS) fuzztest
+test:	$(TESTPROGS) fastfuzztest
 	./testfixture$(TEXE) $(TOP)/test/veryquick.test $(TESTOPTS)
 
 # Run a test using valgrind.  This can take a really long time
@@ -1192,7 +1195,7 @@ clean:
 	rm -f fts5.* fts5parse.*
 
 distclean:	clean
-	rm -f config.log config.status libtool Makefile sqlite3.pc
+	rm -f config.h config.log config.status libtool Makefile sqlite3.pc
 
 #
 # Windows section
diff --git a/Makefile.msc b/Makefile.msc
index ed6e58e949..0e1fedee67 100644
--- a/Makefile.msc
+++ b/Makefile.msc
@@ -1007,8 +1007,8 @@ SRC4 = \
   $(TOP)\ext\icu\icu.c \
   $(TOP)\ext\rtree\rtree.h \
   $(TOP)\ext\rtree\rtree.c \
-  $(TOP)\ext\ota\sqlite3ota.h \
-  $(TOP)\ext\ota\sqlite3ota.c
+  $(TOP)\ext\rbu\sqlite3rbu.h \
+  $(TOP)\ext\rbu\sqlite3rbu.c
 
 
 # Generated source code files
@@ -1069,7 +1069,7 @@ TESTSRC = \
   $(TOP)\src\test_wsd.c \
   $(TOP)\ext\fts3\fts3_term.c \
   $(TOP)\ext\fts3\fts3_test.c \
-  $(TOP)\ext\ota\test_ota.c
+  $(TOP)\ext\rbu\test_rbu.c
 
 # Statically linked extensions
 #
@@ -1738,6 +1738,9 @@ queryplantest:	testfixture.exe sqlite3.exe
 fuzztest:	fuzzcheck.exe
 	.\fuzzcheck.exe $(FUZZDATA)
 
+fastfuzztest:	fuzzcheck.exe
+	.\fuzzcheck.exe --limit-mem 100M $(FUZZDATA)
+
 # Minimal testing that runs in less than 3 minutes (on a fast machine)
 #
 quicktest:	testfixture.exe
@@ -1746,7 +1749,7 @@ quicktest:	testfixture.exe
 # This is the common case.  Run many tests that do not take too long,
 # including fuzzcheck, sqlite3_analyzer, and sqldiff tests.
 #
-test:	$(TESTPROGS) fuzztest
+test:	$(TESTPROGS) fastfuzztest
 	.\testfixture.exe $(TOP)\test\veryquick.test $(TESTOPTS)
 
 smoketest:	$(TESTPROGS)
diff --git a/autoconf/tea/Makefile.in b/autoconf/tea/Makefile.in
index a8708974b0..3e481dadfe 100644
--- a/autoconf/tea/Makefile.in
+++ b/autoconf/tea/Makefile.in
@@ -348,7 +348,7 @@ clean:
 distclean: clean
 	-rm -f *.tab.c
 	-rm -f $(CONFIG_CLEAN_FILES)
-	-rm -f config.cache config.log config.status
+	-rm -f config.h config.cache config.log config.status
 
 #========================================================================
 # Install binary object libraries.  On Windows this includes both .dll and
diff --git a/ext/fts3/fts3.c b/ext/fts3/fts3.c
index 903d7d84fd..6a9b507fc0 100644
--- a/ext/fts3/fts3.c
+++ b/ext/fts3/fts3.c
@@ -4231,7 +4231,6 @@ static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
   int bIncrOk = (bOptOk 
    && pCsr->bDesc==pTab->bDescIdx 
    && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
-   && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
 #ifdef SQLITE_TEST
    && pTab->bNoIncrDoclist==0
 #endif
diff --git a/ext/fts5/fts5_expr.c b/ext/fts5/fts5_expr.c
index 97ff3c72a0..861b20863a 100644
--- a/ext/fts5/fts5_expr.c
+++ b/ext/fts5/fts5_expr.c
@@ -60,7 +60,7 @@ struct Fts5ExprNode {
   /* Child nodes. For a NOT node, this array always contains 2 entries. For 
   ** AND or OR nodes, it contains 2 or more entries.  */
   int nChild;                     /* Number of child nodes */
-  Fts5ExprNode *apChild[0];       /* Array of child nodes */
+  Fts5ExprNode *apChild[1];       /* Array of child nodes */
 };
 
 #define Fts5NodeIsString(p) ((p)->eType==FTS5_TERM || (p)->eType==FTS5_STRING)
@@ -1619,7 +1619,7 @@ Fts5ExprNode *sqlite3Fts5ParseNode(
       if( pRight->eType==eType ) nChild += pRight->nChild-1;
     }
 
-    nByte = sizeof(Fts5ExprNode) + sizeof(Fts5ExprNode*)*nChild;
+    nByte = sizeof(Fts5ExprNode) + sizeof(Fts5ExprNode*)*(nChild-1);
     pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
 
     if( pRet ){
diff --git a/ext/fts5/fts5_index.c b/ext/fts5/fts5_index.c
index f3384bb5cb..065df4fac1 100644
--- a/ext/fts5/fts5_index.c
+++ b/ext/fts5/fts5_index.c
@@ -3690,13 +3690,13 @@ static void fts5IndexMergeLevel(
       fts5MultiIterEof(p, pIter)==0;
       fts5MultiIterNext(p, pIter, 0, 0)
   ){
-    Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
+    Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
     int nPos;                     /* position-list size field value */
     int nTerm;
     const u8 *pTerm;
 
     /* Check for key annihilation. */
-    if( pSeg->nPos==0 && (bOldest || pSeg->bDel==0) ) continue;
+    if( pSegIter->nPos==0 && (bOldest || pSegIter->bDel==0) ) continue;
 
     pTerm = fts5MultiIterTerm(pIter, &nTerm);
     if( nTerm!=term.n || memcmp(pTerm, term.p, nTerm) ){
@@ -3715,11 +3715,11 @@ static void fts5IndexMergeLevel(
 
     /* Append the rowid to the output */
     /* WRITEPOSLISTSIZE */
-    nPos = pSeg->nPos*2 + pSeg->bDel;
+    nPos = pSegIter->nPos*2 + pSegIter->bDel;
     fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter), nPos);
 
     /* Append the position-list data to the output */
-    fts5ChunkIterate(p, pSeg, (void*)&writer, fts5MergeChunkCallback);
+    fts5ChunkIterate(p, pSegIter, (void*)&writer, fts5MergeChunkCallback);
   }
 
   /* Flush the last leaf page to disk. Set the output segment b-tree height
diff --git a/ext/ota/ota.c b/ext/rbu/rbu.c
similarity index 63%
rename from ext/ota/ota.c
rename to ext/rbu/rbu.c
index fffc1267bd..dd46743def 100644
--- a/ext/ota/ota.c
+++ b/ext/rbu/rbu.c
@@ -10,11 +10,11 @@
 **
 *************************************************************************
 **
-** This file contains a command-line application that uses the OTA 
+** This file contains a command-line application that uses the RBU 
 ** extension. See the usage() function below for an explanation.
 */
 
-#include "sqlite3ota.h"
+#include "sqlite3rbu.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -24,18 +24,18 @@
 */
 void usage(const char *zArgv0){
   fprintf(stderr, 
-"Usage: %s [-step NSTEP] TARGET-DB OTA-DB\n"
+"Usage: %s [-step NSTEP] TARGET-DB RBU-DB\n"
 "\n"
-"  Argument OTA-DB must be an OTA database containing an update suitable for\n"
+"  Argument RBU-DB must be an RBU database containing an update suitable for\n"
 "  target database TARGET-DB. If NSTEP is set to less than or equal to zero\n"
 "  (the default value), this program attempts to apply the entire update to\n"
 "  the target database.\n"
 "\n"
 "  If NSTEP is greater than zero, then a maximum of NSTEP calls are made\n"
-"  to sqlite3ota_step(). If the OTA update has not been completely applied\n"
-"  after the NSTEP'th call is made, the state is saved in the database OTA-DB\n"
-"  and the program exits. Subsequent invocations of this (or any other OTA)\n"
-"  application will use this state to resume applying the OTA update to the\n"
+"  to sqlite3rbu_step(). If the RBU update has not been completely applied\n"
+"  after the NSTEP'th call is made, the state is saved in the database RBU-DB\n"
+"  and the program exits. Subsequent invocations of this (or any other RBU)\n"
+"  application will use this state to resume applying the RBU update to the\n"
 "  target db.\n"
 "\n"
 , zArgv0);
@@ -47,8 +47,8 @@ void report_default_vfs(){
   fprintf(stdout, "default vfs is \"%s\"\n", pVfs->zName);
 }
 
-void report_ota_vfs(sqlite3ota *pOta){
-  sqlite3 *db = sqlite3ota_db(pOta, 0);
+void report_rbu_vfs(sqlite3rbu *pRbu){
+  sqlite3 *db = sqlite3rbu_db(pRbu, 0);
   if( db ){
     char *zName = 0;
     sqlite3_file_control(db, "main", SQLITE_FCNTL_VFSNAME, &zName);
@@ -63,16 +63,17 @@ void report_ota_vfs(sqlite3ota *pOta){
 
 int main(int argc, char **argv){
   int i;
-  const char *zTarget;            /* Target database to apply OTA to */
-  const char *zOta;               /* Database containing OTA */
+  const char *zTarget;            /* Target database to apply RBU to */
+  const char *zRbu;               /* Database containing RBU */
+  char zBuf[200];                 /* Buffer for printf() */
   char *zErrmsg;                  /* Error message, if any */
-  sqlite3ota *pOta;               /* OTA handle */
+  sqlite3rbu *pRbu;               /* RBU handle */
   int nStep = 0;                  /* Maximum number of step() calls */
   int rc;
   sqlite3_int64 nProgress = 0;
 
   /* Process command line arguments. Following this block local variables 
-  ** zTarget, zOta and nStep are all set. */
+  ** zTarget, zRbu and nStep are all set. */
   if( argc==5 ){
     int nArg1 = strlen(argv[1]);
     if( nArg1>5 || nArg1<2 || memcmp("-step", argv[1], nArg1) ) usage(argv[0]);
@@ -81,34 +82,36 @@ int main(int argc, char **argv){
     usage(argv[0]);
   }
   zTarget = argv[argc-2];
-  zOta = argv[argc-1];
+  zRbu = argv[argc-1];
 
   report_default_vfs();
 
-  /* Open an OTA handle. If nStep is less than or equal to zero, call
-  ** sqlite3ota_step() until either the OTA has been completely applied
+  /* Open an RBU handle. If nStep is less than or equal to zero, call
+  ** sqlite3rbu_step() until either the RBU has been completely applied
   ** or an error occurs. Or, if nStep is greater than zero, call
-  ** sqlite3ota_step() a maximum of nStep times.  */
-  pOta = sqlite3ota_open(zTarget, zOta, 0);
-  report_ota_vfs(pOta);
-  for(i=0; (nStep<=0 || i<nStep) && sqlite3ota_step(pOta)==SQLITE_OK; i++);
-  nProgress = sqlite3ota_progress(pOta);
-  rc = sqlite3ota_close(pOta, &zErrmsg);
+  ** sqlite3rbu_step() a maximum of nStep times.  */
+  pRbu = sqlite3rbu_open(zTarget, zRbu, 0);
+  report_rbu_vfs(pRbu);
+  for(i=0; (nStep<=0 || i<nStep) && sqlite3rbu_step(pRbu)==SQLITE_OK; i++);
+  nProgress = sqlite3rbu_progress(pRbu);
+  rc = sqlite3rbu_close(pRbu, &zErrmsg);
 
   /* Let the user know what happened. */
   switch( rc ){
     case SQLITE_OK:
-      fprintf(stdout, 
-          "SQLITE_OK: ota update incomplete (%lld operations so far)\n",
+      sqlite3_snprintf(sizeof(zBuf), zBuf,
+          "SQLITE_OK: rbu update incomplete (%lld operations so far)\n",
           nProgress
       );
+      fprintf(stdout, zBuf);
       break;
 
     case SQLITE_DONE:
-      fprintf(stdout, 
-          "SQLITE_DONE: ota update completed (%lld operations)\n",
+      sqlite3_snprintf(sizeof(zBuf), zBuf,
+          "SQLITE_DONE: rbu update completed (%lld operations)\n",
           nProgress
       );
+      fprintf(stdout, zBuf);
       break;
 
     default:
diff --git a/ext/ota/ota1.test b/ext/rbu/rbu1.test
similarity index 71%
rename from ext/ota/ota1.test
rename to ext/rbu/rbu1.test
index 97fd2a3f95..19b3d27a9f 100644
--- a/ext/ota/ota1.test
+++ b/ext/rbu/rbu1.test
@@ -14,128 +14,128 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota1
+set ::testprefix rbu1
 
 db close
 sqlite3_shutdown
 sqlite3_config_uri 1
 
-# Create a simple OTA database. That expects to write to a table:
+# Create a simple RBU database. That expects to write to a table:
 #
 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 #
-proc create_ota1 {filename} {
+proc create_rbu1 {filename} {
   forcedelete $filename
-  sqlite3 ota1 $filename  
-  ota1 eval {
-    CREATE TABLE data_t1(a, b, c, ota_control);
+  sqlite3 rbu1 $filename  
+  rbu1 eval {
+    CREATE TABLE data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(1, 2, 3, 0);
     INSERT INTO data_t1 VALUES(2, 'two', 'three', 0);
     INSERT INTO data_t1 VALUES(3, NULL, 8.2, 0);
   }
-  ota1 close
+  rbu1 close
   return $filename
 }
 
-# Create a simple OTA database. That expects to write to a table:
+# Create a simple RBU database. That expects to write to a table:
 #
 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 #
-# This OTA includes both insert and delete operations.
+# This RBU includes both insert and delete operations.
 #
-proc create_ota4 {filename} {
+proc create_rbu4 {filename} {
   forcedelete $filename
-  sqlite3 ota1 $filename  
-  ota1 eval {
-    CREATE TABLE data_t1(a, b, c, ota_control);
+  sqlite3 rbu1 $filename  
+  rbu1 eval {
+    CREATE TABLE data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(1, 2, 3, 0);
     INSERT INTO data_t1 VALUES(2, NULL, 5, 1);
     INSERT INTO data_t1 VALUES(3, 8, 9, 0);
     INSERT INTO data_t1 VALUES(4, NULL, 11, 1);
   }
-  ota1 close
+  rbu1 close
   return $filename
 }
 #
-# Create a simple OTA database. That expects to write to a table:
+# Create a simple RBU database. That expects to write to a table:
 #
 #   CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
 #
-# This OTA includes both insert and delete operations.
+# This RBU includes both insert and delete operations.
 #
-proc create_ota4b {filename} {
+proc create_rbu4b {filename} {
   forcedelete $filename
-  sqlite3 ota1 $filename  
-  ota1 eval {
-    CREATE TABLE data_t1(c, b, '(a)', ota_control);
+  sqlite3 rbu1 $filename  
+  rbu1 eval {
+    CREATE TABLE data_t1(c, b, '(a)', rbu_control);
     INSERT INTO data_t1 VALUES(3, 2, 1, 0);
     INSERT INTO data_t1 VALUES(5, NULL, 2, 1);
     INSERT INTO data_t1 VALUES(9, 8, 3, 0);
     INSERT INTO data_t1 VALUES(11, NULL, 4, 1);
   }
-  ota1 close
+  rbu1 close
   return $filename
 }
 
-# Create a simple OTA database. That expects to write to a table:
+# Create a simple RBU database. That expects to write to a table:
 #
 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
 #
-# This OTA includes update statements.
+# This RBU includes update statements.
 #
-proc create_ota5 {filename} {
+proc create_rbu5 {filename} {
   forcedelete $filename
-  sqlite3 ota5 $filename  
-  ota5 eval {
-    CREATE TABLE data_t1(a, b, c, d, ota_control);
+  sqlite3 rbu5 $filename  
+  rbu5 eval {
+    CREATE TABLE data_t1(a, b, c, d, rbu_control);
     INSERT INTO data_t1 VALUES(1, NULL, NULL, 5, '...x');  -- SET d = 5
     INSERT INTO data_t1 VALUES(2, NULL, 10, 5, '..xx');    -- SET c=10, d = 5
     INSERT INTO data_t1 VALUES(3, 11, NULL, NULL, '.x..'); -- SET b=11
   }
-  ota5 close
+  rbu5 close
   return $filename
 }
 
-# Run the OTA in file $ota on target database $target until completion.
+# Run the RBU in file $rbu on target database $target until completion.
 #
-proc run_ota {target ota} {
-  sqlite3ota ota $target $ota
+proc run_rbu {target rbu} {
+  sqlite3rbu rbu $target $rbu
   while 1 {
-    set rc [ota step]
+    set rc [rbu step]
     if {$rc!="SQLITE_OK"} break
   }
-  ota close
+  rbu close
 }
 
-proc step_ota {target ota} {
+proc step_rbu {target rbu} {
   while 1 {
-    sqlite3ota ota $target $ota
-    set rc [ota step]
-    ota close
+    sqlite3rbu rbu $target $rbu
+    set rc [rbu step]
+    rbu close
     if {$rc != "SQLITE_OK"} break
   }
   set rc
 }
 
-# Same as [step_ota], except using a URI to open the target db.
+# Same as [step_rbu], except using a URI to open the target db.
 #
-proc step_ota_uri {target ota} {
+proc step_rbu_uri {target rbu} {
   while 1 {
-    sqlite3ota ota file:$target?xyz=&abc=123 $ota
-    set rc [ota step]
-    ota close
+    sqlite3rbu rbu file:$target?xyz=&abc=123 $rbu
+    set rc [rbu step]
+    rbu close
     if {$rc != "SQLITE_OK"} break
   }
   set rc
 }
 
-# Same as [step_ota], except using an external state database - "state.db"
+# Same as [step_rbu], except using an external state database - "state.db"
 #
-proc step_ota_state {target ota} {
+proc step_rbu_state {target rbu} {
   while 1 {
-    sqlite3ota ota $target $ota state.db
-    set rc [ota step]
-    ota close
+    sqlite3rbu rbu $target $rbu state.db
+    set rc [rbu step]
+    rbu close
     if {$rc != "SQLITE_OK"} break
   }
   set rc
@@ -151,17 +151,17 @@ proc dbfilecksum {file} {
 foreach {tn3 create_vfs destroy_vfs} {
   1 {} {}
   2 {
-    sqlite3ota_create_vfs -default myota ""
+    sqlite3rbu_create_vfs -default myrbu ""
   } {
-    sqlite3ota_destroy_vfs myota
+    sqlite3rbu_destroy_vfs myrbu
   }
 } {
 
   eval $create_vfs
 
   foreach {tn2 cmd} {
-      1 run_ota 
-      2 step_ota 3 step_ota_uri 4 step_ota_state
+      1 run_rbu 
+      2 step_rbu 3 step_rbu_uri 4 step_rbu_state
   } {
     foreach {tn schema} {
       1 {
@@ -240,12 +240,12 @@ foreach {tn3 create_vfs destroy_vfs} {
     } {
       reset_db
       execsql $schema
-      create_ota1 ota.db
-      set check [dbfilecksum ota.db]
+      create_rbu1 rbu.db
+      set check [dbfilecksum rbu.db]
       forcedelete state.db
 
       do_test $tn3.1.$tn2.$tn.1 {
-        $cmd test.db ota.db
+        $cmd test.db rbu.db
       } {SQLITE_DONE}
 
       do_execsql_test $tn3.1.$tn2.$tn.2 { SELECT * FROM t1 ORDER BY a ASC } {
@@ -266,51 +266,51 @@ foreach {tn3 create_vfs destroy_vfs} {
    
       do_execsql_test $tn3.1.$tn2.$tn.5 { PRAGMA integrity_check } ok
 
-      if {$cmd=="step_ota_state"} {
+      if {$cmd=="step_rbu_state"} {
         do_test $tn3.1.$tn2.$tn.6 { file exists state.db } 1
-        do_test $tn3.1.$tn2.$tn.7 { expr {$check == [dbfilecksum ota.db]} } 1
+        do_test $tn3.1.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 1
       } else {
         do_test $tn3.1.$tn2.$tn.8 { file exists state.db } 0
-        do_test $tn3.1.$tn2.$tn.9 { expr {$check == [dbfilecksum ota.db]} } 0
+        do_test $tn3.1.$tn2.$tn.9 { expr {$check == [dbfilecksum rbu.db]} } 0
       }
     }
   }
 
   #-------------------------------------------------------------------------
-  # Check that an OTA cannot be applied to a table that has no PK.
+  # Check that an RBU cannot be applied to a table that has no PK.
   #
-  # UPDATE: At one point OTA required that all tables featured either
+  # UPDATE: At one point RBU required that all tables featured either
   # explicit IPK columns or were declared WITHOUT ROWID. This has been
   # relaxed so that external PRIMARY KEYs on tables with automatic rowids
   # are now allowed.
   #
   # UPDATE 2: Tables without any PRIMARY KEY declaration are now allowed.
-  # However the input table must feature an "ota_rowid" column.
+  # However the input table must feature an "rbu_rowid" column.
   #
   reset_db
-  create_ota1 ota.db
+  create_rbu1 rbu.db
   do_execsql_test $tn3.2.1 { CREATE TABLE t1(a, b, c) }
   do_test $tn3.2.2 {
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_ERROR}
   do_test $tn3.2.3 {
-    list [catch { ota close } msg] $msg
-  } {1 {SQLITE_ERROR - table data_t1 requires ota_rowid column}}
+    list [catch { rbu close } msg] $msg
+  } {1 {SQLITE_ERROR - table data_t1 requires rbu_rowid column}}
   reset_db
   do_execsql_test $tn3.2.4 { CREATE TABLE t1(a PRIMARY KEY, b, c) }
   do_test $tn3.2.5 {
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_OK}
   do_test $tn3.2.6 {
-    list [catch { ota close } msg] $msg
+    list [catch { rbu close } msg] $msg
   } {0 SQLITE_OK}
 
   #-------------------------------------------------------------------------
   # Check that if a UNIQUE constraint is violated the current and all 
-  # subsequent [ota step] calls return SQLITE_CONSTRAINT. And that the OTA 
-  # transaction is rolled back by the [ota close] that deletes the ota 
+  # subsequent [rbu step] calls return SQLITE_CONSTRAINT. And that the RBU 
+  # transaction is rolled back by the [rbu close] that deletes the rbu 
   # handle.
   #
   foreach {tn errcode errmsg schema} {
@@ -340,16 +340,16 @@ foreach {tn3 create_vfs destroy_vfs} {
     set cksum [dbcksum db main]
 
     do_test $tn3.3.$tn.1 {
-      create_ota1 ota.db
-      sqlite3ota ota test.db ota.db
-      while {[set res [ota step]]=="SQLITE_OK"} {}
+      create_rbu1 rbu.db
+      sqlite3rbu rbu test.db rbu.db
+      while {[set res [rbu step]]=="SQLITE_OK"} {}
       set res
     } $errcode
 
-    do_test $tn3.3.$tn.2 { ota step } $errcode
+    do_test $tn3.3.$tn.2 { rbu step } $errcode
 
     do_test $tn3.3.$tn.3 { 
-      list [catch { ota close } msg] $msg
+      list [catch { rbu close } msg] $msg
     } [list 1 "$errcode - $errmsg"]
 
     do_test $tn3.3.$tn.4 { dbcksum db main } $cksum
@@ -357,7 +357,7 @@ foreach {tn3 create_vfs destroy_vfs} {
 
   #-------------------------------------------------------------------------
   #
-  foreach {tn2 cmd} {1 run_ota 2 step_ota 3 step_ota_state } {
+  foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state } {
     foreach {tn schema} {
       1 {
         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
@@ -406,12 +406,12 @@ foreach {tn3 create_vfs destroy_vfs} {
         INSERT INTO t1 VALUES(6, 'hello', 'xyz');
       }
 
-      create_ota4 ota.db
-      set check [dbfilecksum ota.db]
+      create_rbu4 rbu.db
+      set check [dbfilecksum rbu.db]
       forcedelete state.db
     
       do_test $tn3.4.$tn2.$tn.1 {
-        $cmd test.db ota.db
+        $cmd test.db rbu.db
       } {SQLITE_DONE}
       
       do_execsql_test $tn3.4.$tn2.$tn.2 {
@@ -424,17 +424,17 @@ foreach {tn3 create_vfs destroy_vfs} {
     
       do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
 
-      if {$cmd=="step_ota_state"} {
+      if {$cmd=="step_rbu_state"} {
         do_test $tn3.4.$tn2.$tn.4 { file exists state.db } 1
-        do_test $tn3.4.$tn2.$tn.5 { expr {$check == [dbfilecksum ota.db]} } 1
+        do_test $tn3.4.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
       } else {
         do_test $tn3.4.$tn2.$tn.6 { file exists state.db } 0
-        do_test $tn3.4.$tn2.$tn.7 { expr {$check == [dbfilecksum ota.db]} } 0
+        do_test $tn3.4.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
       }
     }
   }
 
-  foreach {tn2 cmd} {1 run_ota 2 step_ota 3 step_ota_state} {
+  foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
     foreach {tn schema} {
       1 {
         CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
@@ -455,12 +455,12 @@ foreach {tn3 create_vfs destroy_vfs} {
         INSERT INTO t1('(a)', b, c) VALUES(6, 'hello', 'xyz');
       }
 
-      create_ota4b ota.db
-      set check [dbfilecksum ota.db]
+      create_rbu4b rbu.db
+      set check [dbfilecksum rbu.db]
       forcedelete state.db
     
       do_test $tn3.5.$tn2.$tn.1 {
-        $cmd test.db ota.db
+        $cmd test.db rbu.db
       } {SQLITE_DONE}
       
       do_execsql_test $tn3.5.$tn2.$tn.2 {
@@ -473,19 +473,19 @@ foreach {tn3 create_vfs destroy_vfs} {
     
       do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
 
-      if {$cmd=="step_ota_state"} {
+      if {$cmd=="step_rbu_state"} {
         do_test $tn3.5.$tn2.$tn.4 { file exists state.db } 1
-        do_test $tn3.5.$tn2.$tn.5 { expr {$check == [dbfilecksum ota.db]} } 1
+        do_test $tn3.5.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
       } else {
         do_test $tn3.5.$tn2.$tn.6 { file exists state.db } 0
-        do_test $tn3.5.$tn2.$tn.7 { expr {$check == [dbfilecksum ota.db]} } 0
+        do_test $tn3.5.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
       }
     }
   }
 
   #-------------------------------------------------------------------------
   #
-  foreach {tn2 cmd} {1 run_ota 2 step_ota 3 step_ota_state} {
+  foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
     foreach {tn schema} {
       1 {
         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
@@ -526,12 +526,12 @@ foreach {tn3 create_vfs destroy_vfs} {
         INSERT INTO t1 VALUES(3, 8, 9, 10);
       }
     
-      create_ota5 ota.db
-      set check [dbfilecksum ota.db]
+      create_rbu5 rbu.db
+      set check [dbfilecksum rbu.db]
       forcedelete state.db
 
       do_test $tn3.5.$tn2.$tn.1 {
-        $cmd test.db ota.db
+        $cmd test.db rbu.db
       } {SQLITE_DONE}
       
       do_execsql_test $tn3.5.$tn2.$tn.2 {
@@ -544,12 +544,12 @@ foreach {tn3 create_vfs destroy_vfs} {
     
       do_execsql_test $tn3.6.$tn2.$tn.3 { PRAGMA integrity_check } ok
 
-      if {$cmd=="step_ota_state"} {
+      if {$cmd=="step_rbu_state"} {
         do_test $tn3.6.$tn2.$tn.4 { file exists state.db } 1
-        do_test $tn3.6.$tn2.$tn.5 { expr {$check == [dbfilecksum ota.db]} } 1
+        do_test $tn3.6.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
       } else {
         do_test $tn3.6.$tn2.$tn.6 { file exists state.db } 0
-        do_test $tn3.6.$tn2.$tn.7 { expr {$check == [dbfilecksum ota.db]} } 0
+        do_test $tn3.6.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
       }
     }
   }
@@ -557,9 +557,9 @@ foreach {tn3 create_vfs destroy_vfs} {
   #-------------------------------------------------------------------------
   # Test some error cases:
   # 
-  #   * A virtual table with no ota_rowid column.
-  #   * A no-PK table with no ota_rowid column.
-  #   * A PK table with an ota_rowid column.
+  #   * A virtual table with no rbu_rowid column.
+  #   * A no-PK table with no rbu_rowid column.
+  #   * A PK table with an rbu_rowid column.
   #
   #   6: An update string of the wrong length
   #
@@ -567,88 +567,88 @@ foreach {tn3 create_vfs destroy_vfs} {
     foreach {tn schema error} {
        1 {
          CREATE TABLE t1(a, b);
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-       } {SQLITE_ERROR - table data_t1 requires ota_rowid column}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+       } {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
     
        2 {
          CREATE VIRTUAL TABLE t1 USING fts4(a, b);
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-       } {SQLITE_ERROR - table data_t1 requires ota_rowid column}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+       } {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
     
        3 {
          CREATE TABLE t1(a PRIMARY KEY, b);
-         CREATE TABLE ota.data_t1(a, b, ota_rowid, ota_control);
-       } {SQLITE_ERROR - table data_t1 may not have ota_rowid column}
+         CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
+       } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
     
        4 {
          CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
-         CREATE TABLE ota.data_t1(a, b, ota_rowid, ota_control);
-       } {SQLITE_ERROR - table data_t1 may not have ota_rowid column}
+         CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
+       } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
     
        5 {
          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
-         CREATE TABLE ota.data_t1(a, b, ota_rowid, ota_control);
-       } {SQLITE_ERROR - table data_t1 may not have ota_rowid column}
+         CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
+       } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
 
        6 {
          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-         INSERT INTO ota.data_t1 VALUES(1, 2, 'x.x');
-       } {SQLITE_ERROR - invalid ota_control value}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+         INSERT INTO rbu.data_t1 VALUES(1, 2, 'x.x');
+       } {SQLITE_ERROR - invalid rbu_control value}
 
        7 {
          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-         INSERT INTO ota.data_t1 VALUES(1, 2, NULL);
-       } {SQLITE_ERROR - invalid ota_control value}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+         INSERT INTO rbu.data_t1 VALUES(1, 2, NULL);
+       } {SQLITE_ERROR - invalid rbu_control value}
 
        8 {
          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-         INSERT INTO ota.data_t1 VALUES(1, 2, 4);
-       } {SQLITE_ERROR - invalid ota_control value}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+         INSERT INTO rbu.data_t1 VALUES(1, 2, 4);
+       } {SQLITE_ERROR - invalid rbu_control value}
 
        9 {
          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-         INSERT INTO ota.data_t1 VALUES(1, 2, 2);
-       } {SQLITE_ERROR - invalid ota_control value}
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+         INSERT INTO rbu.data_t1 VALUES(1, 2, 2);
+       } {SQLITE_ERROR - invalid rbu_control value}
 
        10 {
          CREATE TABLE t2(a, b);
-         CREATE TABLE ota.data_t1(a, b, ota_control);
-         INSERT INTO ota.data_t1 VALUES(1, 2, 2);
+         CREATE TABLE rbu.data_t1(a, b, rbu_control);
+         INSERT INTO rbu.data_t1 VALUES(1, 2, 2);
        } {SQLITE_ERROR - no such table: t1}
 
        11 {
-         CREATE TABLE ota.data_t2(a, b, ota_control);
-         INSERT INTO ota.data_t2 VALUES(1, 2, 2);
+         CREATE TABLE rbu.data_t2(a, b, rbu_control);
+         INSERT INTO rbu.data_t2 VALUES(1, 2, 2);
        } {SQLITE_ERROR - no such table: t2}
 
     } {
       reset_db
-      forcedelete ota.db
-      execsql { ATTACH 'ota.db' AS ota }
+      forcedelete rbu.db
+      execsql { ATTACH 'rbu.db' AS rbu }
       execsql $schema
 
       do_test $tn3.7.$tn {
-        list [catch { run_ota test.db ota.db } msg] $msg
+        list [catch { run_rbu test.db rbu.db } msg] $msg
       } [list 1 $error]
     }
   }
 
-  # Test that an OTA database containing no input tables is handled
+  # Test that an RBU database containing no input tables is handled
   # correctly.
   reset_db
-  forcedelete ota.db
+  forcedelete rbu.db
   do_test $tn3.8 {
-    list [catch { run_ota test.db ota.db } msg] $msg
+    list [catch { run_rbu test.db rbu.db } msg] $msg
   } {0 SQLITE_DONE}
   
-  # Test that OTA can update indexes containing NULL values.
+  # Test that RBU can update indexes containing NULL values.
   #
   reset_db
-  forcedelete ota.db
+  forcedelete rbu.db
   do_execsql_test $tn3.9.1 {
     CREATE TABLE t1(a PRIMARY KEY, b, c);
     CREATE INDEX i1 ON t1(b, c);
@@ -656,14 +656,14 @@ foreach {tn3 create_vfs destroy_vfs} {
     INSERT INTO t1 VALUES(2, NULL, 2);
     INSERT INTO t1 VALUES(3, NULL, NULL);
 
-    ATTACH 'ota.db' AS ota;
-    CREATE TABLE ota.data_t1(a, b, c, ota_control);
+    ATTACH 'rbu.db' AS rbu;
+    CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(1, NULL, NULL, 1);
     INSERT INTO data_t1 VALUES(3, NULL, NULL, 1);
   } {}
 
   do_test $tn3.9.2 {
-    list [catch { run_ota test.db ota.db } msg] $msg
+    list [catch { run_rbu test.db rbu.db } msg] $msg
   } {0 SQLITE_DONE}
 
   do_execsql_test $tn3.9.3 {
diff --git a/ext/ota/ota10.test b/ext/rbu/rbu10.test
similarity index 81%
rename from ext/ota/ota10.test
rename to ext/rbu/rbu10.test
index 52cc27a8f6..04aab00a0d 100644
--- a/ext/ota/ota10.test
+++ b/ext/rbu/rbu10.test
@@ -14,7 +14,7 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota10
+set ::testprefix rbu10
 
 
 #--------------------------------------------------------------------
@@ -26,19 +26,19 @@ do_execsql_test 1.0 {
   INSERT INTO t1 VALUES(1, 'b', 'c');
 }
 
-proc apply_ota {sql} {
-  forcedelete ota.db
-  sqlite3 db2 ota.db
+proc apply_rbu {sql} {
+  forcedelete rbu.db
+  sqlite3 db2 rbu.db
   db2 eval $sql
   db2 close
-  sqlite3ota ota test.db ota.db
-  while { [ota step]=="SQLITE_OK" } {}
-  ota close
+  sqlite3rbu rbu test.db rbu.db
+  while { [rbu step]=="SQLITE_OK" } {}
+  rbu close
 }
 
 do_test 1.1 {
-  apply_ota {
-    CREATE TABLE data_t1(a, c, b, ota_control);
+  apply_rbu {
+    CREATE TABLE data_t1(a, c, b, rbu_control);
     INSERT INTO data_t1 VALUES(1, 'xxx', NULL, '.x.');
   }
   db eval { SELECT * FROM t1 }
@@ -53,8 +53,8 @@ ifcapable fts3 {
     CREATE VIRTUAL TABLE ft USING fts4(a, b, languageid='langid');
   }
   do_test 2.1 {
-    apply_ota {
-      CREATE TABLE data_ft(a, b, ota_rowid, langid, ota_control);
+    apply_rbu {
+      CREATE TABLE data_ft(a, b, rbu_rowid, langid, rbu_control);
       INSERT INTO data_ft VALUES('a', 'b', 22, 1, 0);    -- insert
       INSERT INTO data_ft VALUES('a', 'b', 23, 10, 0);   -- insert
       INSERT INTO data_ft VALUES('a', 'b', 24, 100, 0);  -- insert
@@ -70,8 +70,8 @@ ifcapable fts3 {
   # defaults to 0.
   #
   do_test 2.2 {
-    apply_ota {
-      CREATE TABLE data_ft(a, b, ota_rowid, ota_control);
+    apply_rbu {
+      CREATE TABLE data_ft(a, b, rbu_rowid, rbu_control);
       INSERT INTO data_ft VALUES('a', 'b', 25, 0);    -- insert
     }
     db eval { SELECT a, b, rowid, langid FROM ft }
@@ -85,8 +85,8 @@ ifcapable fts3 {
   # Update langid.
   #
   do_test 2.3 {
-    apply_ota {
-      CREATE TABLE data_ft(a, b, ota_rowid, langid, ota_control);
+    apply_rbu {
+      CREATE TABLE data_ft(a, b, rbu_rowid, langid, rbu_control);
       INSERT INTO data_ft VALUES(NULL, NULL, 23, 50, '..x');
       INSERT INTO data_ft VALUES(NULL, NULL, 25, 500, '..x');
     }
@@ -101,7 +101,7 @@ ifcapable fts3 {
 
 #--------------------------------------------------------------------
 # Test that if writing a hidden virtual table column is an error, 
-# attempting to do so via ota is also an error.
+# attempting to do so via rbu is also an error.
 #
 ifcapable fts3 {
   do_execsql_test 3.0 {
@@ -109,8 +109,8 @@ ifcapable fts3 {
   }
   do_test 3.1 {
     list [catch {
-      apply_ota {
-        CREATE TABLE data_xt(a, xt, ota_rowid, ota_control);
+      apply_rbu {
+        CREATE TABLE data_xt(a, xt, rbu_rowid, rbu_control);
         INSERT INTO data_xt VALUES('a', 'b', 1, 0);
       }
     } msg] $msg
@@ -119,7 +119,7 @@ ifcapable fts3 {
 
 #--------------------------------------------------------------------
 # Test that it is not possible to violate a NOT NULL constraint by
-# applying an OTA update.
+# applying an RBU update.
 #
 do_execsql_test 4.1 {
   CREATE TABLE t2(a INTEGER NOT NULL, b TEXT NOT NULL, c PRIMARY KEY);
@@ -131,7 +131,7 @@ do_execsql_test 4.1 {
   INSERT INTO t4 VALUES(10, 10);
 }
 
-foreach {tn error ota} {
+foreach {tn error rbu} {
   2 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t2.a} {
     INSERT INTO data_t2 VALUES(NULL, 'abc', 1, 0);
   }
@@ -163,24 +163,24 @@ foreach {tn error ota} {
     INSERT INTO data_t3 VALUES(1, 'abc', 'text', 0);
   }
 } {
-  set ota "
-    CREATE TABLE data_t2(a, b, c, ota_control);
-    CREATE TABLE data_t3(a, b, c, ota_control);
-    CREATE TABLE data_t4(a, b, ota_control);
-    $ota
+  set rbu "
+    CREATE TABLE data_t2(a, b, c, rbu_control);
+    CREATE TABLE data_t3(a, b, c, rbu_control);
+    CREATE TABLE data_t4(a, b, rbu_control);
+    $rbu
   "
   do_test 4.2.$tn {
-    list [catch { apply_ota $ota } msg] $msg
+    list [catch { apply_rbu $rbu } msg] $msg
   } [list 1 $error]
 }
 
 do_test 4.3 {
-  set ota {
-    CREATE TABLE data_t3(a, b, c, ota_control);
+  set rbu {
+    CREATE TABLE data_t3(a, b, c, rbu_control);
     INSERT INTO data_t3 VALUES(1, 'abc', '5', 0);
     INSERT INTO data_t3 VALUES(1, 'abc', '-6.0', 0);
   }
-  list [catch { apply_ota $ota } msg] $msg
+  list [catch { apply_rbu $rbu } msg] $msg
 } {0 SQLITE_DONE}
 
 
diff --git a/ext/ota/ota11.test b/ext/rbu/rbu11.test
similarity index 64%
rename from ext/ota/ota11.test
rename to ext/rbu/rbu11.test
index 6bd233c0c0..fdc701aceb 100644
--- a/ext/ota/ota11.test
+++ b/ext/rbu/rbu11.test
@@ -14,17 +14,17 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota11
+set ::testprefix rbu11
 
 
 #--------------------------------------------------------------------
-# Test that the xAccess() method of an ota vfs handles queries other
+# Test that the xAccess() method of an rbu vfs handles queries other
 # than SQLITE_ACCESS_EXISTS correctly. The test code below causes
 # SQLite to call xAccess(SQLITE_ACCESS_READWRITE) on the directory
 # path argument passed to "PRAGMA temp_store_directory".
 #
 do_test 1.1 {
-  sqlite3ota_create_vfs -default ota ""
+  sqlite3rbu_create_vfs -default rbu ""
   reset_db
   catchsql { PRAGMA temp_store_directory = '/no/such/directory' }
 } {1 {not a writable directory}}
@@ -39,11 +39,11 @@ do_test 1.3 {
 
 do_test 1.4 {
   db close
-  sqlite3ota_destroy_vfs ota
+  sqlite3rbu_destroy_vfs rbu
 } {}
 
 #--------------------------------------------------------------------
-# Try to trick ota into operating on a database opened in wal mode.
+# Try to trick rbu into operating on a database opened in wal mode.
 #
 reset_db
 do_execsql_test 2.1 {
@@ -57,10 +57,10 @@ do_test 2.2 {
   db_save 
   db close
 
-  forcedelete ota.db
-  sqlite3 dbo ota.db
+  forcedelete rbu.db
+  sqlite3 dbo rbu.db
   dbo eval {
-    CREATE TABLE data_t1(a, b, c, ota_control);
+    CREATE TABLE data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(4, 5, 6, 0);
     INSERT INTO data_t1 VALUES(7, 8, 9, 0);
   }
@@ -72,12 +72,12 @@ do_test 2.2 {
 } {1}
 
 do_test 2.3 {
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_ERROR}
 
 do_test 2.4 {
-  list [catch {ota close} msg] $msg
+  list [catch {rbu close} msg] $msg
 } {1 {SQLITE_ERROR - cannot update wal mode database}}
 
 #--------------------------------------------------------------------
@@ -94,26 +94,26 @@ do_execsql_test 3.1 {
 db close
 
 do_test 3.2 {
-  forcedelete ota.db
-  sqlite3 dbo ota.db
+  forcedelete rbu.db
+  sqlite3 dbo rbu.db
   dbo eval {
-    CREATE TABLE "data_(t1)"(a, b, c, ota_control);
+    CREATE TABLE "data_(t1)"(a, b, c, rbu_control);
     INSERT INTO "data_(t1)" VALUES(4, 8, 9, 0);
   }
   dbo close
 
-  sqlite3ota ota test.db ota.db
-  ota step
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
+  rbu step
 } {SQLITE_CONSTRAINT}
 
 do_test 3.3 {
-  list [catch {ota close} msg] $msg
+  list [catch {rbu close} msg] $msg
 } {1 {SQLITE_CONSTRAINT - UNIQUE constraint failed: (t1).a}}
 
 #--------------------------------------------------------------------
-# Check that once an OTA update has been applied, attempting to apply
-# it a second time is a no-op (as the state stored in the OTA database is
+# Check that once an RBU update has been applied, attempting to apply
+# it a second time is a no-op (as the state stored in the RBU database is
 # "all steps completed").
 #
 reset_db
@@ -125,74 +125,74 @@ do_execsql_test 4.1 {
 db close
 
 do_test 4.2 {
-  forcedelete ota.db
-  sqlite3 dbo ota.db
+  forcedelete rbu.db
+  sqlite3 dbo rbu.db
   dbo eval {
-    CREATE TABLE "data_(t1)"(a, b, c, ota_control);
+    CREATE TABLE "data_(t1)"(a, b, c, rbu_control);
     INSERT INTO "data_(t1)" VALUES(7, 8, 9, 0);
     INSERT INTO "data_(t1)" VALUES(1, 2, 3, 1);
   }
   dbo close
 
-  sqlite3ota ota test.db ota.db
-  while {[ota step]=="SQLITE_OK"} { }
-  ota close
+  sqlite3rbu rbu test.db rbu.db
+  while {[rbu step]=="SQLITE_OK"} { }
+  rbu close
 } {SQLITE_DONE}
 
 do_test 4.3 {
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_DONE}
 
 do_test 4.4 {
-  ota close
+  rbu close
 } {SQLITE_DONE}
 
 do_test 4.5.1 {
-  sqlite3 dbo ota.db
-  dbo eval { INSERT INTO ota_state VALUES(100, 100) }
+  sqlite3 dbo rbu.db
+  dbo eval { INSERT INTO rbu_state VALUES(100, 100) }
   dbo close
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_CORRUPT}
 do_test 4.5.2 {
-  list [catch {ota close} msg] $msg
+  list [catch {rbu close} msg] $msg
 } {1 SQLITE_CORRUPT}
 do_test 4.5.3 {
-  sqlite3 dbo ota.db
-  dbo eval { DELETE FROM ota_state WHERE k = 100 }
+  sqlite3 dbo rbu.db
+  dbo eval { DELETE FROM rbu_state WHERE k = 100 }
   dbo close 
 } {}
 
-# Also, check that an invalid state value in the ota_state table is
+# Also, check that an invalid state value in the rbu_state table is
 # detected and reported as corruption.
 do_test 4.6.1 {
-  sqlite3 dbo ota.db
-  dbo eval { UPDATE ota_state SET v = v*-1 WHERE k = 1 }
+  sqlite3 dbo rbu.db
+  dbo eval { UPDATE rbu_state SET v = v*-1 WHERE k = 1 }
   dbo close
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_CORRUPT}
 do_test 4.6.2 {
-  list [catch {ota close} msg] $msg
+  list [catch {rbu close} msg] $msg
 } {1 SQLITE_CORRUPT}
 do_test 4.6.3 {
-  sqlite3 dbo ota.db
-  dbo eval { UPDATE ota_state SET v = v*-1 WHERE k = 1 }
+  sqlite3 dbo rbu.db
+  dbo eval { UPDATE rbu_state SET v = v*-1 WHERE k = 1 }
   dbo close 
 } {}
 
 do_test 4.7.1 {
-  sqlite3 dbo ota.db
-  dbo eval { UPDATE ota_state SET v = 1 WHERE k = 1 }
-  dbo eval { UPDATE ota_state SET v = 'nosuchtable' WHERE k = 2 }
+  sqlite3 dbo rbu.db
+  dbo eval { UPDATE rbu_state SET v = 1 WHERE k = 1 }
+  dbo eval { UPDATE rbu_state SET v = 'nosuchtable' WHERE k = 2 }
   dbo close
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_ERROR}
 do_test 4.7.2 {
-  list [catch {ota close} msg] $msg
-} {1 {SQLITE_ERROR - ota_state mismatch error}}
+  list [catch {rbu close} msg] $msg
+} {1 {SQLITE_ERROR - rbu_state mismatch error}}
 
 finish_test
 
diff --git a/ext/ota/ota12.test b/ext/rbu/rbu12.test
similarity index 71%
rename from ext/ota/ota12.test
rename to ext/rbu/rbu12.test
index b97f10653e..a83d0891a3 100644
--- a/ext/ota/ota12.test
+++ b/ext/rbu/rbu12.test
@@ -15,7 +15,7 @@ if {![info exists testdir]} {
 }
 source $testdir/tester.tcl
 source $testdir/lock_common.tcl
-set ::testprefix ota12
+set ::testprefix rbu12
 
 set setup_sql {
   DROP TABLE IF EXISTS xx;
@@ -24,34 +24,34 @@ set setup_sql {
   INSERT INTO xx VALUES(1, 2, 3);
   CREATE TABLE xy(a, b, c PRIMARY KEY);
 
-  ATTACH 'ota.db' AS ota;
+  ATTACH 'rbu.db' AS rbu;
     DROP TABLE IF EXISTS data_xx;
-    CREATE TABLE ota.data_xx(a, b, c, ota_control);
+    CREATE TABLE rbu.data_xx(a, b, c, rbu_control);
     INSERT INTO data_xx VALUES(4, 5, 6, 0);
     INSERT INTO data_xx VALUES(7, 8, 9, 0);
-    CREATE TABLE ota.data_xy(a, b, c, ota_control);
+    CREATE TABLE rbu.data_xy(a, b, c, rbu_control);
     INSERT INTO data_xy VALUES(10, 11, 12, 0);
-  DETACH ota;
+  DETACH rbu;
 }
 
 do_multiclient_test tn {
 
-  # Initialize a target (test.db) and ota (ota.db) database.
+  # Initialize a target (test.db) and rbu (rbu.db) database.
   #
-  forcedelete ota.db
+  forcedelete rbu.db
   sql1 $setup_sql
 
   # Using connection 2, open a read transaction on the target database.
-  # OTA will still be able to generate "test.db-oal", but it will not be
+  # RBU will still be able to generate "test.db-oal", but it will not be
   # able to rename it to "test.db-wal".
   #
   do_test 1.$tn.1 {
     sql2 { BEGIN; SELECT * FROM xx; }
   } {1 2 3}
   do_test 1.$tn.2 {
-    sqlite3ota ota test.db ota.db
+    sqlite3rbu rbu test.db rbu.db
     while 1 {
-      set res [ota step]
+      set res [rbu step]
       if {$res!="SQLITE_OK"} break
     }
     set res
@@ -64,119 +64,119 @@ do_multiclient_test tn {
   } {0 1}
   do_test 1.$tn.6 { sql2 COMMIT } {}
 
-  # The ota object that hit the SQLITE_BUSY error above cannot be reused.
+  # The rbu object that hit the SQLITE_BUSY error above cannot be reused.
   # It is stuck in a permanent SQLITE_BUSY state at this point.
   #
-  do_test 1.$tn.7 { ota step } {SQLITE_BUSY}
+  do_test 1.$tn.7 { rbu step } {SQLITE_BUSY}
   do_test 1.$tn.8 { 
-    list [catch { ota close } msg] $msg 
+    list [catch { rbu close } msg] $msg 
   } {1 SQLITE_BUSY}
 
   do_test 1.$tn.9.1 { sql2 { BEGIN EXCLUSIVE } } {}
   do_test 1.$tn.9.2 {
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_BUSY}
   do_test 1.$tn.9.3 {
-    list [catch { ota close } msg] $msg 
+    list [catch { rbu close } msg] $msg 
   } {1 {SQLITE_BUSY - database is locked}}
   do_test 1.$tn.9.4 { sql2 COMMIT } {}
 
-  sqlite3ota ota test.db ota.db
+  sqlite3rbu rbu test.db rbu.db
   do_test 1.$tn.10.1 { sql2 { BEGIN EXCLUSIVE } } {}
   do_test 1.$tn.10.2 {
-    ota step
+    rbu step
   } {SQLITE_BUSY}
   do_test 1.$tn.10.3 {
-    list [catch { ota close } msg] $msg 
+    list [catch { rbu close } msg] $msg 
   } {1 SQLITE_BUSY}
   do_test 1.$tn.10.4 { sql2 COMMIT } {}
 
-  # A new ota object can finish the work though.
+  # A new rbu object can finish the work though.
   #
   do_test 1.$tn.11 {
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_OK}
   do_test 1.$tn.12 {
     list [file exists test.db-wal] [file exists test.db-oal]
   } {1 0}
   do_test 1.$tn.13 {
     while 1 {
-      set res [ota step]
+      set res [rbu step]
       if {$res!="SQLITE_OK"} break
     }
     set res
   } {SQLITE_DONE}
 
   do_test 1.$tn.14 {
-    ota close
+    rbu close
   } {SQLITE_DONE}
 }
 
 do_multiclient_test tn {
 
-  # Initialize a target (test.db) and ota (ota.db) database.
+  # Initialize a target (test.db) and rbu (rbu.db) database.
   #
-  forcedelete ota.db
+  forcedelete rbu.db
   sql1 $setup_sql
 
   do_test 2.$tn.1 {
-    sqlite3ota ota test.db ota.db
+    sqlite3rbu rbu test.db rbu.db
     while {[file exists test.db-wal]==0} {
-      if {[ota step]!="SQLITE_OK"} {error "problem here...."}
+      if {[rbu step]!="SQLITE_OK"} {error "problem here...."}
     }
-    ota close
+    rbu close
   } {SQLITE_OK}
 
 
   do_test 2.$tn.2 { sql2 { BEGIN IMMEDIATE } } {}
 
   do_test 2.$tn.3 { 
-    sqlite3ota ota test.db ota.db
-    ota step 
+    sqlite3rbu rbu test.db rbu.db
+    rbu step 
   } {SQLITE_BUSY}
 
-  do_test 2.$tn.4 { list [catch { ota close } msg] $msg } {1 SQLITE_BUSY}
+  do_test 2.$tn.4 { list [catch { rbu close } msg] $msg } {1 SQLITE_BUSY}
 
   do_test 2.$tn.5 { 
     sql2 { SELECT * FROM xx ; COMMIT }
   } {1 2 3 4 5 6 7 8 9}
 
   do_test 2.$tn.6 {
-    sqlite3ota ota test.db ota.db
-    ota step
-    ota close
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
+    rbu close
   } {SQLITE_OK}
 
   do_test 2.$tn.7 { sql2 { BEGIN EXCLUSIVE } } {}
 
   do_test 2.$tn.8 { 
-    sqlite3ota ota test.db ota.db
-    ota step 
+    sqlite3rbu rbu test.db rbu.db
+    rbu step 
   } {SQLITE_BUSY}
-  do_test 2.$tn.9 { list [catch { ota close } msg] $msg } {1 SQLITE_BUSY}
+  do_test 2.$tn.9 { list [catch { rbu close } msg] $msg } {1 SQLITE_BUSY}
   do_test 2.$tn.10 { 
     sql2 { SELECT * FROM xx ; COMMIT }
   } {1 2 3 4 5 6 7 8 9}
 
   do_test 2.$tn.11 {
-    sqlite3ota ota test.db ota.db
-    while {[ota step]=="SQLITE_OK"} {}
-    ota close
+    sqlite3rbu rbu test.db rbu.db
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
   } {SQLITE_DONE}
 
 }
 
 #-------------------------------------------------------------------------
-# Test that "PRAGMA data_version" works when an OTA client writes the
+# Test that "PRAGMA data_version" works when an RBU client writes the
 # database.
 #
 do_multiclient_test tn {
 
-  # Initialize a target (test.db) and ota (ota.db) database.
+  # Initialize a target (test.db) and rbu (rbu.db) database.
   #
-  forcedelete ota.db
+  forcedelete rbu.db
   sql1 $setup_sql
 
   # Check the initial database contains table "xx" with a single row.
@@ -195,17 +195,17 @@ do_multiclient_test tn {
     list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
   } [list $V1 $V2]
 
-  # Start stepping the OTA. From the point of view of [db1] and [db2], the 
+  # Start stepping the RBU. From the point of view of [db1] and [db2], the 
   # data-version values remain unchanged until the database contents are
   # modified. At which point the values are incremented.
   #
-  sqlite3ota ota test.db ota.db
+  sqlite3rbu rbu test.db rbu.db
   set x 0
   while {[db one {SELECT count(*) FROM xx}]==1} {
     do_test 2.$tn.3.[incr x] {
       list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
     } [list $V1 $V2]
-    ota step
+    rbu step
   }
   do_test 2.$tn.5.1 { expr {$V1 < [sql1 {PRAGMA data_version}]} } 1
   do_test 2.$tn.5.2 { expr {$V2 < [sql2 {PRAGMA data_version}]} } 1
@@ -219,11 +219,11 @@ do_multiclient_test tn {
   set V1 [sql1 {PRAGMA data_version}] 
   set V2 [sql2 {PRAGMA data_version}]
 
-  # Finish applying the OTA (i.e. do the incremental checkpoint). Check that
+  # Finish applying the RBU (i.e. do the incremental checkpoint). Check that
   # this does not cause the data-version values to change.
   #
-  while {[ota step]=="SQLITE_OK"} { }
-  ota close
+  while {[rbu step]=="SQLITE_OK"} { }
+  rbu close
 
   do_test 2.$tn.6 {
     list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
diff --git a/ext/ota/ota13.test b/ext/rbu/rbu13.test
similarity index 80%
rename from ext/ota/ota13.test
rename to ext/rbu/rbu13.test
index 42911a0605..ad67a98f80 100644
--- a/ext/ota/ota13.test
+++ b/ext/rbu/rbu13.test
@@ -9,8 +9,8 @@
 #
 #***********************************************************************
 #
-# Test an OTA update that features lots of different ota_control strings
-# for UPDATE statements. This tests OTA's internal UPDATE statement cache.
+# Test an RBU update that features lots of different rbu_control strings
+# for UPDATE statements. This tests RBU's internal UPDATE statement cache.
 #
 
 if {![info exists testdir]} {
@@ -18,7 +18,7 @@ if {![info exists testdir]} {
 }
 source $testdir/tester.tcl
 source $testdir/lock_common.tcl
-set ::testprefix ota13
+set ::testprefix rbu13
 
 do_execsql_test 1.0 {
   CREATE TABLE t1(a PRIMARY KEY, b, c, d, e, f, g, h);
@@ -26,10 +26,10 @@ do_execsql_test 1.0 {
   INSERT INTO t1 SELECT i, 0, 0, 0, 0, 0, 0, 0 FROM ii;
 }
 
-forcedelete ota.db
+forcedelete rbu.db
 do_execsql_test 1.1 {
-  ATTACH 'ota.db' AS ota;
-  CREATE TABLE ota.data_t1(a, b, c, d, e, f, g, h, ota_control);
+  ATTACH 'rbu.db' AS rbu;
+  CREATE TABLE rbu.data_t1(a, b, c, d, e, f, g, h, rbu_control);
 }
 
 do_test 1.2 {
@@ -47,12 +47,12 @@ do_test 1.2 {
 } {}
 
 do_test 1.3 {
-  sqlite3ota ota test.db ota.db
+  sqlite3rbu rbu test.db rbu.db
   while 1 {
-    set rc [ota step]
+    set rc [rbu step]
     if {$rc!="SQLITE_OK"} break
   }
-  ota close
+  rbu close
 } {SQLITE_DONE}
 
 do_execsql_test 1.4 {
diff --git a/ext/rbu/rbu14.test b/ext/rbu/rbu14.test
new file mode 100644
index 0000000000..d4f97ac32c
--- /dev/null
+++ b/ext/rbu/rbu14.test
@@ -0,0 +1,95 @@
+# 2015 July 25
+#
+# 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.
+#
+#***********************************************************************
+#
+# Test that an RBU data_xxx table may be a view instead of a regular
+# table.
+#
+
+if {![info exists testdir]} {
+  set testdir [file join [file dirname [info script]] .. .. test]
+}
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+set ::testprefix rbu14
+
+
+foreach {tn schema} {
+  1 {
+    CREATE TABLE t1(a PRIMARY KEY, b, c);
+    CREATE TABLE t2(a PRIMARY KEY, b, c);
+  }
+  2 {
+    CREATE TABLE t1(a PRIMARY KEY, b, c);
+    CREATE TABLE t2(a PRIMARY KEY, b, c);
+    CREATE INDEX i1 ON t1(b, c);
+    CREATE INDEX i2 ON t2(b, c);
+  }
+  3 {
+    CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
+    CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
+  }
+  4 {
+    CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
+    CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
+    CREATE INDEX i1 ON t1(b, c);
+    CREATE INDEX i2 ON t2(b, c);
+  }
+} {
+  reset_db
+
+  execsql $schema
+  execsql {
+    INSERT INTO t1 VALUES(50, 50, 50);
+    INSERT INTO t1 VALUES(51, 51, 51);
+    INSERT INTO t2 VALUES(50, 50, 50);
+    INSERT INTO t2 VALUES(51, 51, 51);
+  }
+
+  forcedelete rbu.db
+  do_execsql_test $tn.1 {
+    ATTACH 'rbu.db' AS rbu;
+    CREATE TABLE rbu.stuff(tbl, a, b, c, rbu_control);
+    INSERT INTO stuff VALUES
+      ('t1', 1, 2, 3, 0),                   -- insert into t1
+      ('t2', 4, 5, 6, 0),                   -- insert into t2
+      ('t1', 50, NULL, NULL, 1),            -- delete from t1
+      ('t2', 51, NULL, NULL, 1);            -- delete from t2
+
+    CREATE VIEW rbu.data_t1 AS 
+    SELECT a, b, c, rbu_control FROM stuff WHERE tbl='t1';
+    CREATE VIEW rbu.data_t2 AS 
+    SELECT a, b, c, rbu_control FROM stuff WHERE tbl='t2';
+  }
+
+  do_test $tn.2 {
+    while 1 {
+      sqlite3rbu rbu test.db rbu.db
+      set rc [rbu step]
+      rbu close
+      if {$rc != "SQLITE_OK"} break
+    }
+    set rc
+  } {SQLITE_DONE}
+
+  do_execsql_test $tn.3.1 {
+    SELECT * FROM t1 ORDER BY a;
+  } {1 2 3 51 51 51}
+
+  do_execsql_test $tn.3.2 {
+    SELECT * FROM t2 ORDER BY a;
+  } {4 5 6 50 50 50}
+
+  integrity_check $tn.4
+}
+
+
+finish_test
+
diff --git a/ext/ota/ota3.test b/ext/rbu/rbu3.test
similarity index 65%
rename from ext/ota/ota3.test
rename to ext/rbu/rbu3.test
index 24d5ffde32..995b3123fd 100644
--- a/ext/ota/ota3.test
+++ b/ext/rbu/rbu3.test
@@ -14,25 +14,25 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota3
+set ::testprefix rbu3
 
 
-# Run the OTA in file $ota on target database $target until completion.
+# Run the RBU in file $rbu on target database $target until completion.
 #
-proc run_ota {target ota} {
-  sqlite3ota ota $target $ota
-  while { [ota step]=="SQLITE_OK" } {}
-  ota close
+proc run_rbu {target rbu} {
+  sqlite3rbu rbu $target $rbu
+  while { [rbu step]=="SQLITE_OK" } {}
+  rbu close
 }
 
-forcedelete test.db-oal ota.db
+forcedelete test.db-oal rbu.db
 db close
 sqlite3_shutdown
 sqlite3_config_uri 1
 reset_db
 
 #--------------------------------------------------------------------
-# Test that for an OTA to be applied, no corruption results if the
+# Test that for an RBU to be applied, no corruption results if the
 # affinities on the source and target table do not match.
 #
 do_execsql_test 1.0 {
@@ -41,14 +41,14 @@ do_execsql_test 1.0 {
 } {}
 
 do_test 1.1 {
-  sqlite3 db2 ota.db
+  sqlite3 db2 rbu.db
   db2 eval {
-    CREATE TABLE data_x1(a, b, c, ota_control);
+    CREATE TABLE data_x1(a, b, c, rbu_control);
     INSERT INTO data_x1 VALUES(1, '123', '123', 0);
     INSERT INTO data_x1 VALUES(2, 123, 123, 0);
   }
   db2 close
-  run_ota test.db ota.db
+  run_rbu test.db rbu.db
 } {SQLITE_DONE}
 
 do_execsql_test 1.2 {
@@ -59,7 +59,7 @@ do_execsql_test 1.2 {
 # Test that NULL values may not be inserted into INTEGER PRIMARY KEY
 # columns.
 #
-forcedelete ota.db
+forcedelete rbu.db
 reset_db
 
 do_execsql_test 2.0 {
@@ -67,23 +67,23 @@ do_execsql_test 2.0 {
   CREATE INDEX i1 ON x1(b, c);
 } {}
 
-foreach {tn otadb} {
+foreach {tn rbudb} {
   1 {
-    CREATE TABLE data_x1(a, b, c, ota_control);
+    CREATE TABLE data_x1(a, b, c, rbu_control);
     INSERT INTO data_x1 VALUES(NULL, 'a', 'b', 0);
   }
 
   2 {
-    CREATE TABLE data_x1(c, b, a, ota_control);
+    CREATE TABLE data_x1(c, b, a, rbu_control);
     INSERT INTO data_x1 VALUES('b', 'a', NULL, 0);
   }
 } {
   do_test 2.$tn.1 {
-    forcedelete ota.db
-    sqlite3 db2 ota.db
-    db2 eval $otadb
+    forcedelete rbu.db
+    sqlite3 db2 rbu.db
+    db2 eval $rbudb
     db2 close
-    list [catch { run_ota test.db ota.db } msg] $msg
+    list [catch { run_rbu test.db rbu.db } msg] $msg
   } {1 {SQLITE_MISMATCH - datatype mismatch}}
 
   do_execsql_test 2.1.2 {
@@ -94,7 +94,7 @@ foreach {tn otadb} {
 #--------------------------------------------------------------------
 # Test that missing columns are detected.
 #
-forcedelete ota.db
+forcedelete rbu.db
 reset_db
 
 do_execsql_test 2.0 {
@@ -103,13 +103,13 @@ do_execsql_test 2.0 {
 } {}
 
 do_test 2.1 {
-  sqlite3 db2 ota.db
+  sqlite3 db2 rbu.db
   db2 eval {
-    CREATE TABLE data_x1(a, b, ota_control);
+    CREATE TABLE data_x1(a, b, rbu_control);
     INSERT INTO data_x1 VALUES(1, 'a', 0);
   }
   db2 close
-  list [catch { run_ota test.db ota.db } msg] $msg
+  list [catch { run_rbu test.db rbu.db } msg] $msg
 } {1 {SQLITE_ERROR - column missing from data_x1: c}}
 
 do_execsql_test 2.2 {
@@ -124,14 +124,14 @@ do_execsql_test 2.3 {
 } {}
 
 do_test 2.4 {
-  forcedelete ota.db
-  sqlite3 db2 ota.db
+  forcedelete rbu.db
+  sqlite3 db2 rbu.db
   db2 eval {
-    CREATE TABLE data_x2(a, b, c, d, ota_control);
+    CREATE TABLE data_x2(a, b, c, d, rbu_control);
     INSERT INTO data_x2 VALUES(1, 'a', 2, 3, 0);
   }
   db2 close
-  list [catch { run_ota test.db ota.db } msg] $msg
+  list [catch { run_rbu test.db rbu.db } msg] $msg
 } {1 SQLITE_ERROR}
 
 do_execsql_test 2.5 {
@@ -140,48 +140,48 @@ do_execsql_test 2.5 {
 
 
 #-------------------------------------------------------------------------
-# Test that sqlite3ota_create_vfs() returns an error if the requested 
+# Test that sqlite3rbu_create_vfs() returns an error if the requested 
 # parent VFS is unknown.
 #
 # And that nothing disasterous happens if a VFS name passed to
-# sqlite3ota_destroy_vfs() is unknown or not an OTA vfs.
+# sqlite3rbu_destroy_vfs() is unknown or not an RBU vfs.
 #
 do_test 3.1 {
-  list [catch {sqlite3ota_create_vfs xyz nosuchparent} msg] $msg
+  list [catch {sqlite3rbu_create_vfs xyz nosuchparent} msg] $msg
 } {1 SQLITE_NOTFOUND}
 
 do_test 3.2 {
-  sqlite3ota_destroy_vfs nosuchvfs
-  sqlite3ota_destroy_vfs unix
-  sqlite3ota_destroy_vfs win32
+  sqlite3rbu_destroy_vfs nosuchvfs
+  sqlite3rbu_destroy_vfs unix
+  sqlite3rbu_destroy_vfs win32
 } {}
 
 #-------------------------------------------------------------------------
 # Test that it is an error to specify an explicit VFS that does not 
-# include ota VFS functionality.
+# include rbu VFS functionality.
 #
 do_test 4.1 {
   testvfs tvfs
-  sqlite3ota ota file:test.db?vfs=tvfs ota.db 
-  list [catch { ota step } msg] $msg
+  sqlite3rbu rbu file:test.db?vfs=tvfs rbu.db 
+  list [catch { rbu step } msg] $msg
 } {0 SQLITE_ERROR}
 do_test 4.2 {
-  list [catch { ota close } msg] $msg
-} {1 {SQLITE_ERROR - ota vfs not found}}
+  list [catch { rbu close } msg] $msg
+} {1 {SQLITE_ERROR - rbu vfs not found}}
 tvfs delete
 
 #-------------------------------------------------------------------------
-# Test a large ota update to ensure that wal_autocheckpoint does not get
+# Test a large rbu update to ensure that wal_autocheckpoint does not get
 # in the way.
 #
-forcedelete ota.db
+forcedelete rbu.db
 reset_db
 do_execsql_test 5.1 {
   CREATE TABLE x1(a, b, c, PRIMARY KEY(a)) WITHOUT ROWID;
   CREATE INDEX i1 ON x1(a);
 
-  ATTACH 'ota.db' AS ota;
-  CREATE TABLE ota.data_x1(a, b, c, ota_control);
+  ATTACH 'rbu.db' AS rbu;
+  CREATE TABLE rbu.data_x1(a, b, c, rbu_control);
   WITH s(a, b, c) AS (
     SELECT randomblob(300), randomblob(300), 1
     UNION ALL
@@ -191,16 +191,16 @@ do_execsql_test 5.1 {
 }
 
 do_test 5.2 {
-  sqlite3ota ota test.db ota.db
-  while {[ota step]=="SQLITE_OK" && [file exists test.db-wal]==0} {}
-  ota close
+  sqlite3rbu rbu test.db rbu.db
+  while {[rbu step]=="SQLITE_OK" && [file exists test.db-wal]==0} {}
+  rbu close
 } {SQLITE_OK}
 
 do_test 5.3 {
   expr {[file size test.db-wal] > (1024 * 1200)}
 } 1
 
-do_test 6.1 { sqlite3ota_internal_test } {}
+do_test 6.1 { sqlite3rbu_internal_test } {}
 
 finish_test
 
diff --git a/ext/ota/ota5.test b/ext/rbu/rbu5.test
similarity index 83%
rename from ext/ota/ota5.test
rename to ext/rbu/rbu5.test
index 8b62eb0f66..9a0f17bc5d 100644
--- a/ext/ota/ota5.test
+++ b/ext/rbu/rbu5.test
@@ -9,33 +9,33 @@
 #
 #***********************************************************************
 #
-# Test some properties of the pager_ota_mode and ota_mode pragmas.
+# Test some properties of the pager_rbu_mode and rbu_mode pragmas.
 #
 
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota5
+set ::testprefix rbu5
 
 
-# Run the OTA in file $ota on target database $target until completion.
+# Run the RBU in file $rbu on target database $target until completion.
 #
-proc run_ota {target ota} {
-  sqlite3ota ota $target $ota
-  while { [ota step]=="SQLITE_OK" } {}
-  ota close
+proc run_rbu {target rbu} {
+  sqlite3rbu rbu $target $rbu
+  while { [rbu step]=="SQLITE_OK" } {}
+  rbu close
 }
 
 
-# Run the OTA in file $ota on target database $target one step at a
+# Run the RBU in file $rbu on target database $target one step at a
 # time until completion.
 #
-proc step_ota {target ota} {
+proc step_rbu {target rbu} {
   while 1 {
-    sqlite3ota ota $target $ota
-    set rc [ota step]
-    ota close
+    sqlite3rbu rbu $target $rbu
+    set rc [rbu step]
+    rbu close
     if {$rc != "SQLITE_OK"} break
   }
   set rc
@@ -99,31 +99,31 @@ proc ucontrol {args} {
 
 # Argument $target is the name of an SQLite database file. $sql is an SQL
 # script containing INSERT, UPDATE and DELETE statements to execute against
-# it. This command creates an OTA update database in file $ota that has
+# it. This command creates an RBU update database in file $rbu that has
 # the same effect as the script. The target database is not modified by
 # this command.
 #
-proc generate_ota_db {target ota sql} {
+proc generate_rbu_db {target rbu sql} {
 
-  forcedelete $ota
+  forcedelete $rbu
   forcecopy $target copy.db
 
   # Evaluate the SQL script to modify the contents of copy.db.
   #
-  sqlite3 dbOta copy.db
-  dbOta eval $sql
+  sqlite3 dbRbu copy.db
+  dbRbu eval $sql
 
-  dbOta function ucontrol ucontrol
+  dbRbu function ucontrol ucontrol
   
   # Evaluate the SQL script to modify the contents of copy.db.
-  set ret [datacksum dbOta]
+  set ret [datacksum dbRbu]
 
-  dbOta eval { ATTACH $ota AS ota }
-  dbOta eval { ATTACH $target AS orig }
+  dbRbu eval { ATTACH $rbu AS rbu }
+  dbRbu eval { ATTACH $target AS orig }
 
-  dbOta eval { SELECT name AS tbl FROM sqlite_master WHERE type = 'table' } {
-    set pk [pkcols dbOta $tbl]
-    set cols [allcols dbOta $tbl]
+  dbRbu eval { SELECT name AS tbl FROM sqlite_master WHERE type = 'table' } {
+    set pk [pkcols dbRbu $tbl]
+    set cols [allcols dbRbu $tbl]
 
     # A WHERE clause to test that the PK columns match.
     #
@@ -138,25 +138,25 @@ proc generate_ota_db {target ota sql} {
     set ucontrol "ucontrol([join $where2 ,])"
     set where2 [join $where2 " AND "]
 
-    # Create a data_xxx table in the OTA update database.
-    dbOta eval "
-      CREATE TABLE ota.data_$tbl AS SELECT *, '' AS ota_control 
+    # Create a data_xxx table in the RBU update database.
+    dbRbu eval "
+      CREATE TABLE rbu.data_$tbl AS SELECT *, '' AS rbu_control 
       FROM main.$tbl LIMIT 0
     "
 
     # Find all new rows INSERTed by the script.
-    dbOta eval "
-      INSERT INTO ota.data_$tbl 
-          SELECT *, 0 AS ota_control FROM main.$tbl
+    dbRbu eval "
+      INSERT INTO rbu.data_$tbl 
+          SELECT *, 0 AS rbu_control FROM main.$tbl
           WHERE NOT EXISTS (
             SELECT 1 FROM orig.$tbl WHERE $where
           )
     "
     
     # Find all old rows DELETEd by the script.
-    dbOta eval "
-      INSERT INTO ota.data_$tbl 
-          SELECT *, 1 AS ota_control FROM orig.$tbl
+    dbRbu eval "
+      INSERT INTO rbu.data_$tbl 
+          SELECT *, 1 AS rbu_control FROM orig.$tbl
           WHERE NOT EXISTS (
             SELECT 1 FROM main.$tbl WHERE $where
           )
@@ -166,16 +166,16 @@ proc generate_ota_db {target ota sql} {
     set origcols [list]
     foreach c $cols { lappend origcols "main.$tbl.$c" }
     set origcols [join $origcols ,]
-    dbOta eval "
-      INSERT INTO ota.data_$tbl
-          SELECT $origcols, $ucontrol AS ota_control 
+    dbRbu eval "
+      INSERT INTO rbu.data_$tbl
+          SELECT $origcols, $ucontrol AS rbu_control 
           FROM orig.$tbl, main.$tbl
           WHERE $where AND NOT ($where2)
     "
 
   }
 
-  dbOta close
+  dbRbu close
   forcedelete copy.db
 
   return $ret
@@ -197,7 +197,7 @@ do_execsql_test 1.0 {
 }
 db close
 
-set cksum [generate_ota_db test.db ota.db {
+set cksum [generate_rbu_db test.db rbu.db {
   INSERT INTO t1 VALUES(4, 8, 12);
   DELETE FROM t1 WHERE a = 2;
   UPDATE t1 SET c = 15 WHERE a=3;
@@ -217,13 +217,13 @@ foreach {tn idx} {
 } {
   foreach cmd {run step} {
     forcecopy test.db test.db2
-    forcecopy ota.db ota.db2
+    forcecopy rbu.db rbu.db2
 
     sqlite3 db test.db2
     db eval $idx
 
     do_test 1.$tn.$cmd.1 {
-      ${cmd}_ota test.db2 ota.db2
+      ${cmd}_rbu test.db2 rbu.db2
       datacksum db
     } $cksum
 
@@ -265,7 +265,7 @@ do_execsql_test 2.0 {
 }
 db close
 
-set cksum [generate_ota_db test.db ota.db {
+set cksum [generate_rbu_db test.db rbu.db {
 INSERT INTO t2 VALUES(222916.23,'idh',X'472C517405',X'E3',X'7C4F31824669');
 INSERT INTO t2 VALUES('xcndjwafcoxwxizoktd',-319567.21,NULL,-720906.43,-577170);
 INSERT INTO t2 VALUES(376369.99,-536058,'yoaiurfqupdscwc',X'29EC8A2542EC3953E9',-740485.22);
@@ -305,13 +305,13 @@ foreach {tn idx} {
 } {
   foreach cmd {run step} {
     forcecopy test.db test.db2
-    forcecopy ota.db ota.db2
+    forcecopy rbu.db rbu.db2
 
     sqlite3 db test.db2
     db eval $idx
 
     do_test 2.$tn.$cmd.1 {
-      ${cmd}_ota test.db2 ota.db2
+      ${cmd}_rbu test.db2 rbu.db2
       datacksum db
     } $cksum
 
diff --git a/ext/ota/ota6.test b/ext/rbu/rbu6.test
similarity index 70%
rename from ext/ota/ota6.test
rename to ext/rbu/rbu6.test
index 4fe14950b4..f05721574a 100644
--- a/ext/ota/ota6.test
+++ b/ext/rbu/rbu6.test
@@ -9,15 +9,15 @@
 #
 #***********************************************************************
 #
-# This file contains tests for the OTA module. Specifically, it tests the
-# outcome of some other client writing to the database while an OTA update
+# This file contains tests for the RBU module. Specifically, it tests the
+# outcome of some other client writing to the database while an RBU update
 # is being applied.
 
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota6
+set ::testprefix rbu6
 
 proc setup_test {} {
   reset_db
@@ -28,17 +28,17 @@ proc setup_test {} {
   }
   db close
 
-  forcedelete ota.db
-  sqlite3 ota ota.db
-  ota eval {
-    CREATE TABLE data_t1(a, b, ota_control);
-    CREATE TABLE data_t2(a, b, ota_control);
-    CREATE TABLE data_t3(a, b, ota_control);
+  forcedelete rbu.db
+  sqlite3 rbu rbu.db
+  rbu eval {
+    CREATE TABLE data_t1(a, b, rbu_control);
+    CREATE TABLE data_t2(a, b, rbu_control);
+    CREATE TABLE data_t3(a, b, rbu_control);
     INSERT INTO data_t1 VALUES(1, 't1', 0);
     INSERT INTO data_t2 VALUES(2, 't2', 0);
     INSERT INTO data_t3 VALUES(3, 't3', 0);
   }
-  ota close
+  rbu close
 }
 
 # Test the outcome of some other client writing the db while the *-oal 
@@ -48,49 +48,49 @@ proc setup_test {} {
 for {set nStep 1} {$nStep < 8} {incr nStep} {
   do_test 1.$nStep.1 {
     setup_test
-    sqlite3ota ota test.db ota.db
-    for {set i 0} {$i<$nStep} {incr i} {ota step}
+    sqlite3rbu rbu test.db rbu.db
+    for {set i 0} {$i<$nStep} {incr i} {rbu step}
 
-    ota close
+    rbu close
     sqlite3 db test.db
     execsql { INSERT INTO t1 VALUES(5, 'hello') }
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_BUSY}
   do_test 1.$nStep.2 {
-    ota step
+    rbu step
   } {SQLITE_BUSY}
   do_test 1.$nStep.3 {
     list [file exists test.db-oal] [file exists test.db-wal]
   } {1 0}
   do_test 1.$nStep.4 {
-    list [catch { ota close } msg] $msg
-  } {1 {SQLITE_BUSY - database modified during ota update}}
+    list [catch { rbu close } msg] $msg
+  } {1 {SQLITE_BUSY - database modified during rbu update}}
 }
 
 # Test the outcome of some other client writing the db after the *-oal
 # file has been copied to the *-wal path. Once this has happened, any
-# other client writing to the db causes OTA to consider its job finished.
+# other client writing to the db causes RBU to consider its job finished.
 #
 for {set nStep 8} {$nStep < 20} {incr nStep} {
   do_test 1.$nStep.1 {
     setup_test
-    sqlite3ota ota test.db ota.db
-    for {set i 0} {$i<$nStep} {incr i} {ota step}
-    ota close
+    sqlite3rbu rbu test.db rbu.db
+    for {set i 0} {$i<$nStep} {incr i} {rbu step}
+    rbu close
     sqlite3 db test.db
     execsql { INSERT INTO t1 VALUES(5, 'hello') }
-    sqlite3ota ota test.db ota.db
-    ota step
+    sqlite3rbu rbu test.db rbu.db
+    rbu step
   } {SQLITE_DONE}
   do_test 1.$nStep.2 {
-    ota step
+    rbu step
   } {SQLITE_DONE}
   do_test 1.$nStep.3 {
     file exists test.db-oal
   } {0}
   do_test 1.$nStep.4 {
-    list [catch { ota close } msg] $msg
+    list [catch { rbu close } msg] $msg
   } {0 SQLITE_DONE}
 
   do_execsql_test 1.$nStep.5 {
diff --git a/ext/ota/ota7.test b/ext/rbu/rbu7.test
similarity index 79%
rename from ext/ota/ota7.test
rename to ext/rbu/rbu7.test
index a4ee6b41ad..f773c9e5a9 100644
--- a/ext/ota/ota7.test
+++ b/ext/rbu/rbu7.test
@@ -9,7 +9,7 @@
 #
 #***********************************************************************
 #
-# This file contains tests for the OTA module.
+# This file contains tests for the RBU module.
 #
 
 
@@ -17,12 +17,12 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota7
+set ::testprefix rbu7
 
 # Test index:
 #
 #   1.*: That affinities are correctly applied to values within the 
-#        OTA database.
+#        RBU database.
 #
 #   2.*: Tests for multi-column primary keys.
 #
@@ -34,19 +34,19 @@ do_test 1.0 {
     INSERT INTO t1 VALUES(2, 'def');
   }
 
-  forcedelete ota.db
-  sqlite3 ota ota.db
-  ota eval {
-    CREATE TABLE data_t1(a, b, ota_control);
+  forcedelete rbu.db
+  sqlite3 rbu rbu.db
+  rbu eval {
+    CREATE TABLE data_t1(a, b, rbu_control);
     INSERT INTO data_t1 VALUES('1', NULL, 1);
   }
-  ota close
+  rbu close
 } {}
 
 do_test 1.1 {
-  sqlite3ota ota test.db ota.db
-  while { [ota step]=="SQLITE_OK" } {}
-  ota close
+  sqlite3rbu rbu test.db rbu.db
+  while { [rbu step]=="SQLITE_OK" } {}
+  rbu close
 } {SQLITE_DONE}
 
 sqlite3 db test.db
@@ -72,24 +72,24 @@ foreach {tn tbl} {
   }
 
   do_test 2.$tn.2 {
-    forcedelete ota.db
-    sqlite3 ota ota.db
+    forcedelete rbu.db
+    sqlite3 rbu rbu.db
     execsql {
-      CREATE TABLE data_t1(a, b, c, ota_control);
+      CREATE TABLE data_t1(a, b, c, rbu_control);
       INSERT INTO data_t1 VALUES(3, 1, 'e', 0);
       INSERT INTO data_t1 VALUES(3, 2, 'f', 0);
       INSERT INTO data_t1 VALUES(1, 2, NULL, 1);
       INSERT INTO data_t1 VALUES(2, 1, 'X', '..x');
-    } ota
-    ota close
+    } rbu
+    rbu close
   } {}
 
   do_test 2.$tn.3 {
     set rc "SQLITE_OK"
     while {$rc == "SQLITE_OK"} {
-      sqlite3ota ota test.db ota.db
-      ota step
-      set rc [ota close]
+      sqlite3rbu rbu test.db rbu.db
+      rbu step
+      set rc [rbu close]
     } 
     set rc
   } {SQLITE_DONE}
diff --git a/ext/ota/ota8.test b/ext/rbu/rbu8.test
similarity index 75%
rename from ext/ota/ota8.test
rename to ext/rbu/rbu8.test
index 24a6e72248..75edd4efba 100644
--- a/ext/ota/ota8.test
+++ b/ext/rbu/rbu8.test
@@ -9,14 +9,14 @@
 #
 #***********************************************************************
 #
-# Test the ota_delta() feature.
+# Test the rbu_delta() feature.
 #
 
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota8
+set ::testprefix rbu8
 
 do_execsql_test 1.0 {
   CREATE TABLE t1(x, y PRIMARY KEY, z);
@@ -27,10 +27,10 @@ do_execsql_test 1.0 {
 }
 
 do_test 1.1 {
-  forcedelete ota.db
-  sqlite3 db2 ota.db
+  forcedelete rbu.db
+  sqlite3 db2 rbu.db
   db2 eval {
-    CREATE TABLE data_t1(x, y, z, ota_control);
+    CREATE TABLE data_t1(x, y, z, rbu_control);
     INSERT INTO data_t1 VALUES('a',    1, '_i'      , 'x.d');
     INSERT INTO data_t1 VALUES('b',    2, 2         , '..x');
     INSERT INTO data_t1 VALUES('_iii', 3, '-III'    , 'd.d');
@@ -39,26 +39,26 @@ do_test 1.1 {
 } {}
 
 do_test 1.2.1 {
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_ERROR}
 do_test 1.2.2 {
-  list [catch {ota close} msg] $msg
-} {1 {SQLITE_ERROR - no such function: ota_delta}}
+  list [catch {rbu close} msg] $msg
+} {1 {SQLITE_ERROR - no such function: rbu_delta}}
 
-proc ota_delta {orig new} {
+proc rbu_delta {orig new} {
  return "${orig}${new}"
 }
 
 do_test 1.3.1 {
   while 1 {
-    sqlite3ota ota test.db ota.db
-    ota create_ota_delta
-    set rc [ota step]
+    sqlite3rbu rbu test.db rbu.db
+    rbu create_rbu_delta
+    set rc [rbu step]
     if {$rc != "SQLITE_OK"} break
-    ota close
+    rbu close
   }
-  ota close
+  rbu close
 } {SQLITE_DONE}
 
 do_execsql_test 1.3.2 {
diff --git a/ext/ota/ota9.test b/ext/rbu/rbu9.test
similarity index 81%
rename from ext/ota/ota9.test
rename to ext/rbu/rbu9.test
index e746d363f1..3ce649d250 100644
--- a/ext/ota/ota9.test
+++ b/ext/rbu/rbu9.test
@@ -9,14 +9,14 @@
 #
 #***********************************************************************
 #
-# Test OTA with virtual tables. And tables with no PRIMARY KEY declarations.
+# Test RBU with virtual tables. And tables with no PRIMARY KEY declarations.
 #
 
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix ota9
+set ::testprefix rbu9
 
 ifcapable !fts3 {
   finish_test
@@ -31,10 +31,10 @@ do_execsql_test 1.1 {
 }
 
 do_test 1.1 {
-  forcedelete ota.db
-  sqlite3 db2 ota.db
+  forcedelete rbu.db
+  sqlite3 db2 rbu.db
   db2 eval {
-    CREATE TABLE data_f1(ota_rowid, a, b, c, ota_control);
+    CREATE TABLE data_f1(rbu_rowid, a, b, c, rbu_control);
     INSERT INTO data_f1 VALUES(14, 'x', 'y', 'z', 0);         -- INSERT
     INSERT INTO data_f1 VALUES(11, NULL, NULL, NULL, 1);      -- DELETE
     INSERT INTO data_f1 VALUES(13, NULL, NULL, 'X', '..x');   -- UPDATE
@@ -44,12 +44,12 @@ do_test 1.1 {
 
 do_test 1.2.1 {
   while 1 {
-    sqlite3ota ota test.db ota.db
-    set rc [ota step]
+    sqlite3rbu rbu test.db rbu.db
+    set rc [rbu step]
     if {$rc != "SQLITE_OK"} break
-    ota close
+    rbu close
   }
-  ota close
+  rbu close
 } {SQLITE_DONE}
 
 do_execsql_test 1.2.2 { SELECT rowid, * FROM f1 } { 
@@ -64,12 +64,12 @@ integrity_check 1.2.4
 # Tables with no PK declaration.
 #
 
-# Run the OTA in file $ota on target database $target until completion.
+# Run the RBU in file $rbu on target database $target until completion.
 #
-proc run_ota {target ota} {
-  sqlite3ota ota $target $ota
-  while { [ota step]=="SQLITE_OK" } {}
-  ota close
+proc run_rbu {target rbu} {
+  sqlite3rbu rbu $target $rbu
+  while { [rbu step]=="SQLITE_OK" } {}
+  rbu close
 }
 
 foreach {tn idx} {
@@ -96,10 +96,10 @@ foreach {tn idx} {
   db eval $idx
   
   do_test 2.$tn.2 {
-    forcedelete ota.db
-    sqlite3 db2 ota.db
+    forcedelete rbu.db
+    sqlite3 db2 rbu.db
     db2 eval {
-      CREATE TABLE data_t1(ota_rowid, a, b, c, ota_control);
+      CREATE TABLE data_t1(rbu_rowid, a, b, c, rbu_control);
       INSERT INTO data_t1 VALUES(3, 'x', 'y', 'z', 0);
       INSERT INTO data_t1 VALUES(NULL, 'X', 'Y', 'Z', 0);
       INSERT INTO data_t1 VALUES('1', NULL, NULL, NULL, 1);
@@ -108,7 +108,7 @@ foreach {tn idx} {
     db2 close
   } {}
   
-  run_ota test.db ota.db
+  run_rbu test.db rbu.db
   
   do_execsql_test 2.$tn.3 {
     SELECT rowid, a, b, c FROM t1 ORDER BY rowid;
diff --git a/ext/ota/otaA.test b/ext/rbu/rbuA.test
similarity index 70%
rename from ext/ota/otaA.test
rename to ext/rbu/rbuA.test
index bcc9a8b725..d15a7dbb75 100644
--- a/ext/ota/otaA.test
+++ b/ext/rbu/rbuA.test
@@ -9,22 +9,22 @@
 #
 #***********************************************************************
 #
-# This file contains tests for the OTA module. More specifically, it
+# This file contains tests for the RBU module. More specifically, it
 # contains tests to ensure that it is an error to attempt to update
-# a wal mode database via OTA.
+# a wal mode database via RBU.
 #
 
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix otaA
+set ::testprefix rbuA
 
 set db_sql {
   CREATE TABLE t1(a PRIMARY KEY, b, c);
 }
-set ota_sql {
-  CREATE TABLE data_t1(a, b, c, ota_control);
+set rbu_sql {
+  CREATE TABLE data_t1(a, b, c, rbu_control);
   INSERT INTO data_t1 VALUES(1, 2, 3, 0);
   INSERT INTO data_t1 VALUES(4, 5, 6, 0);
   INSERT INTO data_t1 VALUES(7, 8, 9, 0);
@@ -32,38 +32,38 @@ set ota_sql {
 
 do_test 1.0 {
   db close
-  forcedelete test.db ota.db
+  forcedelete test.db rbu.db
 
   sqlite3 db test.db
   db eval $db_sql
   db eval { PRAGMA journal_mode = wal }
   db close
 
-  sqlite3 db ota.db
-  db eval $ota_sql
+  sqlite3 db rbu.db
+  db eval $rbu_sql
   db close
 
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_ERROR}
 do_test 1.1 {
-  list [catch { ota close } msg] $msg
+  list [catch { rbu close } msg] $msg
 } {1 {SQLITE_ERROR - cannot update wal mode database}}
 
 do_test 2.0 {
-  forcedelete test.db ota.db
+  forcedelete test.db rbu.db
 
   sqlite3 db test.db
   db eval $db_sql
   db close
 
-  sqlite3 db ota.db
-  db eval $ota_sql
+  sqlite3 db rbu.db
+  db eval $rbu_sql
   db close
 
-  sqlite3ota ota test.db ota.db
-  ota step
-  ota close
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
+  rbu close
 } {SQLITE_OK}
 
 do_test 2.1 {
@@ -71,12 +71,12 @@ do_test 2.1 {
   db eval {PRAGMA journal_mode = wal}
   db close
   breakpoint
-  sqlite3ota ota test.db ota.db
-  ota step
+  sqlite3rbu rbu test.db rbu.db
+  rbu step
 } {SQLITE_ERROR}
 
 do_test 2.2 {
-  list [catch { ota close } msg] $msg
+  list [catch { rbu close } msg] $msg
 } {1 {SQLITE_ERROR - cannot update wal mode database}}
 
 
diff --git a/ext/ota/otacrash.test b/ext/rbu/rbucrash.test
similarity index 59%
rename from ext/ota/otacrash.test
rename to ext/rbu/rbucrash.test
index 992b87cd00..40993ac61d 100644
--- a/ext/ota/otacrash.test
+++ b/ext/rbu/rbucrash.test
@@ -14,16 +14,16 @@ if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source $testdir/tester.tcl
-set ::testprefix otacrash
+set ::testprefix rbucrash
 
 db close
-forcedelete test.db-oal ota.db
+forcedelete test.db-oal rbu.db
 sqlite3_shutdown
 sqlite3_config_uri 1
 reset_db
 
-# Set up a target database and an ota update database. The target
-# db is the usual "test.db", the ota db is "test.db2".
+# Set up a target database and an rbu update database. The target
+# db is the usual "test.db", the rbu db is "test.db2".
 #
 forcedelete test.db2
 do_execsql_test 1.0 {
@@ -32,8 +32,8 @@ do_execsql_test 1.0 {
   INSERT INTO t1 VALUES(4, 5, 6);
   INSERT INTO t1 VALUES(7, 8, 9);
 
-  ATTACH 'test.db2' AS ota;
-  CREATE TABLE ota.data_t1(a, b, c, ota_control);
+  ATTACH 'test.db2' AS rbu;
+  CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
   INSERT INTO data_t1 VALUES(10, 11, 12, 0);
   INSERT INTO data_t1 VALUES(13, 14, 15, 0);
   INSERT INTO data_t1 VALUES(4, NULL, NULL, 1);
@@ -42,63 +42,63 @@ do_execsql_test 1.0 {
 db_save_and_close
 
 
-# Determine the number of steps in applying the ota update to the test
-# target database created above. Set $::ota_num_steps accordingly
+# Determine the number of steps in applying the rbu update to the test
+# target database created above. Set $::rbu_num_steps accordingly
 #
-# Check that the same number of steps are required to apply the ota
-# update using many calls to sqlite3ota_step() on a single ota handle
-# as required to apply it using a series of ota handles, on each of 
-# which sqlite3ota_step() is called once.
+# Check that the same number of steps are required to apply the rbu
+# update using many calls to sqlite3rbu_step() on a single rbu handle
+# as required to apply it using a series of rbu handles, on each of 
+# which sqlite3rbu_step() is called once.
 #
 do_test 1.1 {
   db_restore
-  sqlite3ota ota test.db test.db2
+  sqlite3rbu rbu test.db test.db2
   breakpoint
   set nStep 0
-  while {[ota step]=="SQLITE_OK"} { incr nStep }
-  ota close
+  while {[rbu step]=="SQLITE_OK"} { incr nStep }
+  rbu close
 } {SQLITE_DONE}
-set ota_num_steps $nStep
+set rbu_num_steps $nStep
 do_test 1.2 {
   db_restore
   set nStep 0
   while {1} {
-    sqlite3ota ota test.db test.db2
-    ota step
-    if {[ota close]=="SQLITE_DONE"} break
+    sqlite3rbu rbu test.db test.db2
+    rbu step
+    if {[rbu close]=="SQLITE_DONE"} break
     incr nStep
   }
   set nStep
-} $ota_num_steps
+} $rbu_num_steps
 
 
-# Run one or more tests using the target (test.db) and ota (test.db2)
+# Run one or more tests using the target (test.db) and rbu (test.db2)
 # databases created above. As follows:
 #
-#   1. This process starts the ota update and calls sqlite3ota_step()
-#      $nPre times. Then closes the ota update handle.
+#   1. This process starts the rbu update and calls sqlite3rbu_step()
+#      $nPre times. Then closes the rbu update handle.
 #
-#   2. A second process resumes the ota update and attempts to call 
-#      sqlite3ota_step() $nStep times before closing the handle. A
+#   2. A second process resumes the rbu update and attempts to call 
+#      sqlite3rbu_step() $nStep times before closing the handle. A
 #      crash is simulated during each xSync() of file test.db2.
 #
-#   3. This process attempts to resume the ota update from whatever
+#   3. This process attempts to resume the rbu update from whatever
 #      state it was left in by step (2). Test that it is successful
 #      in doing so and that the final target database is as expected.
 #
 # In total (nSync+1) tests are run, where nSync is the number of times
 # xSync() is called on test.db2.
 #
-proc do_ota_crash_test {tn nPre nStep} {
+proc do_rbu_crash_test {tn nPre nStep} {
 
   set script [subst -nocommands {
-    sqlite3ota ota test.db file:test.db2?vfs=crash
+    sqlite3rbu rbu test.db file:test.db2?vfs=crash
     set i 0
     while {[set i] < $nStep} {
-      if {[ota step]!="SQLITE_OK"} break
+      if {[rbu step]!="SQLITE_OK"} break
       incr i
     }
-    ota close
+    rbu close
   }]
 
   set bDone 0
@@ -107,12 +107,12 @@ proc do_ota_crash_test {tn nPre nStep} {
     db_restore
 
     if {$nPre>0} {
-      sqlite3ota ota test.db file:test.db2
+      sqlite3rbu rbu test.db file:test.db2
       set i 0
       for {set i 0} {$i < $nPre} {incr i} { 
-        if {[ota step]!="SQLITE_OK"} break
+        if {[rbu step]!="SQLITE_OK"} break
       }
-      ota close
+      rbu close
     }
 
     set res [
@@ -126,9 +126,9 @@ proc do_ota_crash_test {tn nPre nStep} {
       error "unexected catchsql result: $res"
     }
 
-    sqlite3ota ota test.db test.db2
-    while {[ota step]=="SQLITE_OK"} {}
-    ota close
+    sqlite3rbu rbu test.db test.db2
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
 
     sqlite3 db test.db
     do_execsql_test $tn.delay=$iDelay {
@@ -139,9 +139,9 @@ proc do_ota_crash_test {tn nPre nStep} {
   }
 }
 
-for {set nPre 0} {$nPre < $ota_num_steps} {incr nPre} {
-  for {set is 1} {$is <= ($ota_num_steps - $nPre)} {incr is} {
-    do_ota_crash_test 2.pre=$nPre.step=$is $nPre $is
+for {set nPre 0} {$nPre < $rbu_num_steps} {incr nPre} {
+  for {set is 1} {$is <= ($rbu_num_steps - $nPre)} {incr is} {
+    do_rbu_crash_test 2.pre=$nPre.step=$is $nPre $is
   }
 }
 
diff --git a/ext/ota/otafault.test b/ext/rbu/rbufault.test
similarity index 78%
rename from ext/ota/otafault.test
rename to ext/rbu/rbufault.test
index de6939a556..3f30fb233b 100644
--- a/ext/ota/otafault.test
+++ b/ext/rbu/rbufault.test
@@ -15,7 +15,7 @@ if {![info exists testdir]} {
 }
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl
-set ::testprefix otafault
+set ::testprefix rbufault
 
 proc copy_if_exists {src target} {
   if {[file exists $src]} {
@@ -33,7 +33,7 @@ foreach {tn2 setup sql expect} {
     INSERT INTO t1 VALUES(2, 2, 2);
     INSERT INTO t1 VALUES(3, 3, 3);
 
-    CREATE TABLE ota.data_t1(a, b, c, ota_control);
+    CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(2, NULL, NULL, 1);
     INSERT INTO data_t1 VALUES(3, 'three', NULL, '.x.');
     INSERT INTO data_t1 VALUES(4, 4, 4, 0);
@@ -48,7 +48,7 @@ foreach {tn2 setup sql expect} {
     INSERT INTO t2 VALUES('b', 'b', 'b');
     INSERT INTO t2 VALUES('c', 'c', 'c');
 
-    CREATE TABLE ota.data_t2(a, b, c, ota_control);
+    CREATE TABLE rbu.data_t2(a, b, c, rbu_control);
     INSERT INTO data_t2 VALUES('b', NULL, NULL, 1);
     INSERT INTO data_t2 VALUES('c', 'see', NULL, '.x.');
     INSERT INTO data_t2 VALUES('d', 'd', 'd', 0);
@@ -62,8 +62,8 @@ foreach {tn2 setup sql expect} {
     CREATE INDEX t1cb ON t1(c, b);
     CREATE INDEX t2cb ON t2(c, b);
 
-    CREATE TABLE ota.data_t1(a, b, c, ota_control);
-    CREATE TABLE ota.data_t2(a, b, c, ota_control);
+    CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
+    CREATE TABLE rbu.data_t2(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES(1, 2, 3, 0);
     INSERT INTO data_t2 VALUES(4, 5, 6, 0);
   } {
@@ -76,7 +76,7 @@ foreach {tn2 setup sql expect} {
     INSERT INTO t1 VALUES('A', 'B', 'C');
     INSERT INTO t1 VALUES('D', 'E', 'F');
 
-    CREATE TABLE ota.data_t1(a, b, c, ota_control);
+    CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
     INSERT INTO data_t1 VALUES('D', NULL, NULL, 1);
     INSERT INTO data_t1 VALUES('A', 'Z', NULL, '.x.');
     INSERT INTO data_t1 VALUES('G', 'H', 'I', 0);
@@ -88,7 +88,7 @@ foreach {tn2 setup sql expect} {
     CREATE TABLE t1(a, b, c);
     CREATE INDEX t1c ON t1(c, b);
 
-    CREATE TABLE ota.data_t1(a, b, c, ota_rowid, ota_control);
+    CREATE TABLE rbu.data_t1(a, b, c, rbu_rowid, rbu_control);
     INSERT INTO data_t1 VALUES('a', 'b', 'c', 1, 0);
     INSERT INTO data_t1 VALUES('d', 'e', 'f', '2', 0);
   } {
@@ -97,17 +97,17 @@ foreach {tn2 setup sql expect} {
 
 } {
   catch {db close}
-  forcedelete ota.db test.db
+  forcedelete rbu.db test.db
   sqlite3 db test.db
   execsql {
     PRAGMA encoding = utf16;
-    ATTACH 'ota.db' AS ota;
+    ATTACH 'rbu.db' AS rbu;
   }
   execsql $setup
   db close
 
   forcecopy test.db test.db.bak
-  forcecopy ota.db ota.db.bak
+  forcecopy rbu.db rbu.db.bak
 
   foreach {tn f reslist} {
     1 oom-tra*  {
@@ -126,8 +126,8 @@ foreach {tn2 setup sql expect} {
       {1 SQLITE_IOERR_READ}
       {1 SQLITE_IOERR_FSYNC}
       {1 {SQLITE_ERROR - SQL logic error or missing database}}
-      {1 {SQLITE_ERROR - unable to open database: ota.db}}
-      {1 {SQLITE_IOERR - unable to open database: ota.db}}
+      {1 {SQLITE_ERROR - unable to open database: rbu.db}}
+      {1 {SQLITE_IOERR - unable to open database: rbu.db}}
     }
 
     3 shmerr-*  {
@@ -145,13 +145,13 @@ foreach {tn2 setup sql expect} {
 
     do_faultsim_test 2.$tn2 -faults $::f -prep {
       catch { db close }
-      forcedelete test.db-journal test.db-wal ota.db-journal ota.db-wal
+      forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
       forcecopy test.db.bak test.db
-      forcecopy ota.db.bak  ota.db
+      forcecopy rbu.db.bak  rbu.db
     } -body {
-      sqlite3ota ota test.db ota.db
-      while {[ota step]=="SQLITE_OK"} {}
-      ota close
+      sqlite3rbu rbu test.db rbu.db
+      while {[rbu step]=="SQLITE_OK"} {}
+      rbu close
     } -test {
       faultsim_test_result {*}$::reslist
       if {$testrc==0} {
@@ -176,46 +176,46 @@ foreach {tn2 setup sql expect} {
 
     for {set iStep 0} {$iStep<=21} {incr iStep} {
     
-      forcedelete test.db-journal test.db-wal ota.db-journal ota.db-wal
+      forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
     
       copy_if_exists test.db.bak test.db
-      copy_if_exists ota.db.bak ota.db
+      copy_if_exists rbu.db.bak rbu.db
     
-      sqlite3ota ota test.db ota.db
-      for {set x 0} {$x < $::iStep} {incr x} { ota step }
-      ota close
+      sqlite3rbu rbu test.db rbu.db
+      for {set x 0} {$x < $::iStep} {incr x} { rbu step }
+      rbu close
   
-# sqlite3 x ota.db ; puts "XYZ [x eval { SELECT * FROM ota_state } ]" ; x close
+# sqlite3 x rbu.db ; puts "XYZ [x eval { SELECT * FROM rbu_state } ]" ; x close
     
       copy_if_exists test.db     test.db.bak.2
       copy_if_exists test.db-wal test.db.bak.2-wal
       copy_if_exists test.db-oal test.db.bak.2-oal
-      copy_if_exists ota.db      ota.db.bak.2
+      copy_if_exists rbu.db      rbu.db.bak.2
     
       do_faultsim_test 3.$tn.$iStep -faults $::f -prep {
         catch { db close }
-        forcedelete test.db-journal test.db-wal ota.db-journal ota.db-wal
+        forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
         copy_if_exists test.db.bak.2 test.db
         copy_if_exists test.db.bak.2-wal test.db-wal
         copy_if_exists test.db.bak.2-oal test.db-oal
-        copy_if_exists ota.db.bak.2  ota.db
+        copy_if_exists rbu.db.bak.2  rbu.db
       } -body {
-        sqlite3ota ota test.db ota.db
-        ota step
-        ota close
+        sqlite3rbu rbu test.db rbu.db
+        rbu step
+        rbu close
       } -test {
 
         if {$testresult=="SQLITE_OK"} {set testresult "SQLITE_DONE"}
         faultsim_test_result {*}$::reslist
       
         if {$testrc==0} {
-          # No error occurred. If the OTA has not already been fully applied,
+          # No error occurred. If the RBU has not already been fully applied,
           # apply the rest of it now. Then ensure that the final state of the
           # target db is as expected. And that "PRAGMA integrity_check"
           # passes.
-          sqlite3ota ota test.db ota.db
-          while {[ota step] == "SQLITE_OK"} {}
-          ota close
+          sqlite3rbu rbu test.db rbu.db
+          while {[rbu step] == "SQLITE_OK"} {}
+          rbu close
 
           sqlite3 db test.db
           faultsim_integrity_check
diff --git a/ext/ota/otafault2.test b/ext/rbu/rbufault2.test
similarity index 78%
rename from ext/ota/otafault2.test
rename to ext/rbu/rbufault2.test
index 659cfec1f8..ec89397fdc 100644
--- a/ext/ota/otafault2.test
+++ b/ext/rbu/rbufault2.test
@@ -15,33 +15,33 @@ if {![info exists testdir]} {
 }
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl
-set ::testprefix otafault2
+set ::testprefix rbufault2
 
-forcedelete ota.db
+forcedelete rbu.db
 do_execsql_test 1.0 {
   CREATE TABLE target(x UNIQUE, y, z, PRIMARY KEY(y));
   INSERT INTO target VALUES(1, 2, 3);
   INSERT INTO target VALUES(4, 5, 6);
 
-  ATTACH 'ota.db' AS ota;
-  CREATE TABLE ota.data_target(x, y, z, ota_control);
+  ATTACH 'rbu.db' AS rbu;
+  CREATE TABLE rbu.data_target(x, y, z, rbu_control);
   INSERT INTO data_target VALUES(7, 8, 9, 0);
   INSERT INTO data_target VALUES(1, 11, 12, 0);
-  DETACH ota;
+  DETACH rbu;
 }
 db close
 
 forcecopy test.db test.db-bak 
-forcecopy ota.db ota.db-bak 
+forcecopy rbu.db rbu.db-bak 
 
 do_faultsim_test 1 -faults oom* -prep {
   forcecopy test.db-bak test.db
-  forcecopy ota.db-bak ota.db
-  forcedelete test.db-oal test.db-wal ota.db-journal
-  sqlite3ota ota test.db ota.db
+  forcecopy rbu.db-bak rbu.db
+  forcedelete test.db-oal test.db-wal rbu.db-journal
+  sqlite3rbu rbu test.db rbu.db
 } -body {
-  while {[ota step]=="SQLITE_OK"} { }
-  ota close
+  while {[rbu step]=="SQLITE_OK"} { }
+  rbu close
 } -test {
   faultsim_test_result      \
       {1 {SQLITE_CONSTRAINT - UNIQUE constraint failed: target.x}} \
diff --git a/ext/ota/sqlite3ota.c b/ext/rbu/sqlite3rbu.c
similarity index 69%
rename from ext/ota/sqlite3ota.c
rename to ext/rbu/sqlite3rbu.c
index b53d128994..491313ad9a 100644
--- a/ext/ota/sqlite3ota.c
+++ b/ext/rbu/sqlite3rbu.c
@@ -13,11 +13,11 @@
 **
 ** OVERVIEW 
 **
-**  The OTA extension requires that the OTA update be packaged as an
+**  The RBU extension requires that the RBU update be packaged as an
 **  SQLite database. The tables it expects to find are described in
-**  sqlite3ota.h.  Essentially, for each table xyz in the target database
+**  sqlite3rbu.h.  Essentially, for each table xyz in the target database
 **  that the user wishes to write to, a corresponding data_xyz table is
-**  created in the OTA database and populated with one row for each row to
+**  created in the RBU database and populated with one row for each row to
 **  update, insert or delete from the target table.
 ** 
 **  The update proceeds in three stages:
@@ -29,7 +29,7 @@
 **     "<database>-oal", they go on using the original database in
 **     rollback mode while the *-oal file is being generated.
 ** 
-**     During this stage OTA does not update the database by writing
+**     During this stage RBU does not update the database by writing
 **     directly to the target tables. Instead it creates "imposter"
 **     tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses
 **     to update each b-tree individually. All updates required by each
@@ -37,45 +37,45 @@
 **     updates are done in sorted key order.
 ** 
 **  2) The "<database>-oal" file is moved to the equivalent "<database>-wal"
-**     location using a call to rename(2). Before doing this the OTA
+**     location using a call to rename(2). Before doing this the RBU
 **     module takes an EXCLUSIVE lock on the database file, ensuring
 **     that there are no other active readers.
 ** 
 **     Once the EXCLUSIVE lock is released, any other database readers
 **     detect the new *-wal file and read the database in wal mode. At
 **     this point they see the new version of the database - including
-**     the updates made as part of the OTA update.
+**     the updates made as part of the RBU update.
 ** 
 **  3) The new *-wal file is checkpointed. This proceeds in the same way 
 **     as a regular database checkpoint, except that a single frame is
-**     checkpointed each time sqlite3ota_step() is called. If the OTA
+**     checkpointed each time sqlite3rbu_step() is called. If the RBU
 **     handle is closed before the entire *-wal file is checkpointed,
-**     the checkpoint progress is saved in the OTA database and the
-**     checkpoint can be resumed by another OTA client at some point in
+**     the checkpoint progress is saved in the RBU database and the
+**     checkpoint can be resumed by another RBU client at some point in
 **     the future.
 **
 ** POTENTIAL PROBLEMS
 ** 
-**  The rename() call might not be portable. And OTA is not currently
+**  The rename() call might not be portable. And RBU is not currently
 **  syncing the directory after renaming the file.
 **
 **  When state is saved, any commit to the *-oal file and the commit to
-**  the OTA update database are not atomic. So if the power fails at the
+**  the RBU update database are not atomic. So if the power fails at the
 **  wrong moment they might get out of sync. As the main database will be
-**  committed before the OTA update database this will likely either just
+**  committed before the RBU update database this will likely either just
 **  pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE
 **  constraint violations).
 **
-**  If some client does modify the target database mid OTA update, or some
-**  other error occurs, the OTA extension will keep throwing errors. It's
+**  If some client does modify the target database mid RBU update, or some
+**  other error occurs, the RBU extension will keep throwing errors. It's
 **  not really clear how to get out of this state. The system could just
-**  by delete the OTA update database and *-oal file and have the device
+**  by delete the RBU update database and *-oal file and have the device
 **  download the update again and start over.
 **
 **  At present, for an UPDATE, both the new.* and old.* records are
-**  collected in the ota_xyz table. And for both UPDATEs and DELETEs all
+**  collected in the rbu_xyz table. And for both UPDATEs and DELETEs all
 **  fields are collected.  This means we're probably writing a lot more
-**  data to disk when saving the state of an ongoing update to the OTA
+**  data to disk when saving the state of an ongoing update to the RBU
 **  update database than is strictly necessary.
 ** 
 */
@@ -83,15 +83,18 @@
 #include <assert.h>
 #include <string.h>
 #include <stdio.h>
-#include <unistd.h>
+
+#if !defined(_WIN32)
+#  include <unistd.h>
+#endif
 
 #include "sqlite3.h"
 
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_OTA)
-#include "sqlite3ota.h"
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
+#include "sqlite3rbu.h"
 
 /* Maximum number of prepared UPDATE statements held by this module */
-#define SQLITE_OTA_UPDATE_CACHESIZE 16
+#define SQLITE_RBU_UPDATE_CACHESIZE 16
 
 /*
 ** Swap two objects of type TYPE.
@@ -101,74 +104,74 @@
 #endif
 
 /*
-** The ota_state table is used to save the state of a partially applied
+** The rbu_state table is used to save the state of a partially applied
 ** update so that it can be resumed later. The table consists of integer
 ** keys mapped to values as follows:
 **
-** OTA_STATE_STAGE:
+** RBU_STATE_STAGE:
 **   May be set to integer values 1, 2, 4 or 5. As follows:
-**       1: the *-ota file is currently under construction.
-**       2: the *-ota file has been constructed, but not yet moved 
+**       1: the *-rbu file is currently under construction.
+**       2: the *-rbu file has been constructed, but not yet moved 
 **          to the *-wal path.
 **       4: the checkpoint is underway.
-**       5: the ota update has been checkpointed.
+**       5: the rbu update has been checkpointed.
 **
-** OTA_STATE_TBL:
+** RBU_STATE_TBL:
 **   Only valid if STAGE==1. The target database name of the table 
 **   currently being written.
 **
-** OTA_STATE_IDX:
+** RBU_STATE_IDX:
 **   Only valid if STAGE==1. The target database name of the index 
 **   currently being written, or NULL if the main table is currently being
 **   updated.
 **
-** OTA_STATE_ROW:
+** RBU_STATE_ROW:
 **   Only valid if STAGE==1. Number of rows already processed for the current
 **   table/index.
 **
-** OTA_STATE_PROGRESS:
-**   Total number of sqlite3ota_step() calls made so far as part of this
-**   ota update.
+** RBU_STATE_PROGRESS:
+**   Trbul number of sqlite3rbu_step() calls made so far as part of this
+**   rbu update.
 **
-** OTA_STATE_CKPT:
+** RBU_STATE_CKPT:
 **   Valid if STAGE==4. The 64-bit checksum associated with the wal-index
 **   header created by recovering the *-wal file. This is used to detect
 **   cases when another client appends frames to the *-wal file in the
 **   middle of an incremental checkpoint (an incremental checkpoint cannot
 **   be continued if this happens).
 **
-** OTA_STATE_COOKIE:
+** RBU_STATE_COOKIE:
 **   Valid if STAGE==1. The current change-counter cookie value in the 
 **   target db file.
 **
-** OTA_STATE_OALSZ:
+** RBU_STATE_OALSZ:
 **   Valid if STAGE==1. The size in bytes of the *-oal file.
 */
-#define OTA_STATE_STAGE       1
-#define OTA_STATE_TBL         2
-#define OTA_STATE_IDX         3
-#define OTA_STATE_ROW         4
-#define OTA_STATE_PROGRESS    5
-#define OTA_STATE_CKPT        6
-#define OTA_STATE_COOKIE      7
-#define OTA_STATE_OALSZ       8
+#define RBU_STATE_STAGE       1
+#define RBU_STATE_TBL         2
+#define RBU_STATE_IDX         3
+#define RBU_STATE_ROW         4
+#define RBU_STATE_PROGRESS    5
+#define RBU_STATE_CKPT        6
+#define RBU_STATE_COOKIE      7
+#define RBU_STATE_OALSZ       8
 
-#define OTA_STAGE_OAL         1
-#define OTA_STAGE_MOVE        2
-#define OTA_STAGE_CAPTURE     3
-#define OTA_STAGE_CKPT        4
-#define OTA_STAGE_DONE        5
+#define RBU_STAGE_OAL         1
+#define RBU_STAGE_MOVE        2
+#define RBU_STAGE_CAPTURE     3
+#define RBU_STAGE_CKPT        4
+#define RBU_STAGE_DONE        5
 
 
-#define OTA_CREATE_STATE \
-  "CREATE TABLE IF NOT EXISTS %s.ota_state(k INTEGER PRIMARY KEY, v)"
+#define RBU_CREATE_STATE \
+  "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"
 
-typedef struct OtaFrame OtaFrame;
-typedef struct OtaObjIter OtaObjIter;
-typedef struct OtaState OtaState;
-typedef struct ota_vfs ota_vfs;
-typedef struct ota_file ota_file;
-typedef struct OtaUpdateStmt OtaUpdateStmt;
+typedef struct RbuFrame RbuFrame;
+typedef struct RbuObjIter RbuObjIter;
+typedef struct RbuState RbuState;
+typedef struct rbu_vfs rbu_vfs;
+typedef struct rbu_file rbu_file;
+typedef struct RbuUpdateStmt RbuUpdateStmt;
 
 #if !defined(SQLITE_AMALGAMATION)
 typedef unsigned int u32;
@@ -186,9 +189,9 @@ typedef sqlite3_int64 i64;
 #define WAL_LOCK_READ0  3
 
 /*
-** A structure to store values read from the ota_state table in memory.
+** A structure to store values read from the rbu_state table in memory.
 */
-struct OtaState {
+struct RbuState {
   int eStage;
   char *zTbl;
   char *zIdx;
@@ -199,10 +202,10 @@ struct OtaState {
   i64 iOalSz;
 };
 
-struct OtaUpdateStmt {
+struct RbuUpdateStmt {
   char *zMask;                    /* Copy of update mask used with pUpdate */
   sqlite3_stmt *pUpdate;          /* Last update statement (or NULL) */
-  OtaUpdateStmt *pNext;
+  RbuUpdateStmt *pNext;
 };
 
 /*
@@ -221,7 +224,7 @@ struct OtaUpdateStmt {
 **   index. Or clear otherwise.
 **   
 */
-struct OtaObjIter {
+struct RbuObjIter {
   sqlite3_stmt *pTblIter;         /* Iterate through tables */
   sqlite3_stmt *pIdxIter;         /* Index iterator */
   int nTblCol;                    /* Size of azTblCol[] array */
@@ -231,7 +234,7 @@ struct OtaObjIter {
   u8 *abTblPk;                    /* Array of flags, set on target PK columns */
   u8 *abNotNull;                  /* Array of flags, set on NOT NULL columns */
   u8 *abIndexed;                  /* Array of flags, set on indexed & PK cols */
-  int eType;                      /* Table type - an OTA_PK_XXX value */
+  int eType;                      /* Table type - an RBU_PK_XXX value */
 
   /* Output variables. zTbl==0 implies EOF. */
   int bCleanup;                   /* True in "cleanup" state */
@@ -241,19 +244,19 @@ struct OtaObjIter {
   int iPkTnum;                    /* If eType==EXTERNAL, root of PK index */
   int bUnique;                    /* Current index is unique */
 
-  /* Statements created by otaObjIterPrepareAll() */
+  /* Statements created by rbuObjIterPrepareAll() */
   int nCol;                       /* Number of columns in current object */
   sqlite3_stmt *pSelect;          /* Source data */
   sqlite3_stmt *pInsert;          /* Statement for INSERT operations */
   sqlite3_stmt *pDelete;          /* Statement for DELETE ops */
-  sqlite3_stmt *pTmpInsert;       /* Insert into ota_tmp_$zTbl */
+  sqlite3_stmt *pTmpInsert;       /* Insert into rbu_tmp_$zTbl */
 
   /* Last UPDATE used (for PK b-tree updates only), or NULL. */
-  OtaUpdateStmt *pOtaUpdate;
+  RbuUpdateStmt *pRbuUpdate;
 };
 
 /*
-** Values for OtaObjIter.eType
+** Values for RbuObjIter.eType
 **
 **     0: Table does not exist (error)
 **     1: Table has an implicit rowid.
@@ -262,86 +265,86 @@ struct OtaObjIter {
 **     4: Table is WITHOUT ROWID.
 **     5: Table is a virtual table.
 */
-#define OTA_PK_NOTABLE        0
-#define OTA_PK_NONE           1
-#define OTA_PK_IPK            2
-#define OTA_PK_EXTERNAL       3
-#define OTA_PK_WITHOUT_ROWID  4
-#define OTA_PK_VTAB           5
+#define RBU_PK_NOTABLE        0
+#define RBU_PK_NONE           1
+#define RBU_PK_IPK            2
+#define RBU_PK_EXTERNAL       3
+#define RBU_PK_WITHOUT_ROWID  4
+#define RBU_PK_VTAB           5
 
 
 /*
-** Within the OTA_STAGE_OAL stage, each call to sqlite3ota_step() performs
+** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs
 ** one of the following operations.
 */
-#define OTA_INSERT     1          /* Insert on a main table b-tree */
-#define OTA_DELETE     2          /* Delete a row from a main table b-tree */
-#define OTA_IDX_DELETE 3          /* Delete a row from an aux. index b-tree */
-#define OTA_IDX_INSERT 4          /* Insert on an aux. index b-tree */
-#define OTA_UPDATE     5          /* Update a row in a main table b-tree */
+#define RBU_INSERT     1          /* Insert on a main table b-tree */
+#define RBU_DELETE     2          /* Delete a row from a main table b-tree */
+#define RBU_IDX_DELETE 3          /* Delete a row from an aux. index b-tree */
+#define RBU_IDX_INSERT 4          /* Insert on an aux. index b-tree */
+#define RBU_UPDATE     5          /* Update a row in a main table b-tree */
 
 
 /*
 ** A single step of an incremental checkpoint - frame iWalFrame of the wal
 ** file should be copied to page iDbPage of the database file.
 */
-struct OtaFrame {
+struct RbuFrame {
   u32 iDbPage;
   u32 iWalFrame;
 };
 
 /*
-** OTA handle.
+** RBU handle.
 */
-struct sqlite3ota {
-  int eStage;                     /* Value of OTA_STATE_STAGE field */
+struct sqlite3rbu {
+  int eStage;                     /* Value of RBU_STATE_STAGE field */
   sqlite3 *dbMain;                /* target database handle */
-  sqlite3 *dbOta;                 /* ota database handle */
+  sqlite3 *dbRbu;                 /* rbu database handle */
   char *zTarget;                  /* Path to target db */
-  char *zOta;                     /* Path to ota db */
-  char *zState;                   /* Path to state db (or NULL if zOta) */
+  char *zRbu;                     /* Path to rbu db */
+  char *zState;                   /* Path to state db (or NULL if zRbu) */
   char zStateDb[5];               /* Db name for state ("stat" or "main") */
-  int rc;                         /* Value returned by last ota_step() call */
+  int rc;                         /* Value returned by last rbu_step() call */
   char *zErrmsg;                  /* Error message if rc!=SQLITE_OK */
   int nStep;                      /* Rows processed for current object */
   int nProgress;                  /* Rows processed for all objects */
-  OtaObjIter objiter;             /* Iterator for skipping through tbl/idx */
-  const char *zVfsName;           /* Name of automatically created ota vfs */
-  ota_file *pTargetFd;            /* File handle open on target db */
+  RbuObjIter objiter;             /* Iterator for skipping through tbl/idx */
+  const char *zVfsName;           /* Name of automatically created rbu vfs */
+  rbu_file *pTargetFd;            /* File handle open on target db */
   i64 iOalSz;
 
   /* The following state variables are used as part of the incremental
-  ** checkpoint stage (eStage==OTA_STAGE_CKPT). See comments surrounding
-  ** function otaSetupCheckpoint() for details.  */
+  ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
+  ** function rbuSetupCheckpoint() for details.  */
   u32 iMaxFrame;                  /* Largest iWalFrame value in aFrame[] */
   u32 mLock;
   int nFrame;                     /* Entries in aFrame[] array */
   int nFrameAlloc;                /* Allocated size of aFrame[] array */
-  OtaFrame *aFrame;
+  RbuFrame *aFrame;
   int pgsz;
   u8 *aBuf;
   i64 iWalCksum;
 };
 
 /*
-** An ota VFS is implemented using an instance of this structure.
+** An rbu VFS is implemented using an instance of this structure.
 */
-struct ota_vfs {
-  sqlite3_vfs base;               /* ota VFS shim methods */
+struct rbu_vfs {
+  sqlite3_vfs base;               /* rbu VFS shim methods */
   sqlite3_vfs *pRealVfs;          /* Underlying VFS */
   sqlite3_mutex *mutex;           /* Mutex to protect pMain */
-  ota_file *pMain;                /* Linked list of main db files */
+  rbu_file *pMain;                /* Linked list of main db files */
 };
 
 /*
-** Each file opened by an ota VFS is represented by an instance of
+** Each file opened by an rbu VFS is represented by an instance of
 ** the following structure.
 */
-struct ota_file {
+struct rbu_file {
   sqlite3_file base;              /* sqlite3_file methods */
   sqlite3_file *pReal;            /* Underlying file handle */
-  ota_vfs *pOtaVfs;               /* Pointer to the ota_vfs object */
-  sqlite3ota *pOta;               /* Pointer to ota object (ota target only) */
+  rbu_vfs *pRbuVfs;               /* Pointer to the rbu_vfs object */
+  sqlite3rbu *pRbu;               /* Pointer to rbu object (rbu target only) */
 
   int openFlags;                  /* Flags this file was opened with */
   u32 iCookie;                    /* Cookie value for main db files */
@@ -352,8 +355,8 @@ struct ota_file {
   char *zDel;                     /* Delete this when closing file */
 
   const char *zWal;               /* Wal filename for this main db file */
-  ota_file *pWalFd;               /* Wal file descriptor for this main db */
-  ota_file *pMainNext;            /* Next MAIN_DB file */
+  rbu_file *pWalFd;               /* Wal file descriptor for this main db */
+  rbu_file *pMainNext;            /* Next MAIN_DB file */
 };
 
 
@@ -431,10 +434,10 @@ static int prepareFreeAndCollectError(
 }
 
 /*
-** Free the OtaObjIter.azTblCol[] and OtaObjIter.abTblPk[] arrays allocated
-** by an earlier call to otaObjIterCacheTableInfo().
+** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated
+** by an earlier call to rbuObjIterCacheTableInfo().
 */
-static void otaObjIterFreeCols(OtaObjIter *pIter){
+static void rbuObjIterFreeCols(RbuObjIter *pIter){
   int i;
   for(i=0; i<pIter->nTblCol; i++){
     sqlite3_free(pIter->azTblCol[i]);
@@ -454,16 +457,16 @@ static void otaObjIterFreeCols(OtaObjIter *pIter){
 ** Finalize all statements and free all allocations that are specific to
 ** the current object (table/index pair).
 */
-static void otaObjIterClearStatements(OtaObjIter *pIter){
-  OtaUpdateStmt *pUp;
+static void rbuObjIterClearStatements(RbuObjIter *pIter){
+  RbuUpdateStmt *pUp;
 
   sqlite3_finalize(pIter->pSelect);
   sqlite3_finalize(pIter->pInsert);
   sqlite3_finalize(pIter->pDelete);
   sqlite3_finalize(pIter->pTmpInsert);
-  pUp = pIter->pOtaUpdate;
+  pUp = pIter->pRbuUpdate;
   while( pUp ){
-    OtaUpdateStmt *pTmp = pUp->pNext;
+    RbuUpdateStmt *pTmp = pUp->pNext;
     sqlite3_finalize(pUp->pUpdate);
     sqlite3_free(pUp);
     pUp = pTmp;
@@ -472,7 +475,7 @@ static void otaObjIterClearStatements(OtaObjIter *pIter){
   pIter->pSelect = 0;
   pIter->pInsert = 0;
   pIter->pDelete = 0;
-  pIter->pOtaUpdate = 0;
+  pIter->pRbuUpdate = 0;
   pIter->pTmpInsert = 0;
   pIter->nCol = 0;
 }
@@ -481,12 +484,12 @@ static void otaObjIterClearStatements(OtaObjIter *pIter){
 ** Clean up any resources allocated as part of the iterator object passed
 ** as the only argument.
 */
-static void otaObjIterFinalize(OtaObjIter *pIter){
-  otaObjIterClearStatements(pIter);
+static void rbuObjIterFinalize(RbuObjIter *pIter){
+  rbuObjIterClearStatements(pIter);
   sqlite3_finalize(pIter->pTblIter);
   sqlite3_finalize(pIter->pIdxIter);
-  otaObjIterFreeCols(pIter);
-  memset(pIter, 0, sizeof(OtaObjIter));
+  rbuObjIterFreeCols(pIter);
+  memset(pIter, 0, sizeof(RbuObjIter));
 }
 
 /*
@@ -494,28 +497,28 @@ static void otaObjIterFinalize(OtaObjIter *pIter){
 **
 ** If no error occurs, SQLITE_OK is returned and the iterator is left 
 ** pointing to the next entry. Otherwise, an error code and message is 
-** left in the OTA handle passed as the first argument. A copy of the 
+** left in the RBU handle passed as the first argument. A copy of the 
 ** error code is returned.
 */
-static int otaObjIterNext(sqlite3ota *p, OtaObjIter *pIter){
+static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
   int rc = p->rc;
   if( rc==SQLITE_OK ){
 
     /* Free any SQLite statements used while processing the previous object */ 
-    otaObjIterClearStatements(pIter);
+    rbuObjIterClearStatements(pIter);
     if( pIter->zIdx==0 ){
       rc = sqlite3_exec(p->dbMain,
-          "DROP TRIGGER IF EXISTS temp.ota_insert_tr;"
-          "DROP TRIGGER IF EXISTS temp.ota_update1_tr;"
-          "DROP TRIGGER IF EXISTS temp.ota_update2_tr;"
-          "DROP TRIGGER IF EXISTS temp.ota_delete_tr;"
+          "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;"
+          "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;"
+          "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;"
+          "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;"
           , 0, 0, &p->zErrmsg
       );
     }
 
     if( rc==SQLITE_OK ){
       if( pIter->bCleanup ){
-        otaObjIterFreeCols(pIter);
+        rbuObjIterFreeCols(pIter);
         pIter->bCleanup = 0;
         rc = sqlite3_step(pIter->pTblIter);
         if( rc!=SQLITE_ROW ){
@@ -548,7 +551,7 @@ static int otaObjIterNext(sqlite3ota *p, OtaObjIter *pIter){
   }
 
   if( rc!=SQLITE_OK ){
-    otaObjIterFinalize(pIter);
+    rbuObjIterFinalize(pIter);
     p->rc = rc;
   }
   return rc;
@@ -559,16 +562,16 @@ static int otaObjIterNext(sqlite3ota *p, OtaObjIter *pIter){
 **
 ** If no error occurs, SQLITE_OK is returned and the iterator is left 
 ** pointing to the first entry. Otherwise, an error code and message is 
-** left in the OTA handle passed as the first argument. A copy of the 
+** left in the RBU handle passed as the first argument. A copy of the 
 ** error code is returned.
 */
-static int otaObjIterFirst(sqlite3ota *p, OtaObjIter *pIter){
+static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
   int rc;
-  memset(pIter, 0, sizeof(OtaObjIter));
+  memset(pIter, 0, sizeof(RbuObjIter));
 
-  rc = prepareAndCollectError(p->dbOta, &pIter->pTblIter, &p->zErrmsg, 
+  rc = prepareAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg, 
       "SELECT substr(name, 6) FROM sqlite_master "
-      "WHERE type='table' AND name LIKE 'data_%'"
+      "WHERE type IN ('table', 'view') AND name LIKE 'data_%'"
   );
 
   if( rc==SQLITE_OK ){
@@ -581,19 +584,19 @@ static int otaObjIterFirst(sqlite3ota *p, OtaObjIter *pIter){
 
   pIter->bCleanup = 1;
   p->rc = rc;
-  return otaObjIterNext(p, pIter);
+  return rbuObjIterNext(p, pIter);
 }
 
 /*
 ** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs,
-** an error code is stored in the OTA handle passed as the first argument.
+** an error code is stored in the RBU handle passed as the first argument.
 **
 ** If an error has already occurred (p->rc is already set to something other
 ** than SQLITE_OK), then this function returns NULL without modifying the
 ** stored error code. In this case it still calls sqlite3_free() on any 
 ** printf() parameters associated with %z conversions.
 */
-static char *otaMPrintf(sqlite3ota *p, const char *zFmt, ...){
+static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){
   char *zSql = 0;
   va_list ap;
   va_start(ap, zFmt);
@@ -612,16 +615,17 @@ static char *otaMPrintf(sqlite3ota *p, const char *zFmt, ...){
 ** Argument zFmt is a sqlite3_mprintf() style format string. The trailing
 ** arguments are the usual subsitution values. This function performs
 ** the printf() style substitutions and executes the result as an SQL
-** statement on the OTA handles database.
+** statement on the RBU handles database.
 **
 ** If an error occurs, an error code and error message is stored in the
-** OTA handle. If an error has already occurred when this function is
+** RBU handle. If an error has already occurred when this function is
 ** called, it is a no-op.
 */
-static int otaMPrintfExec(sqlite3ota *p, sqlite3 *db, const char *zFmt, ...){
+static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){
   va_list ap;
+  char *zSql;
   va_start(ap, zFmt);
-  char *zSql = sqlite3_vmprintf(zFmt, ap);
+  zSql = sqlite3_vmprintf(zFmt, ap);
   if( p->rc==SQLITE_OK ){
     if( zSql==0 ){
       p->rc = SQLITE_NOMEM;
@@ -639,12 +643,12 @@ static int otaMPrintfExec(sqlite3ota *p, sqlite3 *db, const char *zFmt, ...){
 ** bytes. 
 **
 ** If an error (i.e. an OOM condition) occurs, return NULL and leave an 
-** error code in the ota handle passed as the first argument. Or, if an 
+** error code in the rbu handle passed as the first argument. Or, if an 
 ** error has already occurred when this function is called, return NULL 
 ** immediately without attempting the allocation or modifying the stored
 ** error code.
 */
-static void *otaMalloc(sqlite3ota *p, int nByte){
+static void *rbuMalloc(sqlite3rbu *p, int nByte){
   void *pRet = 0;
   if( p->rc==SQLITE_OK ){
     assert( nByte>0 );
@@ -662,13 +666,13 @@ static void *otaMalloc(sqlite3ota *p, int nByte){
 /*
 ** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
 ** there is room for at least nCol elements. If an OOM occurs, store an
-** error code in the OTA handle passed as the first argument.
+** error code in the RBU handle passed as the first argument.
 */
-static void otaAllocateIterArrays(sqlite3ota *p, OtaObjIter *pIter, int nCol){
+static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
   int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
   char **azNew;
 
-  azNew = (char**)otaMalloc(p, nByte);
+  azNew = (char**)rbuMalloc(p, nByte);
   if( azNew ){
     pIter->azTblCol = azNew;
     pIter->azTblType = &azNew[nCol];
@@ -689,7 +693,7 @@ static void otaAllocateIterArrays(sqlite3ota *p, OtaObjIter *pIter, int nCol){
 ** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise,
 ** if the allocation succeeds, (*pRc) is left unchanged.
 */
-static char *otaStrndup(const char *zStr, int *pRc){
+static char *rbuStrndup(const char *zStr, int *pRc){
   char *zRet = 0;
 
   assert( *pRc==SQLITE_OK );
@@ -710,10 +714,10 @@ static char *otaStrndup(const char *zStr, int *pRc){
 ** Finalize the statement passed as the second argument.
 **
 ** If the sqlite3_finalize() call indicates that an error occurs, and the
-** ota handle error code is not already set, set the error code and error
+** rbu handle error code is not already set, set the error code and error
 ** message accordingly.
 */
-static void otaFinalize(sqlite3ota *p, sqlite3_stmt *pStmt){
+static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){
   sqlite3 *db = sqlite3_db_handle(pStmt);
   int rc = sqlite3_finalize(pStmt);
   if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
@@ -728,12 +732,12 @@ static void otaFinalize(sqlite3ota *p, sqlite3_stmt *pStmt){
 **   (int). This call sets the output parameter as follows, depending
 **   on the type of the table specified by parameters dbName and zTbl.
 **
-**     OTA_PK_NOTABLE:       No such table.
-**     OTA_PK_NONE:          Table has an implicit rowid.
-**     OTA_PK_IPK:           Table has an explicit IPK column.
-**     OTA_PK_EXTERNAL:      Table has an external PK index.
-**     OTA_PK_WITHOUT_ROWID: Table is WITHOUT ROWID.
-**     OTA_PK_VTAB:          Table is a virtual table.
+**     RBU_PK_NOTABLE:       No such table.
+**     RBU_PK_NONE:          Table has an implicit rowid.
+**     RBU_PK_IPK:           Table has an explicit IPK column.
+**     RBU_PK_EXTERNAL:      Table has an external PK index.
+**     RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID.
+**     RBU_PK_VTAB:          Table is a virtual table.
 **
 **   Argument *piPk is also of type (int*), and also points to an output
 **   parameter. Unless the table has an external primary key index 
@@ -745,24 +749,24 @@ static void otaFinalize(sqlite3ota *p, sqlite3_stmt *pStmt){
 ** ALGORITHM:
 **
 **   if( no entry exists in sqlite_master ){
-**     return OTA_PK_NOTABLE
+**     return RBU_PK_NOTABLE
 **   }else if( sql for the entry starts with "CREATE VIRTUAL" ){
-**     return OTA_PK_VTAB
+**     return RBU_PK_VTAB
 **   }else if( "PRAGMA index_list()" for the table contains a "pk" index ){
 **     if( the index that is the pk exists in sqlite_master ){
 **       *piPK = rootpage of that index.
-**       return OTA_PK_EXTERNAL
+**       return RBU_PK_EXTERNAL
 **     }else{
-**       return OTA_PK_WITHOUT_ROWID
+**       return RBU_PK_WITHOUT_ROWID
 **     }
 **   }else if( "PRAGMA table_info()" lists one or more "pk" columns ){
-**     return OTA_PK_IPK
+**     return RBU_PK_IPK
 **   }else{
-**     return OTA_PK_NONE
+**     return RBU_PK_NONE
 **   }
 */
-static void otaTableType(
-  sqlite3ota *p,
+static void rbuTableType(
+  sqlite3rbu *p,
   const char *zTab,
   int *peType,
   int *piTnum,
@@ -776,7 +780,7 @@ static void otaTableType(
   */
   sqlite3_stmt *aStmt[4] = {0, 0, 0, 0};
 
-  *peType = OTA_PK_NOTABLE;
+  *peType = RBU_PK_NOTABLE;
   *piPk = 0;
 
   assert( p->rc==SQLITE_OK );
@@ -788,18 +792,18 @@ static void otaTableType(
   ));
   if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){
     /* Either an error, or no such table. */
-    goto otaTableType_end;
+    goto rbuTableType_end;
   }
   if( sqlite3_column_int(aStmt[0], 0) ){
-    *peType = OTA_PK_VTAB;                     /* virtual table */
-    goto otaTableType_end;
+    *peType = RBU_PK_VTAB;                     /* virtual table */
+    goto rbuTableType_end;
   }
   *piTnum = sqlite3_column_int(aStmt[0], 1);
 
   p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg, 
     sqlite3_mprintf("PRAGMA index_list=%Q",zTab)
   );
-  if( p->rc ) goto otaTableType_end;
+  if( p->rc ) goto rbuTableType_end;
   while( sqlite3_step(aStmt[1])==SQLITE_ROW ){
     const u8 *zOrig = sqlite3_column_text(aStmt[1], 3);
     const u8 *zIdx = sqlite3_column_text(aStmt[1], 1);
@@ -811,12 +815,12 @@ static void otaTableType(
       if( p->rc==SQLITE_OK ){
         if( sqlite3_step(aStmt[2])==SQLITE_ROW ){
           *piPk = sqlite3_column_int(aStmt[2], 0);
-          *peType = OTA_PK_EXTERNAL;
+          *peType = RBU_PK_EXTERNAL;
         }else{
-          *peType = OTA_PK_WITHOUT_ROWID;
+          *peType = RBU_PK_WITHOUT_ROWID;
         }
       }
-      goto otaTableType_end;
+      goto rbuTableType_end;
     }
   }
 
@@ -826,26 +830,26 @@ static void otaTableType(
   if( p->rc==SQLITE_OK ){
     while( sqlite3_step(aStmt[3])==SQLITE_ROW ){
       if( sqlite3_column_int(aStmt[3],5)>0 ){
-        *peType = OTA_PK_IPK;                /* explicit IPK column */
-        goto otaTableType_end;
+        *peType = RBU_PK_IPK;                /* explicit IPK column */
+        goto rbuTableType_end;
       }
     }
-    *peType = OTA_PK_NONE;
+    *peType = RBU_PK_NONE;
   }
 
-otaTableType_end: {
+rbuTableType_end: {
     int i;
     for(i=0; i<sizeof(aStmt)/sizeof(aStmt[0]); i++){
-      otaFinalize(p, aStmt[i]);
+      rbuFinalize(p, aStmt[i]);
     }
   }
 }
 
 /*
-** This is a helper function for otaObjIterCacheTableInfo(). It populates
+** This is a helper function for rbuObjIterCacheTableInfo(). It populates
 ** the pIter->abIndexed[] array.
 */
-static void otaObjIterCacheIndexedCols(sqlite3ota *p, OtaObjIter *pIter){
+static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
   sqlite3_stmt *pList = 0;
   int bIndex = 0;
 
@@ -867,11 +871,11 @@ static void otaObjIterCacheIndexedCols(sqlite3ota *p, OtaObjIter *pIter){
       int iCid = sqlite3_column_int(pXInfo, 1);
       if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
     }
-    otaFinalize(p, pXInfo);
+    rbuFinalize(p, pXInfo);
     bIndex = 1;
   }
 
-  otaFinalize(p, pList);
+  rbuFinalize(p, pList);
   if( bIndex==0 ) pIter->abIndexed = 0;
 }
 
@@ -883,63 +887,63 @@ static void otaObjIterCacheIndexedCols(sqlite3ota *p, OtaObjIter *pIter){
 **
 ** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
 ** an error does occur, an error code and error message are also left in 
-** the OTA handle.
+** the RBU handle.
 */
-static int otaObjIterCacheTableInfo(sqlite3ota *p, OtaObjIter *pIter){
+static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
   if( pIter->azTblCol==0 ){
     sqlite3_stmt *pStmt = 0;
     int nCol = 0;
     int i;                        /* for() loop iterator variable */
-    int bOtaRowid = 0;            /* If input table has column "ota_rowid" */
+    int bRbuRowid = 0;            /* If input table has column "rbu_rowid" */
     int iOrder = 0;
     int iTnum = 0;
 
     /* Figure out the type of table this step will deal with. */
     assert( pIter->eType==0 );
-    otaTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
-    if( p->rc==SQLITE_OK && pIter->eType==OTA_PK_NOTABLE ){
+    rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
+    if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
       p->rc = SQLITE_ERROR;
       p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
     }
     if( p->rc ) return p->rc;
     if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
 
-    assert( pIter->eType==OTA_PK_NONE || pIter->eType==OTA_PK_IPK 
-         || pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_WITHOUT_ROWID
-         || pIter->eType==OTA_PK_VTAB
+    assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK 
+         || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
+         || pIter->eType==RBU_PK_VTAB
     );
 
     /* Populate the azTblCol[] and nTblCol variables based on the columns
     ** of the input table. Ignore any input table columns that begin with
-    ** "ota_".  */
-    p->rc = prepareFreeAndCollectError(p->dbOta, &pStmt, &p->zErrmsg, 
+    ** "rbu_".  */
+    p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, 
         sqlite3_mprintf("SELECT * FROM 'data_%q'", pIter->zTbl)
     );
     if( p->rc==SQLITE_OK ){
       nCol = sqlite3_column_count(pStmt);
-      otaAllocateIterArrays(p, pIter, nCol);
+      rbuAllocateIterArrays(p, pIter, nCol);
     }
     for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
       const char *zName = (const char*)sqlite3_column_name(pStmt, i);
-      if( sqlite3_strnicmp("ota_", zName, 4) ){
-        char *zCopy = otaStrndup(zName, &p->rc);
+      if( sqlite3_strnicmp("rbu_", zName, 4) ){
+        char *zCopy = rbuStrndup(zName, &p->rc);
         pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
         pIter->azTblCol[pIter->nTblCol++] = zCopy;
       }
-      else if( 0==sqlite3_stricmp("ota_rowid", zName) ){
-        bOtaRowid = 1;
+      else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
+        bRbuRowid = 1;
       }
     }
     sqlite3_finalize(pStmt);
     pStmt = 0;
 
     if( p->rc==SQLITE_OK
-     && bOtaRowid!=(pIter->eType==OTA_PK_VTAB || pIter->eType==OTA_PK_NONE)
+     && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
     ){
       p->rc = SQLITE_ERROR;
       p->zErrmsg = sqlite3_mprintf(
-          "table data_%q %s ota_rowid column", pIter->zTbl,
-          (bOtaRowid ? "may not have" : "requires")
+          "table data_%q %s rbu_rowid column", pIter->zTbl,
+          (bRbuRowid ? "may not have" : "requires")
       );
     }
 
@@ -972,16 +976,16 @@ static int otaObjIterCacheTableInfo(sqlite3ota *p, OtaObjIter *pIter){
           SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
         }
 
-        pIter->azTblType[iOrder] = otaStrndup(zType, &p->rc);
+        pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
         pIter->abTblPk[iOrder] = (iPk!=0);
         pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
         iOrder++;
       }
     }
 
-    otaFinalize(p, pStmt);
-    otaObjIterCacheIndexedCols(p, pIter);
-    assert( pIter->eType!=OTA_PK_VTAB || pIter->abIndexed==0 );
+    rbuFinalize(p, pStmt);
+    rbuObjIterCacheIndexedCols(p, pIter);
+    assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
   }
 
   return p->rc;
@@ -992,16 +996,16 @@ static int otaObjIterCacheTableInfo(sqlite3ota *p, OtaObjIter *pIter){
 ** string containing some SQL clause or list based on one or more of the 
 ** column names currently stored in the pIter->azTblCol[] array.
 */
-static char *otaObjIterGetCollist(
-  sqlite3ota *p,                  /* OTA object */
-  OtaObjIter *pIter               /* Object iterator for column names */
+static char *rbuObjIterGetCollist(
+  sqlite3rbu *p,                  /* RBU object */
+  RbuObjIter *pIter               /* Object iterator for column names */
 ){
   char *zList = 0;
   const char *zSep = "";
   int i;
   for(i=0; i<pIter->nTblCol; i++){
     const char *z = pIter->azTblCol[i];
-    zList = otaMPrintf(p, "%z%s\"%w\"", zList, zSep, z);
+    zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z);
     zSep = ", ";
   }
   return zList;
@@ -1010,7 +1014,7 @@ static char *otaObjIterGetCollist(
 /*
 ** This function is used to create a SELECT list (the list of SQL 
 ** expressions that follows a SELECT keyword) for a SELECT statement 
-** used to read from an data_xxx or ota_tmp_xxx table while updating the 
+** used to read from an data_xxx or rbu_tmp_xxx table while updating the 
 ** index object currently indicated by the iterator object passed as the 
 ** second argument. A "PRAGMA index_xinfo = <idxname>" statement is used 
 ** to obtain the required information.
@@ -1031,13 +1035,13 @@ static char *otaObjIterGetCollist(
 **   pzImposterPk: ...
 **   pzWhere: ...
 */
-static char *otaObjIterGetIndexCols(
-  sqlite3ota *p,                  /* OTA object */
-  OtaObjIter *pIter,              /* Object iterator for column names */
+static char *rbuObjIterGetIndexCols(
+  sqlite3rbu *p,                  /* RBU object */
+  RbuObjIter *pIter,              /* Object iterator for column names */
   char **pzImposterCols,          /* OUT: Columns for imposter table */
   char **pzImposterPk,            /* OUT: Imposter PK clause */
   char **pzWhere,                 /* OUT: WHERE clause */
-  int *pnBind                     /* OUT: Total number of columns */
+  int *pnBind                     /* OUT: Trbul number of columns */
 ){
   int rc = p->rc;                 /* Error code */
   int rc2;                        /* sqlite3_finalize() return code */
@@ -1066,14 +1070,14 @@ static char *otaObjIterGetIndexCols(
 
     if( iCid<0 ){
       /* An integer primary key. If the table has an explicit IPK, use
-      ** its name. Otherwise, use "ota_rowid".  */
-      if( pIter->eType==OTA_PK_IPK ){
+      ** its name. Otherwise, use "rbu_rowid".  */
+      if( pIter->eType==RBU_PK_IPK ){
         int i;
         for(i=0; pIter->abTblPk[i]==0; i++);
         assert( i<pIter->nTblCol );
         zCol = pIter->azTblCol[i];
       }else{
-        zCol = "ota_rowid";
+        zCol = "rbu_rowid";
       }
       zType = "INTEGER";
     }else{
@@ -1084,15 +1088,15 @@ static char *otaObjIterGetIndexCols(
     zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom, zCol, zCollate);
     if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
       const char *zOrder = (bDesc ? " DESC" : "");
-      zImpPK = sqlite3_mprintf("%z%s\"ota_imp_%d%w\"%s", 
+      zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s", 
           zImpPK, zCom, nBind, zCol, zOrder
       );
     }
-    zImpCols = sqlite3_mprintf("%z%s\"ota_imp_%d%w\" %s COLLATE %Q", 
+    zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q", 
         zImpCols, zCom, nBind, zCol, zType, zCollate
     );
     zWhere = sqlite3_mprintf(
-        "%z%s\"ota_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol
+        "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol
     );
     if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM;
     zCom = ", ";
@@ -1130,12 +1134,12 @@ static char *otaObjIterGetIndexCols(
 **
 ** With the column names escaped.
 **
-** For tables with implicit rowids - OTA_PK_EXTERNAL and OTA_PK_NONE, append
+** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append
 ** the text ", old._rowid_" to the returned value.
 */
-static char *otaObjIterGetOldlist(
-  sqlite3ota *p, 
-  OtaObjIter *pIter,
+static char *rbuObjIterGetOldlist(
+  sqlite3rbu *p, 
+  RbuObjIter *pIter,
   const char *zObj
 ){
   char *zList = 0;
@@ -1157,8 +1161,8 @@ static char *otaObjIterGetOldlist(
     }
 
     /* For a table with implicit rowids, append "old._rowid_" to the list. */
-    if( pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_NONE ){
-      zList = otaMPrintf(p, "%z, %s._rowid_", zList, zObj);
+    if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
+      zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj);
     }
   }
   return zList;
@@ -1174,24 +1178,24 @@ static char *otaObjIterGetOldlist(
 **
 **   "b = ?1 AND c = ?2"
 */
-static char *otaObjIterGetWhere(
-  sqlite3ota *p, 
-  OtaObjIter *pIter
+static char *rbuObjIterGetWhere(
+  sqlite3rbu *p, 
+  RbuObjIter *pIter
 ){
   char *zList = 0;
-  if( pIter->eType==OTA_PK_VTAB || pIter->eType==OTA_PK_NONE ){
-    zList = otaMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
-  }else if( pIter->eType==OTA_PK_EXTERNAL ){
+  if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
+    zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
+  }else if( pIter->eType==RBU_PK_EXTERNAL ){
     const char *zSep = "";
     int i;
     for(i=0; i<pIter->nTblCol; i++){
       if( pIter->abTblPk[i] ){
-        zList = otaMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1);
+        zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1);
         zSep = " AND ";
       }
     }
-    zList = otaMPrintf(p, 
-        "_rowid_ = (SELECT id FROM ota_imposter2 WHERE %z)", zList
+    zList = rbuMPrintf(p, 
+        "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList
     );
 
   }else{
@@ -1200,7 +1204,7 @@ static char *otaObjIterGetWhere(
     for(i=0; i<pIter->nTblCol; i++){
       if( pIter->abTblPk[i] ){
         const char *zCol = pIter->azTblCol[i];
-        zList = otaMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1);
+        zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1);
         zSep = " AND ";
       }
     }
@@ -1211,13 +1215,13 @@ static char *otaObjIterGetWhere(
 /*
 ** The SELECT statement iterating through the keys for the current object
 ** (p->objiter.pSelect) currently points to a valid row. However, there
-** is something wrong with the ota_control value in the ota_control value
+** is something wrong with the rbu_control value in the rbu_control value
 ** stored in the (p->nCol+1)'th column. Set the error code and error message
-** of the OTA handle to something reflecting this.
+** of the RBU handle to something reflecting this.
 */
-static void otaBadControlError(sqlite3ota *p){
+static void rbuBadControlError(sqlite3rbu *p){
   p->rc = SQLITE_ERROR;
-  p->zErrmsg = sqlite3_mprintf("invalid ota_control value");
+  p->zErrmsg = sqlite3_mprintf("invalid rbu_control value");
 }
 
 
@@ -1225,7 +1229,7 @@ static void otaBadControlError(sqlite3ota *p){
 ** Return a nul-terminated string containing the comma separated list of
 ** assignments that should be included following the "SET" keyword of
 ** an UPDATE statement used to update the table object that the iterator
-** passed as the second argument currently points to if the ota_control
+** passed as the second argument currently points to if the rbu_control
 ** column of the data_xxx table entry is set to zMask.
 **
 ** The memory for the returned string is obtained from sqlite3_malloc().
@@ -1233,14 +1237,14 @@ static void otaBadControlError(sqlite3ota *p){
 ** sqlite3_free(). 
 **
 ** If an OOM error is encountered when allocating space for the new
-** string, an error code is left in the ota handle passed as the first
+** string, an error code is left in the rbu handle passed as the first
 ** argument and NULL is returned. Or, if an error has already occurred
 ** when this function is called, NULL is returned immediately, without
 ** attempting the allocation or modifying the stored error code.
 */
-static char *otaObjIterGetSetlist(
-  sqlite3ota *p,
-  OtaObjIter *pIter,
+static char *rbuObjIterGetSetlist(
+  sqlite3rbu *p,
+  RbuObjIter *pIter,
   const char *zMask
 ){
   char *zList = 0;
@@ -1248,19 +1252,19 @@ static char *otaObjIterGetSetlist(
     int i;
 
     if( strlen(zMask)!=pIter->nTblCol ){
-      otaBadControlError(p);
+      rbuBadControlError(p);
     }else{
       const char *zSep = "";
       for(i=0; i<pIter->nTblCol; i++){
         char c = zMask[pIter->aiSrcOrder[i]];
         if( c=='x' ){
-          zList = otaMPrintf(p, "%z%s\"%w\"=?%d", 
+          zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", 
               zList, zSep, pIter->azTblCol[i], i+1
           );
           zSep = ", ";
         }
         if( c=='d' ){
-          zList = otaMPrintf(p, "%z%s\"%w\"=ota_delta(\"%w\", ?%d)", 
+          zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)", 
               zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
           );
           zSep = ", ";
@@ -1281,16 +1285,16 @@ static char *otaObjIterGetSetlist(
 ** sqlite3_free(). 
 **
 ** If an OOM error is encountered when allocating space for the new
-** string, an error code is left in the ota handle passed as the first
+** string, an error code is left in the rbu handle passed as the first
 ** argument and NULL is returned. Or, if an error has already occurred
 ** when this function is called, NULL is returned immediately, without
 ** attempting the allocation or modifying the stored error code.
 */
-static char *otaObjIterGetBindlist(sqlite3ota *p, int nBind){
+static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){
   char *zRet = 0;
   int nByte = nBind*2 + 1;
 
-  zRet = (char*)otaMalloc(p, nByte);
+  zRet = (char*)rbuMalloc(p, nByte);
   if( zRet ){
     int i;
     for(i=0; i<nBind; i++){
@@ -1303,7 +1307,7 @@ static char *otaObjIterGetBindlist(sqlite3ota *p, int nBind){
 
 /*
 ** The iterator currently points to a table (not index) of type 
-** OTA_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY 
+** RBU_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY 
 ** declaration for the corresponding imposter table. For example,
 ** if the iterator points to a table created as:
 **
@@ -1313,7 +1317,7 @@ static char *otaObjIterGetBindlist(sqlite3ota *p, int nBind){
 **
 **   PRIMARY KEY("b", "a" DESC)
 */
-static char *otaWithoutRowidPK(sqlite3ota *p, OtaObjIter *pIter){
+static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
   char *z = 0;
   assert( pIter->zIdx==0 );
   if( p->rc==SQLITE_OK ){
@@ -1336,19 +1340,19 @@ static char *otaWithoutRowidPK(sqlite3ota *p, OtaObjIter *pIter){
         break;
       }
     }
-    otaFinalize(p, pXList);
+    rbuFinalize(p, pXList);
 
     while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
       if( sqlite3_column_int(pXInfo, 5) ){
         /* int iCid = sqlite3_column_int(pXInfo, 0); */
         const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2);
         const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : "";
-        z = otaMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc);
+        z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc);
         zSep = ", ";
       }
     }
-    z = otaMPrintf(p, "%z)", z);
-    otaFinalize(p, pXInfo);
+    z = rbuMPrintf(p, "%z)", z);
+    rbuFinalize(p, pXInfo);
   }
   return z;
 }
@@ -1361,7 +1365,7 @@ static char *otaWithoutRowidPK(sqlite3ota *p, OtaObjIter *pIter){
 ** no-op. 
 **
 ** Assuming the iterator does point to a table with an external PK, this
-** function creates a WITHOUT ROWID imposter table named "ota_imposter2"
+** function creates a WITHOUT ROWID imposter table named "rbu_imposter2"
 ** used to access that PK index. For example, if the target table is
 ** declared as follows:
 **
@@ -1369,11 +1373,11 @@ static char *otaWithoutRowidPK(sqlite3ota *p, OtaObjIter *pIter){
 **
 ** then the imposter table schema is:
 **
-**   CREATE TABLE ota_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID;
+**   CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID;
 **
 */
-static void otaCreateImposterTable2(sqlite3ota *p, OtaObjIter *pIter){
-  if( p->rc==SQLITE_OK && pIter->eType==OTA_PK_EXTERNAL ){
+static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
+  if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
     int tnum = pIter->iPkTnum;    /* Root page of PK index */
     sqlite3_stmt *pQuery = 0;     /* SELECT name ... WHERE rootpage = $tnum */
     const char *zIdx = 0;         /* Name of PK index */
@@ -1399,7 +1403,7 @@ static void otaCreateImposterTable2(sqlite3ota *p, OtaObjIter *pIter){
           sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
       );
     }
-    otaFinalize(p, pQuery);
+    rbuFinalize(p, pQuery);
 
     while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
       int bKey = sqlite3_column_int(pXInfo, 5);
@@ -1407,19 +1411,19 @@ static void otaCreateImposterTable2(sqlite3ota *p, OtaObjIter *pIter){
         int iCid = sqlite3_column_int(pXInfo, 1);
         int bDesc = sqlite3_column_int(pXInfo, 3);
         const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
-        zCols = otaMPrintf(p, "%z%sc%d %s COLLATE %s", zCols, zComma, 
+        zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %s", zCols, zComma, 
             iCid, pIter->azTblType[iCid], zCollate
         );
-        zPk = otaMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":"");
+        zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":"");
         zComma = ", ";
       }
     }
-    zCols = otaMPrintf(p, "%z, id INTEGER", zCols);
-    otaFinalize(p, pXInfo);
+    zCols = rbuMPrintf(p, "%z, id INTEGER", zCols);
+    rbuFinalize(p, pXInfo);
 
     sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
-    otaMPrintfExec(p, p->dbMain,
-        "CREATE TABLE ota_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID", 
+    rbuMPrintfExec(p, p->dbMain,
+        "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID", 
         zCols, zPk
     );
     sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
@@ -1430,7 +1434,7 @@ static void otaCreateImposterTable2(sqlite3ota *p, OtaObjIter *pIter){
 ** If an error has already occurred when this function is called, it 
 ** immediately returns zero (without doing any work). Or, if an error
 ** occurs during the execution of this function, it sets the error code
-** in the sqlite3ota object indicated by the first argument and returns
+** in the sqlite3rbu object indicated by the first argument and returns
 ** zero.
 **
 ** The iterator passed as the second argument is guaranteed to point to
@@ -1439,15 +1443,15 @@ static void otaCreateImposterTable2(sqlite3ota *p, OtaObjIter *pIter){
 ** table b-tree of the table before returning. Non-zero is returned if
 ** an imposter table are created, or zero otherwise.
 **
-** An imposter table is required in all cases except OTA_PK_VTAB. Only
+** An imposter table is required in all cases except RBU_PK_VTAB. Only
 ** virtual tables are written to directly. The imposter table has the 
 ** same schema as the actual target table (less any UNIQUE constraints). 
 ** More precisely, the "same schema" means the same columns, types, 
 ** collation sequences. For tables that do not have an external PRIMARY
 ** KEY, it also means the same PRIMARY KEY declaration.
 */
-static void otaCreateImposterTable(sqlite3ota *p, OtaObjIter *pIter){
-  if( p->rc==SQLITE_OK && pIter->eType!=OTA_PK_VTAB ){
+static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
+  if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
     int tnum = pIter->iTnum;
     const char *zComma = "";
     char *zSql = 0;
@@ -1463,69 +1467,69 @@ static void otaCreateImposterTable(sqlite3ota *p, OtaObjIter *pIter){
           p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
       );
 
-      if( pIter->eType==OTA_PK_IPK && pIter->abTblPk[iCol] ){
+      if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
         /* If the target table column is an "INTEGER PRIMARY KEY", add
         ** "PRIMARY KEY" to the imposter table column declaration. */
         zPk = "PRIMARY KEY ";
       }
-      zSql = otaMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %s%s", 
+      zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %s%s", 
           zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
           (pIter->abNotNull[iCol] ? " NOT NULL" : "")
       );
       zComma = ", ";
     }
 
-    if( pIter->eType==OTA_PK_WITHOUT_ROWID ){
-      char *zPk = otaWithoutRowidPK(p, pIter);
+    if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
+      char *zPk = rbuWithoutRowidPK(p, pIter);
       if( zPk ){
-        zSql = otaMPrintf(p, "%z, %z", zSql, zPk);
+        zSql = rbuMPrintf(p, "%z, %z", zSql, zPk);
       }
     }
 
     sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
-    otaMPrintfExec(p, p->dbMain, "CREATE TABLE \"ota_imp_%w\"(%z)%s", 
+    rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s", 
         pIter->zTbl, zSql, 
-        (pIter->eType==OTA_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
+        (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
     );
     sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
   }
 }
 
 /*
-** Prepare a statement used to insert rows into the "ota_tmp_xxx" table.
+** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table.
 ** Specifically a statement of the form:
 **
-**     INSERT INTO ota_tmp_xxx VALUES(?, ?, ? ...);
+**     INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...);
 **
 ** The number of bound variables is equal to the number of columns in
-** the target table, plus one (for the ota_control column), plus one more 
-** (for the ota_rowid column) if the target table is an implicit IPK or 
+** the target table, plus one (for the rbu_control column), plus one more 
+** (for the rbu_rowid column) if the target table is an implicit IPK or 
 ** virtual table.
 */
-static void otaObjIterPrepareTmpInsert(
-  sqlite3ota *p, 
-  OtaObjIter *pIter,
+static void rbuObjIterPrepareTmpInsert(
+  sqlite3rbu *p, 
+  RbuObjIter *pIter,
   const char *zCollist,
-  const char *zOtaRowid
+  const char *zRbuRowid
 ){
-  int bOtaRowid = (pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_NONE);
-  char *zBind = otaObjIterGetBindlist(p, pIter->nTblCol + 1 + bOtaRowid);
+  int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
+  char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
   if( zBind ){
     assert( pIter->pTmpInsert==0 );
     p->rc = prepareFreeAndCollectError(
-        p->dbOta, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
-          "INSERT INTO %s.'ota_tmp_%q'(ota_control,%s%s) VALUES(%z)", 
-          p->zStateDb, pIter->zTbl, zCollist, zOtaRowid, zBind
+        p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
+          "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)", 
+          p->zStateDb, pIter->zTbl, zCollist, zRbuRowid, zBind
     ));
   }
 }
 
-static void otaTmpInsertFunc(
+static void rbuTmpInsertFunc(
   sqlite3_context *pCtx, 
   int nVal,
   sqlite3_value **apVal
 ){
-  sqlite3ota *p = sqlite3_user_data(pCtx);
+  sqlite3rbu *p = sqlite3_user_data(pCtx);
   int rc = SQLITE_OK;
   int i;
 
@@ -1547,13 +1551,13 @@ static void otaTmpInsertFunc(
 ** target database object currently indicated by the iterator passed 
 ** as the second argument are available.
 */
-static int otaObjIterPrepareAll(
-  sqlite3ota *p, 
-  OtaObjIter *pIter,
+static int rbuObjIterPrepareAll(
+  sqlite3rbu *p, 
+  RbuObjIter *pIter,
   int nOffset                     /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */
 ){
   assert( pIter->bCleanup==0 );
-  if( pIter->pSelect==0 && otaObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
+  if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
     const int tnum = pIter->iTnum;
     char *zCollist = 0;           /* List of indexed columns */
     char **pz = &p->zErrmsg;
@@ -1573,17 +1577,17 @@ static int otaObjIterPrepareAll(
       char *zBind = 0;
       int nBind = 0;
 
-      assert( pIter->eType!=OTA_PK_VTAB );
-      zCollist = otaObjIterGetIndexCols(
+      assert( pIter->eType!=RBU_PK_VTAB );
+      zCollist = rbuObjIterGetIndexCols(
           p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
       );
-      zBind = otaObjIterGetBindlist(p, nBind);
+      zBind = rbuObjIterGetBindlist(p, nBind);
 
       /* Create the imposter table used to write to this index. */
       sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1);
       sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum);
-      otaMPrintfExec(p, p->dbMain,
-          "CREATE TABLE \"ota_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID",
+      rbuMPrintfExec(p, p->dbMain,
+          "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID",
           zTbl, zImposterCols, zImposterPK
       );
       sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
@@ -1593,7 +1597,7 @@ static int otaObjIterPrepareAll(
       if( p->rc==SQLITE_OK ){
         p->rc = prepareFreeAndCollectError(
             p->dbMain, &pIter->pInsert, &p->zErrmsg,
-          sqlite3_mprintf("INSERT INTO \"ota_imp_%w\" VALUES(%s)", zTbl, zBind)
+          sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind)
         );
       }
 
@@ -1601,32 +1605,32 @@ static int otaObjIterPrepareAll(
       if( p->rc==SQLITE_OK ){
         p->rc = prepareFreeAndCollectError(
             p->dbMain, &pIter->pDelete, &p->zErrmsg,
-          sqlite3_mprintf("DELETE FROM \"ota_imp_%w\" WHERE %s", zTbl, zWhere)
+          sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere)
         );
       }
 
       /* Create the SELECT statement to read keys in sorted order */
       if( p->rc==SQLITE_OK ){
         char *zSql;
-        if( pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_NONE ){
+        if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
           zSql = sqlite3_mprintf(
-              "SELECT %s, ota_control FROM %s.'ota_tmp_%q' ORDER BY %s%s",
+              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' ORDER BY %s%s",
               zCollist, p->zStateDb, pIter->zTbl,
               zCollist, zLimit
           );
         }else{
           zSql = sqlite3_mprintf(
-              "SELECT %s, ota_control FROM 'data_%q' "
-              "WHERE typeof(ota_control)='integer' AND ota_control!=1 "
+              "SELECT %s, rbu_control FROM 'data_%q' "
+              "WHERE typeof(rbu_control)='integer' AND rbu_control!=1 "
               "UNION ALL "
-              "SELECT %s, ota_control FROM %s.'ota_tmp_%q' "
+              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' "
               "ORDER BY %s%s",
               zCollist, pIter->zTbl, 
               zCollist, p->zStateDb, pIter->zTbl, 
               zCollist, zLimit
           );
         }
-        p->rc = prepareFreeAndCollectError(p->dbOta, &pIter->pSelect, pz, zSql);
+        p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, zSql);
       }
 
       sqlite3_free(zImposterCols);
@@ -1634,39 +1638,39 @@ static int otaObjIterPrepareAll(
       sqlite3_free(zWhere);
       sqlite3_free(zBind);
     }else{
-      int bOtaRowid = (pIter->eType==OTA_PK_VTAB || pIter->eType==OTA_PK_NONE);
+      int bRbuRowid = (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE);
       const char *zTbl = pIter->zTbl;       /* Table this step applies to */
       const char *zWrite;                   /* Imposter table name */
 
-      char *zBindings = otaObjIterGetBindlist(p, pIter->nTblCol + bOtaRowid);
-      char *zWhere = otaObjIterGetWhere(p, pIter);
-      char *zOldlist = otaObjIterGetOldlist(p, pIter, "old");
-      char *zNewlist = otaObjIterGetOldlist(p, pIter, "new");
+      char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
+      char *zWhere = rbuObjIterGetWhere(p, pIter);
+      char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
+      char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
 
-      zCollist = otaObjIterGetCollist(p, pIter);
+      zCollist = rbuObjIterGetCollist(p, pIter);
       pIter->nCol = pIter->nTblCol;
 
       /* Create the SELECT statement to read keys from data_xxx */
       if( p->rc==SQLITE_OK ){
-        p->rc = prepareFreeAndCollectError(p->dbOta, &pIter->pSelect, pz,
+        p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
             sqlite3_mprintf(
-              "SELECT %s, ota_control%s FROM 'data_%q'%s", 
-              zCollist, (bOtaRowid ? ", ota_rowid" : ""), zTbl, zLimit
+              "SELECT %s, rbu_control%s FROM 'data_%q'%s", 
+              zCollist, (bRbuRowid ? ", rbu_rowid" : ""), zTbl, zLimit
             )
         );
       }
 
       /* Create the imposter table or tables (if required). */
-      otaCreateImposterTable(p, pIter);
-      otaCreateImposterTable2(p, pIter);
-      zWrite = (pIter->eType==OTA_PK_VTAB ? "" : "ota_imp_");
+      rbuCreateImposterTable(p, pIter);
+      rbuCreateImposterTable2(p, pIter);
+      zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
 
       /* Create the INSERT statement to write to the target PK b-tree */
       if( p->rc==SQLITE_OK ){
         p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
             sqlite3_mprintf(
               "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)", 
-              zWrite, zTbl, zCollist, (bOtaRowid ? ", _rowid_" : ""), zBindings
+              zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings
             )
         );
       }
@@ -1681,51 +1685,51 @@ static int otaObjIterPrepareAll(
       }
 
       if( pIter->abIndexed ){
-        const char *zOtaRowid = "";
-        if( pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_NONE ){
-          zOtaRowid = ", ota_rowid";
+        const char *zRbuRowid = "";
+        if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
+          zRbuRowid = ", rbu_rowid";
         }
 
-        /* Create the ota_tmp_xxx table and the triggers to populate it. */
-        otaMPrintfExec(p, p->dbOta,
-            "CREATE TABLE IF NOT EXISTS %s.'ota_tmp_%q' AS "
+        /* Create the rbu_tmp_xxx table and the triggers to populate it. */
+        rbuMPrintfExec(p, p->dbRbu,
+            "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS "
             "SELECT *%s FROM 'data_%q' WHERE 0;"
             , p->zStateDb
-            , zTbl, (pIter->eType==OTA_PK_EXTERNAL ? ", 0 AS ota_rowid" : "")
+            , zTbl, (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
             , zTbl
         );
 
-        otaMPrintfExec(p, p->dbMain,
-            "CREATE TEMP TRIGGER ota_delete_tr BEFORE DELETE ON \"%s%w\" "
+        rbuMPrintfExec(p, p->dbMain,
+            "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" "
             "BEGIN "
-            "  SELECT ota_tmp_insert(2, %s);"
+            "  SELECT rbu_tmp_insert(2, %s);"
             "END;"
 
-            "CREATE TEMP TRIGGER ota_update1_tr BEFORE UPDATE ON \"%s%w\" "
+            "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" "
             "BEGIN "
-            "  SELECT ota_tmp_insert(2, %s);"
+            "  SELECT rbu_tmp_insert(2, %s);"
             "END;"
 
-            "CREATE TEMP TRIGGER ota_update2_tr AFTER UPDATE ON \"%s%w\" "
+            "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" "
             "BEGIN "
-            "  SELECT ota_tmp_insert(3, %s);"
+            "  SELECT rbu_tmp_insert(3, %s);"
             "END;",
             zWrite, zTbl, zOldlist,
             zWrite, zTbl, zOldlist,
             zWrite, zTbl, zNewlist
         );
 
-        if( pIter->eType==OTA_PK_EXTERNAL || pIter->eType==OTA_PK_NONE ){
-          otaMPrintfExec(p, p->dbMain,
-              "CREATE TEMP TRIGGER ota_insert_tr AFTER INSERT ON \"%s%w\" "
+        if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
+          rbuMPrintfExec(p, p->dbMain,
+              "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" "
               "BEGIN "
-              "  SELECT ota_tmp_insert(0, %s);"
+              "  SELECT rbu_tmp_insert(0, %s);"
               "END;",
               zWrite, zTbl, zNewlist
           );
         }
 
-        otaObjIterPrepareTmpInsert(p, pIter, zCollist, zOtaRowid);
+        rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
       }
 
       sqlite3_free(zWhere);
@@ -1744,19 +1748,19 @@ static int otaObjIterPrepareAll(
 ** Set output variable *ppStmt to point to an UPDATE statement that may
 ** be used to update the imposter table for the main table b-tree of the
 ** table object that pIter currently points to, assuming that the 
-** ota_control column of the data_xyz table contains zMask.
+** rbu_control column of the data_xyz table contains zMask.
 ** 
 ** If the zMask string does not specify any columns to update, then this
 ** is not an error. Output variable *ppStmt is set to NULL in this case.
 */
-static int otaGetUpdateStmt(
-  sqlite3ota *p,                  /* OTA handle */
-  OtaObjIter *pIter,              /* Object iterator */
-  const char *zMask,              /* ota_control value ('x.x.') */
+static int rbuGetUpdateStmt(
+  sqlite3rbu *p,                  /* RBU handle */
+  RbuObjIter *pIter,              /* Object iterator */
+  const char *zMask,              /* rbu_control value ('x.x.') */
   sqlite3_stmt **ppStmt           /* OUT: UPDATE statement handle */
 ){
-  OtaUpdateStmt **pp;
-  OtaUpdateStmt *pUp = 0;
+  RbuUpdateStmt **pp;
+  RbuUpdateStmt *pUp = 0;
   int nUp = 0;
 
   /* In case an error occurs */
@@ -1766,12 +1770,12 @@ static int otaGetUpdateStmt(
   ** of the LRU queue and return immediately. Otherwise, leave nUp pointing
   ** to the number of statements currently in the cache and pUp to the
   ** last object in the list.  */
-  for(pp=&pIter->pOtaUpdate; *pp; pp=&((*pp)->pNext)){
+  for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
     pUp = *pp;
     if( strcmp(pUp->zMask, zMask)==0 ){
       *pp = pUp->pNext;
-      pUp->pNext = pIter->pOtaUpdate;
-      pIter->pOtaUpdate = pUp;
+      pUp->pNext = pIter->pRbuUpdate;
+      pIter->pRbuUpdate = pUp;
       *ppStmt = pUp->pUpdate; 
       return SQLITE_OK;
     }
@@ -1779,29 +1783,29 @@ static int otaGetUpdateStmt(
   }
   assert( pUp==0 || pUp->pNext==0 );
 
-  if( nUp>=SQLITE_OTA_UPDATE_CACHESIZE ){
-    for(pp=&pIter->pOtaUpdate; *pp!=pUp; pp=&((*pp)->pNext));
+  if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){
+    for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
     *pp = 0;
     sqlite3_finalize(pUp->pUpdate);
     pUp->pUpdate = 0;
   }else{
-    pUp = (OtaUpdateStmt*)otaMalloc(p, sizeof(OtaUpdateStmt)+pIter->nTblCol+1);
+    pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
   }
 
   if( pUp ){
-    char *zWhere = otaObjIterGetWhere(p, pIter);
-    char *zSet = otaObjIterGetSetlist(p, pIter, zMask);
+    char *zWhere = rbuObjIterGetWhere(p, pIter);
+    char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
     char *zUpdate = 0;
 
     pUp->zMask = (char*)&pUp[1];
     memcpy(pUp->zMask, zMask, pIter->nTblCol);
-    pUp->pNext = pIter->pOtaUpdate;
-    pIter->pOtaUpdate = pUp;
+    pUp->pNext = pIter->pRbuUpdate;
+    pIter->pRbuUpdate = pUp;
 
     if( zSet ){
       const char *zPrefix = "";
 
-      if( pIter->eType!=OTA_PK_VTAB ) zPrefix = "ota_imp_";
+      if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
       zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s", 
           zPrefix, pIter->zTbl, zSet, zWhere
       );
@@ -1817,7 +1821,7 @@ static int otaGetUpdateStmt(
   return p->rc;
 }
 
-static sqlite3 *otaOpenDbhandle(sqlite3ota *p, const char *zName){
+static sqlite3 *rbuOpenDbhandle(sqlite3rbu *p, const char *zName){
   sqlite3 *db = 0;
   if( p->rc==SQLITE_OK ){
     const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI;
@@ -1832,21 +1836,21 @@ static sqlite3 *otaOpenDbhandle(sqlite3ota *p, const char *zName){
 }
 
 /*
-** Open the database handle and attach the OTA database as "ota". If an
-** error occurs, leave an error code and message in the OTA handle.
+** Open the database handle and attach the RBU database as "rbu". If an
+** error occurs, leave an error code and message in the RBU handle.
 */
-static void otaOpenDatabase(sqlite3ota *p){
+static void rbuOpenDatabase(sqlite3rbu *p){
   assert( p->rc==SQLITE_OK );
-  assert( p->dbMain==0 && p->dbOta==0 );
+  assert( p->dbMain==0 && p->dbRbu==0 );
 
   p->eStage = 0;
-  p->dbMain = otaOpenDbhandle(p, p->zTarget);
-  p->dbOta = otaOpenDbhandle(p, p->zOta);
+  p->dbMain = rbuOpenDbhandle(p, p->zTarget);
+  p->dbRbu = rbuOpenDbhandle(p, p->zRbu);
 
-  /* If using separate OTA and state databases, attach the state database to
-  ** the OTA db handle now.  */
+  /* If using separate RBU and state databases, attach the state database to
+  ** the RBU db handle now.  */
   if( p->zState ){
-    otaMPrintfExec(p, p->dbOta, "ATTACH %Q AS stat", p->zState);
+    rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState);
     memcpy(p->zStateDb, "stat", 4);
   }else{
     memcpy(p->zStateDb, "main", 4);
@@ -1854,25 +1858,25 @@ static void otaOpenDatabase(sqlite3ota *p){
 
   if( p->rc==SQLITE_OK ){
     p->rc = sqlite3_create_function(p->dbMain, 
-        "ota_tmp_insert", -1, SQLITE_UTF8, (void*)p, otaTmpInsertFunc, 0, 0
+        "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0
     );
   }
 
   if( p->rc==SQLITE_OK ){
-    p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_OTA, (void*)p);
+    p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
   }
-  otaMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_master");
+  rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_master");
 
-  /* Mark the database file just opened as an OTA target database. If 
-  ** this call returns SQLITE_NOTFOUND, then the OTA vfs is not in use.
+  /* Mark the database file just opened as an RBU target database. If 
+  ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use.
   ** This is an error.  */
   if( p->rc==SQLITE_OK ){
-    p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_OTA, (void*)p);
+    p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
   }
 
   if( p->rc==SQLITE_NOTFOUND ){
     p->rc = SQLITE_ERROR;
-    p->zErrmsg = sqlite3_mprintf("ota vfs not found");
+    p->zErrmsg = sqlite3_mprintf("rbu vfs not found");
   }
 }
 
@@ -1896,7 +1900,7 @@ static void otaOpenDatabase(sqlite3ota *p){
 **     test.db-shm        =>   test.shm
 **     test.db-mj7f3319fa =>   test.9fa
 */
-static void otaFileSuffix3(const char *zBase, char *z){
+static void rbuFileSuffix3(const char *zBase, char *z){
 #ifdef SQLITE_ENABLE_8_3_NAMES
 #if SQLITE_ENABLE_8_3_NAMES<2
   if( sqlite3_uri_boolean(zBase, "8_3_names", 0) )
@@ -1917,7 +1921,7 @@ static void otaFileSuffix3(const char *zBase, char *z){
 ** The checksum is store in the first page of xShmMap memory as an 8-byte 
 ** blob starting at byte offset 40.
 */
-static i64 otaShmChecksum(sqlite3ota *p){
+static i64 rbuShmChecksum(sqlite3rbu *p){
   i64 iRet = 0;
   if( p->rc==SQLITE_OK ){
     sqlite3_file *pDb = p->pTargetFd->pReal;
@@ -1934,19 +1938,19 @@ static i64 otaShmChecksum(sqlite3ota *p){
 ** This function is called as part of initializing or reinitializing an
 ** incremental checkpoint. 
 **
-** It populates the sqlite3ota.aFrame[] array with the set of 
+** It populates the sqlite3rbu.aFrame[] array with the set of 
 ** (wal frame -> db page) copy operations required to checkpoint the 
 ** current wal file, and obtains the set of shm locks required to safely 
 ** perform the copy operations directly on the file-system.
 **
 ** If argument pState is not NULL, then the incremental checkpoint is
 ** being resumed. In this case, if the checksum of the wal-index-header
-** following recovery is not the same as the checksum saved in the OtaState
-** object, then the ota handle is set to DONE state. This occurs if some
+** following recovery is not the same as the checksum saved in the RbuState
+** object, then the rbu handle is set to DONE state. This occurs if some
 ** other client appends a transaction to the wal file in the middle of
 ** an incremental checkpoint.
 */
-static void otaSetupCheckpoint(sqlite3ota *p, OtaState *pState){
+static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
 
   /* If pState is NULL, then the wal file may not have been opened and
   ** recovered. Running a read-statement here to ensure that doing so
@@ -1959,8 +1963,8 @@ static void otaSetupCheckpoint(sqlite3ota *p, OtaState *pState){
   }
 
   /* Assuming no error has occurred, run a "restart" checkpoint with the
-  ** sqlite3ota.eStage variable set to CAPTURE. This turns on the following
-  ** special behaviour in the ota VFS:
+  ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following
+  ** special behaviour in the rbu VFS:
   **
   **   * If the exclusive shm WRITER or READ0 lock cannot be obtained,
   **     the checkpoint fails with SQLITE_BUSY (normally SQLite would
@@ -1968,7 +1972,7 @@ static void otaSetupCheckpoint(sqlite3ota *p, OtaState *pState){
   **
   **   * Attempts to read from the *-wal file or write to the database file
   **     do not perform any IO. Instead, the frame/page combinations that
-  **     would be read/written are recorded in the sqlite3ota.aFrame[]
+  **     would be read/written are recorded in the sqlite3rbu.aFrame[]
   **     array.
   **
   **   * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER, 
@@ -1988,72 +1992,72 @@ static void otaSetupCheckpoint(sqlite3ota *p, OtaState *pState){
   */
   if( p->rc==SQLITE_OK ){
     int rc2;
-    p->eStage = OTA_STAGE_CAPTURE;
+    p->eStage = RBU_STAGE_CAPTURE;
     rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0);
     if( rc2!=SQLITE_INTERNAL ) p->rc = rc2;
   }
 
   if( p->rc==SQLITE_OK ){
-    p->eStage = OTA_STAGE_CKPT;
+    p->eStage = RBU_STAGE_CKPT;
     p->nStep = (pState ? pState->nRow : 0);
-    p->aBuf = otaMalloc(p, p->pgsz);
-    p->iWalCksum = otaShmChecksum(p);
+    p->aBuf = rbuMalloc(p, p->pgsz);
+    p->iWalCksum = rbuShmChecksum(p);
   }
 
   if( p->rc==SQLITE_OK && pState && pState->iWalCksum!=p->iWalCksum ){
     p->rc = SQLITE_DONE;
-    p->eStage = OTA_STAGE_DONE;
+    p->eStage = RBU_STAGE_DONE;
   }
 }
 
 /*
 ** Called when iAmt bytes are read from offset iOff of the wal file while
-** the ota object is in capture mode. Record the frame number of the frame
+** the rbu object is in capture mode. Record the frame number of the frame
 ** being read in the aFrame[] array.
 */
-static int otaCaptureWalRead(sqlite3ota *pOta, i64 iOff, int iAmt){
+static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){
   const u32 mReq = (1<<WAL_LOCK_WRITE)|(1<<WAL_LOCK_CKPT)|(1<<WAL_LOCK_READ0);
   u32 iFrame;
 
-  if( pOta->mLock!=mReq ){
-    pOta->rc = SQLITE_BUSY;
+  if( pRbu->mLock!=mReq ){
+    pRbu->rc = SQLITE_BUSY;
     return SQLITE_INTERNAL;
   }
 
-  pOta->pgsz = iAmt;
-  if( pOta->nFrame==pOta->nFrameAlloc ){
-    int nNew = (pOta->nFrameAlloc ? pOta->nFrameAlloc : 64) * 2;
-    OtaFrame *aNew;
-    aNew = (OtaFrame*)sqlite3_realloc(pOta->aFrame, nNew * sizeof(OtaFrame));
+  pRbu->pgsz = iAmt;
+  if( pRbu->nFrame==pRbu->nFrameAlloc ){
+    int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
+    RbuFrame *aNew;
+    aNew = (RbuFrame*)sqlite3_realloc(pRbu->aFrame, nNew * sizeof(RbuFrame));
     if( aNew==0 ) return SQLITE_NOMEM;
-    pOta->aFrame = aNew;
-    pOta->nFrameAlloc = nNew;
+    pRbu->aFrame = aNew;
+    pRbu->nFrameAlloc = nNew;
   }
 
   iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1;
-  if( pOta->iMaxFrame<iFrame ) pOta->iMaxFrame = iFrame;
-  pOta->aFrame[pOta->nFrame].iWalFrame = iFrame;
-  pOta->aFrame[pOta->nFrame].iDbPage = 0;
-  pOta->nFrame++;
+  if( pRbu->iMaxFrame<iFrame ) pRbu->iMaxFrame = iFrame;
+  pRbu->aFrame[pRbu->nFrame].iWalFrame = iFrame;
+  pRbu->aFrame[pRbu->nFrame].iDbPage = 0;
+  pRbu->nFrame++;
   return SQLITE_OK;
 }
 
 /*
 ** Called when a page of data is written to offset iOff of the database
-** file while the ota handle is in capture mode. Record the page number 
+** file while the rbu handle is in capture mode. Record the page number 
 ** of the page being written in the aFrame[] array.
 */
-static int otaCaptureDbWrite(sqlite3ota *pOta, i64 iOff){
-  pOta->aFrame[pOta->nFrame-1].iDbPage = (u32)(iOff / pOta->pgsz) + 1;
+static int rbuCaptureDbWrite(sqlite3rbu *pRbu, i64 iOff){
+  pRbu->aFrame[pRbu->nFrame-1].iDbPage = (u32)(iOff / pRbu->pgsz) + 1;
   return SQLITE_OK;
 }
 
 /*
 ** This is called as part of an incremental checkpoint operation. Copy
 ** a single frame of data from the wal file into the database file, as
-** indicated by the OtaFrame object.
+** indicated by the RbuFrame object.
 */
-static void otaCheckpointFrame(sqlite3ota *p, OtaFrame *pFrame){
+static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){
   sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
   sqlite3_file *pDb = p->pTargetFd->pReal;
   i64 iOff;
@@ -2071,7 +2075,7 @@ static void otaCheckpointFrame(sqlite3ota *p, OtaFrame *pFrame){
 /*
 ** Take an EXCLUSIVE lock on the database file.
 */
-static void otaLockDatabase(sqlite3ota *p){
+static void rbuLockDatabase(sqlite3rbu *p){
   sqlite3_file *pReal = p->pTargetFd->pReal;
   assert( p->rc==SQLITE_OK );
   p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_SHARED);
@@ -2081,19 +2085,19 @@ static void otaLockDatabase(sqlite3ota *p){
 }
 
 /*
-** The OTA handle is currently in OTA_STAGE_OAL state, with a SHARED lock
+** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
 ** on the database file. This proc moves the *-oal file to the *-wal path,
 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
-** If an error occurs, leave an error code and error message in the ota 
+** If an error occurs, leave an error code and error message in the rbu 
 ** handle.
 */
-static void otaMoveOalFile(sqlite3ota *p){
+static void rbuMoveOalFile(sqlite3rbu *p){
   const char *zBase = sqlite3_db_filename(p->dbMain, "main");
 
   char *zWal = sqlite3_mprintf("%s-wal", zBase);
   char *zOal = sqlite3_mprintf("%s-oal", zBase);
 
-  assert( p->eStage==OTA_STAGE_MOVE );
+  assert( p->eStage==RBU_STAGE_MOVE );
   assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
   if( zWal==0 || zOal==0 ){
     p->rc = SQLITE_NOMEM;
@@ -2105,21 +2109,21 @@ static void otaMoveOalFile(sqlite3ota *p){
     ** In order to ensure that there are no database readers, an EXCLUSIVE
     ** lock is obtained here before the *-oal is moved to *-wal.
     */
-    otaLockDatabase(p);
+    rbuLockDatabase(p);
     if( p->rc==SQLITE_OK ){
-      otaFileSuffix3(zBase, zWal);
-      otaFileSuffix3(zBase, zOal);
+      rbuFileSuffix3(zBase, zWal);
+      rbuFileSuffix3(zBase, zOal);
 
       /* Re-open the databases. */
-      otaObjIterFinalize(&p->objiter);
+      rbuObjIterFinalize(&p->objiter);
       sqlite3_close(p->dbMain);
-      sqlite3_close(p->dbOta);
+      sqlite3_close(p->dbRbu);
       p->rc = rename(zOal, zWal) ? SQLITE_IOERR : SQLITE_OK;
       if( p->rc==SQLITE_OK ){
         p->dbMain = 0;
-        p->dbOta = 0;
-        otaOpenDatabase(p);
-        otaSetupCheckpoint(p, 0);
+        p->dbRbu = 0;
+        rbuOpenDatabase(p);
+        rbuSetupCheckpoint(p, 0);
       }
     }
   }
@@ -2134,32 +2138,32 @@ static void otaMoveOalFile(sqlite3ota *p){
 ** determines the type of operation requested by this row and returns
 ** one of the following values to indicate the result:
 **
-**     * OTA_INSERT
-**     * OTA_DELETE
-**     * OTA_IDX_DELETE
-**     * OTA_UPDATE
+**     * RBU_INSERT
+**     * RBU_DELETE
+**     * RBU_IDX_DELETE
+**     * RBU_UPDATE
 **
-** If OTA_UPDATE is returned, then output variable *pzMask is set to
+** If RBU_UPDATE is returned, then output variable *pzMask is set to
 ** point to the text value indicating the columns to update.
 **
-** If the ota_control field contains an invalid value, an error code and
-** message are left in the OTA handle and zero returned.
+** If the rbu_control field contains an invalid value, an error code and
+** message are left in the RBU handle and zero returned.
 */
-static int otaStepType(sqlite3ota *p, const char **pzMask){
-  int iCol = p->objiter.nCol;     /* Index of ota_control column */
+static int rbuStepType(sqlite3rbu *p, const char **pzMask){
+  int iCol = p->objiter.nCol;     /* Index of rbu_control column */
   int res = 0;                    /* Return value */
 
   switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
     case SQLITE_INTEGER: {
       int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
       if( iVal==0 ){
-        res = OTA_INSERT;
+        res = RBU_INSERT;
       }else if( iVal==1 ){
-        res = OTA_DELETE;
+        res = RBU_DELETE;
       }else if( iVal==2 ){
-        res = OTA_IDX_DELETE;
+        res = RBU_IDX_DELETE;
       }else if( iVal==3 ){
-        res = OTA_IDX_INSERT;
+        res = RBU_IDX_INSERT;
       }
       break;
     }
@@ -2171,7 +2175,7 @@ static int otaStepType(sqlite3ota *p, const char **pzMask){
       }else{
         *pzMask = (const char*)z;
       }
-      res = OTA_UPDATE;
+      res = RBU_UPDATE;
 
       break;
     }
@@ -2181,7 +2185,7 @@ static int otaStepType(sqlite3ota *p, const char **pzMask){
   }
 
   if( res==0 ){
-    otaBadControlError(p);
+    rbuBadControlError(p);
   }
   return res;
 }
@@ -2199,41 +2203,41 @@ static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
 #endif
 
 /*
-** This function does the work for an sqlite3ota_step() call.
+** This function does the work for an sqlite3rbu_step() call.
 **
 ** The object-iterator (p->objiter) currently points to a valid object,
 ** and the input cursor (p->objiter.pSelect) currently points to a valid
 ** input row. Perform whatever processing is required and return.
 **
 ** If no  error occurs, SQLITE_OK is returned. Otherwise, an error code
-** and message is left in the OTA handle and a copy of the error code
+** and message is left in the RBU handle and a copy of the error code
 ** returned.
 */
-static int otaStep(sqlite3ota *p){
-  OtaObjIter *pIter = &p->objiter;
+static int rbuStep(sqlite3rbu *p){
+  RbuObjIter *pIter = &p->objiter;
   const char *zMask = 0;
   int i;
-  int eType = otaStepType(p, &zMask);
+  int eType = rbuStepType(p, &zMask);
 
   if( eType ){
-    assert( eType!=OTA_UPDATE || pIter->zIdx==0 );
+    assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
 
-    if( pIter->zIdx==0 && eType==OTA_IDX_DELETE ){
-      otaBadControlError(p);
+    if( pIter->zIdx==0 && eType==RBU_IDX_DELETE ){
+      rbuBadControlError(p);
     }
     else if( 
-        eType==OTA_INSERT 
-     || eType==OTA_DELETE
-     || eType==OTA_IDX_DELETE 
-     || eType==OTA_IDX_INSERT
+        eType==RBU_INSERT 
+     || eType==RBU_DELETE
+     || eType==RBU_IDX_DELETE 
+     || eType==RBU_IDX_INSERT
     ){
       sqlite3_value *pVal;
       sqlite3_stmt *pWriter;
 
-      assert( eType!=OTA_UPDATE );
-      assert( eType!=OTA_DELETE || pIter->zIdx==0 );
+      assert( eType!=RBU_UPDATE );
+      assert( eType!=RBU_DELETE || pIter->zIdx==0 );
 
-      if( eType==OTA_IDX_DELETE || eType==OTA_DELETE ){
+      if( eType==RBU_IDX_DELETE || eType==RBU_DELETE ){
         pWriter = pIter->pDelete;
       }else{
         pWriter = pIter->pInsert;
@@ -2243,8 +2247,8 @@ static int otaStep(sqlite3ota *p){
         /* If this is an INSERT into a table b-tree and the table has an
         ** explicit INTEGER PRIMARY KEY, check that this is not an attempt
         ** to write a NULL into the IPK column. That is not permitted.  */
-        if( eType==OTA_INSERT 
-         && pIter->zIdx==0 && pIter->eType==OTA_PK_IPK && pIter->abTblPk[i] 
+        if( eType==RBU_INSERT 
+         && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i] 
          && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
         ){
           p->rc = SQLITE_MISMATCH;
@@ -2252,7 +2256,7 @@ static int otaStep(sqlite3ota *p){
           goto step_out;
         }
 
-        if( eType==OTA_DELETE && pIter->abTblPk[i]==0 ){
+        if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
           continue;
         }
 
@@ -2261,16 +2265,16 @@ static int otaStep(sqlite3ota *p){
         if( p->rc ) goto step_out;
       }
       if( pIter->zIdx==0
-       && (pIter->eType==OTA_PK_VTAB || pIter->eType==OTA_PK_NONE) 
+       && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE) 
       ){
         /* For a virtual table, or a table with no primary key, the 
         ** SELECT statement is:
         **
-        **   SELECT <cols>, ota_control, ota_rowid FROM ....
+        **   SELECT <cols>, rbu_control, rbu_rowid FROM ....
         **
         ** Hence column_value(pIter->nCol+1).
         */
-        assertColumnName(pIter->pSelect, pIter->nCol+1, "ota_rowid");
+        assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
         pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
         p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
       }
@@ -2281,8 +2285,8 @@ static int otaStep(sqlite3ota *p){
     }else{
       sqlite3_value *pVal;
       sqlite3_stmt *pUpdate = 0;
-      assert( eType==OTA_UPDATE );
-      otaGetUpdateStmt(p, pIter, zMask, &pUpdate);
+      assert( eType==RBU_UPDATE );
+      rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
       if( pUpdate ){
         for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
           char c = zMask[pIter->aiSrcOrder[i]];
@@ -2292,10 +2296,10 @@ static int otaStep(sqlite3ota *p){
           }
         }
         if( p->rc==SQLITE_OK 
-         && (pIter->eType==OTA_PK_VTAB || pIter->eType==OTA_PK_NONE) 
+         && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE) 
         ){
-          /* Bind the ota_rowid value to column _rowid_ */
-          assertColumnName(pIter->pSelect, pIter->nCol+1, "ota_rowid");
+          /* Bind the rbu_rowid value to column _rowid_ */
+          assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
           pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
           p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
         }
@@ -2314,7 +2318,7 @@ static int otaStep(sqlite3ota *p){
 /*
 ** Increment the schema cookie of the main database opened by p->dbMain.
 */
-static void otaIncrSchemaCookie(sqlite3ota *p){
+static void rbuIncrSchemaCookie(sqlite3rbu *p){
   if( p->rc==SQLITE_OK ){
     int iCookie = 1000000;
     sqlite3_stmt *pStmt;
@@ -2331,28 +2335,28 @@ static void otaIncrSchemaCookie(sqlite3ota *p){
       if( SQLITE_ROW==sqlite3_step(pStmt) ){
         iCookie = sqlite3_column_int(pStmt, 0);
       }
-      otaFinalize(p, pStmt);
+      rbuFinalize(p, pStmt);
     }
     if( p->rc==SQLITE_OK ){
-      otaMPrintfExec(p, p->dbMain, "PRAGMA schema_version = %d", iCookie+1);
+      rbuMPrintfExec(p, p->dbMain, "PRAGMA schema_version = %d", iCookie+1);
     }
   }
 }
 
 /*
-** Update the contents of the ota_state table within the ota database. The
-** value stored in the OTA_STATE_STAGE column is eStage. All other values
-** are determined by inspecting the ota handle passed as the first argument.
+** Update the contents of the rbu_state table within the rbu database. The
+** value stored in the RBU_STATE_STAGE column is eStage. All other values
+** are determined by inspecting the rbu handle passed as the first argument.
 */
-static void otaSaveState(sqlite3ota *p, int eStage){
+static void rbuSaveState(sqlite3rbu *p, int eStage){
   if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
     sqlite3_stmt *pInsert = 0;
     int rc;
 
     assert( p->zErrmsg==0 );
-    rc = prepareFreeAndCollectError(p->dbOta, &pInsert, &p->zErrmsg, 
+    rc = prepareFreeAndCollectError(p->dbRbu, &pInsert, &p->zErrmsg, 
         sqlite3_mprintf(
-          "INSERT OR REPLACE INTO %s.ota_state(k, v) VALUES "
+          "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
           "(%d, %d), "
           "(%d, %Q), "
           "(%d, %Q), "
@@ -2362,14 +2366,14 @@ static void otaSaveState(sqlite3ota *p, int eStage){
           "(%d, %lld), "
           "(%d, %lld) ",
           p->zStateDb,
-          OTA_STATE_STAGE, eStage,
-          OTA_STATE_TBL, p->objiter.zTbl, 
-          OTA_STATE_IDX, p->objiter.zIdx, 
-          OTA_STATE_ROW, p->nStep, 
-          OTA_STATE_PROGRESS, p->nProgress,
-          OTA_STATE_CKPT, p->iWalCksum,
-          OTA_STATE_COOKIE, (i64)p->pTargetFd->iCookie,
-          OTA_STATE_OALSZ, p->iOalSz
+          RBU_STATE_STAGE, eStage,
+          RBU_STATE_TBL, p->objiter.zTbl, 
+          RBU_STATE_IDX, p->objiter.zIdx, 
+          RBU_STATE_ROW, p->nStep, 
+          RBU_STATE_PROGRESS, p->nProgress,
+          RBU_STATE_CKPT, p->iWalCksum,
+          RBU_STATE_COOKIE, (i64)p->pTargetFd->iCookie,
+          RBU_STATE_OALSZ, p->iOalSz
       )
     );
     assert( pInsert==0 || rc==SQLITE_OK );
@@ -2384,26 +2388,26 @@ static void otaSaveState(sqlite3ota *p, int eStage){
 
 
 /*
-** Step the OTA object.
+** Step the RBU object.
 */
-int sqlite3ota_step(sqlite3ota *p){
+int sqlite3rbu_step(sqlite3rbu *p){
   if( p ){
     switch( p->eStage ){
-      case OTA_STAGE_OAL: {
-        OtaObjIter *pIter = &p->objiter;
+      case RBU_STAGE_OAL: {
+        RbuObjIter *pIter = &p->objiter;
         while( p->rc==SQLITE_OK && pIter->zTbl ){
 
           if( pIter->bCleanup ){
-            /* Clean up the ota_tmp_xxx table for the previous table. It 
+            /* Clean up the rbu_tmp_xxx table for the previous table. It 
             ** cannot be dropped as there are currently active SQL statements.
             ** But the contents can be deleted.  */
             if( pIter->abIndexed ){
-              otaMPrintfExec(p, p->dbOta, 
-                  "DELETE FROM %s.'ota_tmp_%q'", p->zStateDb, pIter->zTbl
+              rbuMPrintfExec(p, p->dbRbu, 
+                  "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zTbl
               );
             }
           }else{
-            otaObjIterPrepareAll(p, pIter, 0);
+            rbuObjIterPrepareAll(p, pIter, 0);
 
             /* Advance to the next row to process. */
             if( p->rc==SQLITE_OK ){
@@ -2411,40 +2415,40 @@ int sqlite3ota_step(sqlite3ota *p){
               if( rc==SQLITE_ROW ){
                 p->nProgress++;
                 p->nStep++;
-                return otaStep(p);
+                return rbuStep(p);
               }
               p->rc = sqlite3_reset(pIter->pSelect);
               p->nStep = 0;
             }
           }
 
-          otaObjIterNext(p, pIter);
+          rbuObjIterNext(p, pIter);
         }
 
         if( p->rc==SQLITE_OK ){
           assert( pIter->zTbl==0 );
-          otaSaveState(p, OTA_STAGE_MOVE);
-          otaIncrSchemaCookie(p);
+          rbuSaveState(p, RBU_STAGE_MOVE);
+          rbuIncrSchemaCookie(p);
           if( p->rc==SQLITE_OK ){
             p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
           }
           if( p->rc==SQLITE_OK ){
-            p->rc = sqlite3_exec(p->dbOta, "COMMIT", 0, 0, &p->zErrmsg);
+            p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
           }
-          p->eStage = OTA_STAGE_MOVE;
+          p->eStage = RBU_STAGE_MOVE;
         }
         break;
       }
 
-      case OTA_STAGE_MOVE: {
+      case RBU_STAGE_MOVE: {
         if( p->rc==SQLITE_OK ){
-          otaMoveOalFile(p);
+          rbuMoveOalFile(p);
           p->nProgress++;
         }
         break;
       }
 
-      case OTA_STAGE_CKPT: {
+      case RBU_STAGE_CKPT: {
         if( p->rc==SQLITE_OK ){
           if( p->nStep>=p->nFrame ){
             sqlite3_file *pDb = p->pTargetFd->pReal;
@@ -2462,12 +2466,12 @@ int sqlite3ota_step(sqlite3ota *p){
             }
   
             if( p->rc==SQLITE_OK ){
-              p->eStage = OTA_STAGE_DONE;
+              p->eStage = RBU_STAGE_DONE;
               p->rc = SQLITE_DONE;
             }
           }else{
-            OtaFrame *pFrame = &p->aFrame[p->nStep];
-            otaCheckpointFrame(p, pFrame);
+            RbuFrame *pFrame = &p->aFrame[p->nStep];
+            rbuCheckpointFrame(p, pFrame);
             p->nStep++;
           }
           p->nProgress++;
@@ -2485,9 +2489,9 @@ int sqlite3ota_step(sqlite3ota *p){
 }
 
 /*
-** Free an OtaState object allocated by otaLoadState().
+** Free an RbuState object allocated by rbuLoadState().
 */
-static void otaFreeState(OtaState *p){
+static void rbuFreeState(RbuState *p){
   if( p ){
     sqlite3_free(p->zTbl);
     sqlite3_free(p->zIdx);
@@ -2496,63 +2500,63 @@ static void otaFreeState(OtaState *p){
 }
 
 /*
-** Allocate an OtaState object and load the contents of the ota_state 
+** Allocate an RbuState object and load the contents of the rbu_state 
 ** table into it. Return a pointer to the new object. It is the 
 ** responsibility of the caller to eventually free the object using
 ** sqlite3_free().
 **
-** If an error occurs, leave an error code and message in the ota handle
+** If an error occurs, leave an error code and message in the rbu handle
 ** and return NULL.
 */
-static OtaState *otaLoadState(sqlite3ota *p){
-  OtaState *pRet = 0;
+static RbuState *rbuLoadState(sqlite3rbu *p){
+  RbuState *pRet = 0;
   sqlite3_stmt *pStmt = 0;
   int rc;
   int rc2;
 
-  pRet = (OtaState*)otaMalloc(p, sizeof(OtaState));
+  pRet = (RbuState*)rbuMalloc(p, sizeof(RbuState));
   if( pRet==0 ) return 0;
 
-  rc = prepareFreeAndCollectError(p->dbOta, &pStmt, &p->zErrmsg, 
-      sqlite3_mprintf("SELECT k, v FROM %s.ota_state", p->zStateDb)
+  rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, 
+      sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb)
   );
   while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
     switch( sqlite3_column_int(pStmt, 0) ){
-      case OTA_STATE_STAGE:
+      case RBU_STATE_STAGE:
         pRet->eStage = sqlite3_column_int(pStmt, 1);
-        if( pRet->eStage!=OTA_STAGE_OAL
-         && pRet->eStage!=OTA_STAGE_MOVE
-         && pRet->eStage!=OTA_STAGE_CKPT
+        if( pRet->eStage!=RBU_STAGE_OAL
+         && pRet->eStage!=RBU_STAGE_MOVE
+         && pRet->eStage!=RBU_STAGE_CKPT
         ){
           p->rc = SQLITE_CORRUPT;
         }
         break;
 
-      case OTA_STATE_TBL:
-        pRet->zTbl = otaStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
+      case RBU_STATE_TBL:
+        pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
         break;
 
-      case OTA_STATE_IDX:
-        pRet->zIdx = otaStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
+      case RBU_STATE_IDX:
+        pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
         break;
 
-      case OTA_STATE_ROW:
+      case RBU_STATE_ROW:
         pRet->nRow = sqlite3_column_int(pStmt, 1);
         break;
 
-      case OTA_STATE_PROGRESS:
+      case RBU_STATE_PROGRESS:
         pRet->nProgress = sqlite3_column_int64(pStmt, 1);
         break;
 
-      case OTA_STATE_CKPT:
+      case RBU_STATE_CKPT:
         pRet->iWalCksum = sqlite3_column_int64(pStmt, 1);
         break;
 
-      case OTA_STATE_COOKIE:
+      case RBU_STATE_COOKIE:
         pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1);
         break;
 
-      case OTA_STATE_OALSZ:
+      case RBU_STATE_OALSZ:
         pRet->iOalSz = (u32)sqlite3_column_int64(pStmt, 1);
         break;
 
@@ -2573,43 +2577,43 @@ static OtaState *otaLoadState(sqlite3ota *p){
 ** otherwise. Either or both argument may be NULL. Two NULL values are
 ** considered equal, and NULL is considered distinct from all other values.
 */
-static int otaStrCompare(const char *z1, const char *z2){
+static int rbuStrCompare(const char *z1, const char *z2){
   if( z1==0 && z2==0 ) return 0;
   if( z1==0 || z2==0 ) return 1;
   return (sqlite3_stricmp(z1, z2)!=0);
 }
 
 /*
-** This function is called as part of sqlite3ota_open() when initializing
-** an ota handle in OAL stage. If the ota update has not started (i.e.
-** the ota_state table was empty) it is a no-op. Otherwise, it arranges
-** things so that the next call to sqlite3ota_step() continues on from
-** where the previous ota handle left off.
+** This function is called as part of sqlite3rbu_open() when initializing
+** an rbu handle in OAL stage. If the rbu update has not started (i.e.
+** the rbu_state table was empty) it is a no-op. Otherwise, it arranges
+** things so that the next call to sqlite3rbu_step() continues on from
+** where the previous rbu handle left off.
 **
 ** If an error occurs, an error code and error message are left in the
-** ota handle passed as the first argument.
+** rbu handle passed as the first argument.
 */
-static void otaSetupOal(sqlite3ota *p, OtaState *pState){
+static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
   assert( p->rc==SQLITE_OK );
   if( pState->zTbl ){
-    OtaObjIter *pIter = &p->objiter;
+    RbuObjIter *pIter = &p->objiter;
     int rc = SQLITE_OK;
 
     while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup 
-       || otaStrCompare(pIter->zIdx, pState->zIdx)
-       || otaStrCompare(pIter->zTbl, pState->zTbl) 
+       || rbuStrCompare(pIter->zIdx, pState->zIdx)
+       || rbuStrCompare(pIter->zTbl, pState->zTbl) 
     )){
-      rc = otaObjIterNext(p, pIter);
+      rc = rbuObjIterNext(p, pIter);
     }
 
     if( rc==SQLITE_OK && !pIter->zTbl ){
       rc = SQLITE_ERROR;
-      p->zErrmsg = sqlite3_mprintf("ota_state mismatch error");
+      p->zErrmsg = sqlite3_mprintf("rbu_state mismatch error");
     }
 
     if( rc==SQLITE_OK ){
       p->nStep = pState->nRow;
-      rc = otaObjIterPrepareAll(p, &p->objiter, p->nStep);
+      rc = rbuObjIterPrepareAll(p, &p->objiter, p->nStep);
     }
 
     p->rc = rc;
@@ -2619,9 +2623,9 @@ static void otaSetupOal(sqlite3ota *p, OtaState *pState){
 /*
 ** If there is a "*-oal" file in the file-system corresponding to the
 ** target database in the file-system, delete it. If an error occurs,
-** leave an error code and error message in the ota handle.
+** leave an error code and error message in the rbu handle.
 */
-static void otaDeleteOalFile(sqlite3ota *p){
+static void rbuDeleteOalFile(sqlite3rbu *p){
   char *zOal = sqlite3_mprintf("%s-oal", p->zTarget);
   assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
   unlink(zOal);
@@ -2629,19 +2633,19 @@ static void otaDeleteOalFile(sqlite3ota *p){
 }
 
 /*
-** Allocate a private ota VFS for the ota handle passed as the only
-** argument. This VFS will be used unless the call to sqlite3ota_open()
+** Allocate a private rbu VFS for the rbu handle passed as the only
+** argument. This VFS will be used unless the call to sqlite3rbu_open()
 ** specified a URI with a vfs=? option in place of a target database
 ** file name.
 */
-static void otaCreateVfs(sqlite3ota *p){
+static void rbuCreateVfs(sqlite3rbu *p){
   int rnd;
   char zRnd[64];
 
   assert( p->rc==SQLITE_OK );
   sqlite3_randomness(sizeof(int), (void*)&rnd);
-  sprintf(zRnd, "ota_vfs_%d", rnd);
-  p->rc = sqlite3ota_create_vfs(zRnd, 0);
+  sqlite3_snprintf(sizeof(zRnd), zRnd, "rbu_vfs_%d", rnd);
+  p->rc = sqlite3rbu_create_vfs(zRnd, 0);
   if( p->rc==SQLITE_OK ){
     sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
     assert( pVfs );
@@ -2650,61 +2654,61 @@ static void otaCreateVfs(sqlite3ota *p){
 }
 
 /*
-** Destroy the private VFS created for the ota handle passed as the only
-** argument by an earlier call to otaCreateVfs().
+** Destroy the private VFS created for the rbu handle passed as the only
+** argument by an earlier call to rbuCreateVfs().
 */
-static void otaDeleteVfs(sqlite3ota *p){
+static void rbuDeleteVfs(sqlite3rbu *p){
   if( p->zVfsName ){
-    sqlite3ota_destroy_vfs(p->zVfsName);
+    sqlite3rbu_destroy_vfs(p->zVfsName);
     p->zVfsName = 0;
   }
 }
 
 /*
-** Open and return a new OTA handle. 
+** Open and return a new RBU handle. 
 */
-sqlite3ota *sqlite3ota_open(
+sqlite3rbu *sqlite3rbu_open(
   const char *zTarget, 
-  const char *zOta,
+  const char *zRbu,
   const char *zState
 ){
-  sqlite3ota *p;
+  sqlite3rbu *p;
   int nTarget = strlen(zTarget);
-  int nOta = strlen(zOta);
+  int nRbu = strlen(zRbu);
   int nState = zState ? strlen(zState) : 0;
 
-  p = (sqlite3ota*)sqlite3_malloc(sizeof(sqlite3ota)+nTarget+1+nOta+1+nState+1);
+  p = (sqlite3rbu*)sqlite3_malloc(sizeof(sqlite3rbu)+nTarget+1+nRbu+1+nState+1);
   if( p ){
-    OtaState *pState = 0;
+    RbuState *pState = 0;
 
     /* Create the custom VFS. */
-    memset(p, 0, sizeof(sqlite3ota));
-    otaCreateVfs(p);
+    memset(p, 0, sizeof(sqlite3rbu));
+    rbuCreateVfs(p);
 
     /* Open the target database */
     if( p->rc==SQLITE_OK ){
       p->zTarget = (char*)&p[1];
       memcpy(p->zTarget, zTarget, nTarget+1);
-      p->zOta = &p->zTarget[nTarget+1];
-      memcpy(p->zOta, zOta, nOta+1);
+      p->zRbu = &p->zTarget[nTarget+1];
+      memcpy(p->zRbu, zRbu, nRbu+1);
       if( zState ){
-        p->zState = &p->zOta[nOta+1];
+        p->zState = &p->zRbu[nRbu+1];
         memcpy(p->zState, zState, nState+1);
       }
-      otaOpenDatabase(p);
+      rbuOpenDatabase(p);
     }
 
-    /* If it has not already been created, create the ota_state table */
-    otaMPrintfExec(p, p->dbOta, OTA_CREATE_STATE, p->zStateDb);
+    /* If it has not already been created, create the rbu_state table */
+    rbuMPrintfExec(p, p->dbRbu, RBU_CREATE_STATE, p->zStateDb);
 
     if( p->rc==SQLITE_OK ){
-      pState = otaLoadState(p);
+      pState = rbuLoadState(p);
       assert( pState || p->rc!=SQLITE_OK );
       if( p->rc==SQLITE_OK ){
 
         if( pState->eStage==0 ){ 
-          otaDeleteOalFile(p);
-          p->eStage = OTA_STAGE_OAL;
+          rbuDeleteOalFile(p);
+          p->eStage = RBU_STAGE_OAL;
         }else{
           p->eStage = pState->eStage;
         }
@@ -2715,17 +2719,17 @@ sqlite3ota *sqlite3ota_open(
     assert( p->rc!=SQLITE_OK || p->eStage!=0 );
 
     if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
-      if( p->eStage==OTA_STAGE_OAL ){
+      if( p->eStage==RBU_STAGE_OAL ){
         p->rc = SQLITE_ERROR;
         p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
-      }else if( p->eStage==OTA_STAGE_MOVE ){
-        p->eStage = OTA_STAGE_CKPT;
+      }else if( p->eStage==RBU_STAGE_MOVE ){
+        p->eStage = RBU_STAGE_CKPT;
         p->nStep = 0;
       }
     }
 
     if( p->rc==SQLITE_OK
-     && (p->eStage==OTA_STAGE_OAL || p->eStage==OTA_STAGE_MOVE)
+     && (p->eStage==RBU_STAGE_OAL || p->eStage==RBU_STAGE_MOVE)
      && pState->eStage!=0 && p->pTargetFd->iCookie!=pState->iCookie
     ){   
       /* At this point (pTargetFd->iCookie) contains the value of the
@@ -2733,46 +2737,46 @@ sqlite3ota *sqlite3ota_open(
       ** transaction is committed in rollback mode) currently stored on 
       ** page 1 of the database file. */
       p->rc = SQLITE_BUSY;
-      p->zErrmsg = sqlite3_mprintf("database modified during ota update");
+      p->zErrmsg = sqlite3_mprintf("database modified during rbu update");
     }
 
     if( p->rc==SQLITE_OK ){
-      if( p->eStage==OTA_STAGE_OAL ){
+      if( p->eStage==RBU_STAGE_OAL ){
 
         /* Open transactions both databases. The *-oal file is opened or
         ** created at this point. */
         p->rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
         if( p->rc==SQLITE_OK ){
-          p->rc = sqlite3_exec(p->dbOta, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
+          p->rc = sqlite3_exec(p->dbRbu, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
         }
   
         /* Point the object iterator at the first object */
         if( p->rc==SQLITE_OK ){
-          p->rc = otaObjIterFirst(p, &p->objiter);
+          p->rc = rbuObjIterFirst(p, &p->objiter);
         }
 
-        /* If the OTA database contains no data_xxx tables, declare the OTA
+        /* If the RBU database contains no data_xxx tables, declare the RBU
         ** update finished.  */
         if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
           p->rc = SQLITE_DONE;
         }
 
         if( p->rc==SQLITE_OK ){
-          otaSetupOal(p, pState);
+          rbuSetupOal(p, pState);
         }
 
-      }else if( p->eStage==OTA_STAGE_MOVE ){
+      }else if( p->eStage==RBU_STAGE_MOVE ){
         /* no-op */
-      }else if( p->eStage==OTA_STAGE_CKPT ){
-        otaSetupCheckpoint(p, pState);
-      }else if( p->eStage==OTA_STAGE_DONE ){
+      }else if( p->eStage==RBU_STAGE_CKPT ){
+        rbuSetupCheckpoint(p, pState);
+      }else if( p->eStage==RBU_STAGE_DONE ){
         p->rc = SQLITE_DONE;
       }else{
         p->rc = SQLITE_CORRUPT;
       }
     }
 
-    otaFreeState(pState);
+    rbuFreeState(pState);
   }
 
   return p;
@@ -2780,28 +2784,28 @@ sqlite3ota *sqlite3ota_open(
 
 
 /*
-** Return the database handle used by pOta.
+** Return the database handle used by pRbu.
 */
-sqlite3 *sqlite3ota_db(sqlite3ota *pOta, int bOta){
+sqlite3 *sqlite3rbu_db(sqlite3rbu *pRbu, int bRbu){
   sqlite3 *db = 0;
-  if( pOta ){
-    db = (bOta ? pOta->dbOta : pOta->dbMain);
+  if( pRbu ){
+    db = (bRbu ? pRbu->dbRbu : pRbu->dbMain);
   }
   return db;
 }
 
 
 /*
-** If the error code currently stored in the OTA handle is SQLITE_CONSTRAINT,
+** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
 ** then edit any error message string so as to remove all occurrences of
-** the pattern "ota_imp_[0-9]*".
+** the pattern "rbu_imp_[0-9]*".
 */
-static void otaEditErrmsg(sqlite3ota *p){
+static void rbuEditErrmsg(sqlite3rbu *p){
   if( p->rc==SQLITE_CONSTRAINT && p->zErrmsg ){
     int i;
     int nErrmsg = strlen(p->zErrmsg);
     for(i=0; i<(nErrmsg-8); i++){
-      if( memcmp(&p->zErrmsg[i], "ota_imp_", 8)==0 ){
+      if( memcmp(&p->zErrmsg[i], "rbu_imp_", 8)==0 ){
         int nDel = 8;
         while( p->zErrmsg[i+nDel]>='0' && p->zErrmsg[i+nDel]<='9' ) nDel++;
         memmove(&p->zErrmsg[i], &p->zErrmsg[i+nDel], nErrmsg + 1 - i - nDel);
@@ -2812,34 +2816,34 @@ static void otaEditErrmsg(sqlite3ota *p){
 }
 
 /*
-** Close the OTA handle.
+** Close the RBU handle.
 */
-int sqlite3ota_close(sqlite3ota *p, char **pzErrmsg){
+int sqlite3rbu_close(sqlite3rbu *p, char **pzErrmsg){
   int rc;
   if( p ){
 
     /* Commit the transaction to the *-oal file. */
-    if( p->rc==SQLITE_OK && p->eStage==OTA_STAGE_OAL ){
+    if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
       p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
     }
 
-    otaSaveState(p, p->eStage);
+    rbuSaveState(p, p->eStage);
 
-    if( p->rc==SQLITE_OK && p->eStage==OTA_STAGE_OAL ){
-      p->rc = sqlite3_exec(p->dbOta, "COMMIT", 0, 0, &p->zErrmsg);
+    if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
+      p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
     }
 
     /* Close any open statement handles. */
-    otaObjIterFinalize(&p->objiter);
+    rbuObjIterFinalize(&p->objiter);
 
     /* Close the open database handle and VFS object. */
     sqlite3_close(p->dbMain);
-    sqlite3_close(p->dbOta);
-    otaDeleteVfs(p);
+    sqlite3_close(p->dbRbu);
+    rbuDeleteVfs(p);
     sqlite3_free(p->aBuf);
     sqlite3_free(p->aFrame);
 
-    otaEditErrmsg(p);
+    rbuEditErrmsg(p);
     rc = p->rc;
     *pzErrmsg = p->zErrmsg;
     sqlite3_free(p);
@@ -2853,61 +2857,61 @@ int sqlite3ota_close(sqlite3ota *p, char **pzErrmsg){
 /*
 ** Return the total number of key-value operations (inserts, deletes or 
 ** updates) that have been performed on the target database since the
-** current OTA update was started.
+** current RBU update was started.
 */
-sqlite3_int64 sqlite3ota_progress(sqlite3ota *pOta){
-  return pOta->nProgress;
+sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu){
+  return pRbu->nProgress;
 }
 
 /**************************************************************************
-** Beginning of OTA VFS shim methods. The VFS shim modifies the behaviour
+** Beginning of RBU VFS shim methods. The VFS shim modifies the behaviour
 ** of a standard VFS in the following ways:
 **
 ** 1. Whenever the first page of a main database file is read or 
 **    written, the value of the change-counter cookie is stored in
-**    ota_file.iCookie. Similarly, the value of the "write-version"
-**    database header field is stored in ota_file.iWriteVer. This ensures
+**    rbu_file.iCookie. Similarly, the value of the "write-version"
+**    database header field is stored in rbu_file.iWriteVer. This ensures
 **    that the values are always trustworthy within an open transaction.
 **
-** 2. Whenever an SQLITE_OPEN_WAL file is opened, the (ota_file.pWalFd)
+** 2. Whenever an SQLITE_OPEN_WAL file is opened, the (rbu_file.pWalFd)
 **    member variable of the associated database file descriptor is set
 **    to point to the new file. A mutex protected linked list of all main 
-**    db fds opened using a particular OTA VFS is maintained at 
-**    ota_vfs.pMain to facilitate this.
+**    db fds opened using a particular RBU VFS is maintained at 
+**    rbu_vfs.pMain to facilitate this.
 **
-** 3. Using a new file-control "SQLITE_FCNTL_OTA", a main db ota_file 
-**    object can be marked as the target database of an OTA update. This
+** 3. Using a new file-control "SQLITE_FCNTL_RBU", a main db rbu_file 
+**    object can be marked as the target database of an RBU update. This
 **    turns on the following extra special behaviour:
 **
 ** 3a. If xAccess() is called to check if there exists a *-wal file 
-**     associated with an OTA target database currently in OTA_STAGE_OAL
+**     associated with an RBU target database currently in RBU_STAGE_OAL
 **     stage (preparing the *-oal file), the following special handling
 **     applies:
 **
-**      * if the *-wal file does exist, return SQLITE_CANTOPEN. An OTA
+**      * if the *-wal file does exist, return SQLITE_CANTOPEN. An RBU
 **        target database may not be in wal mode already.
 **
 **      * if the *-wal file does not exist, set the output parameter to
 **        non-zero (to tell SQLite that it does exist) anyway.
 **
 **     Then, when xOpen() is called to open the *-wal file associated with
-**     the OTA target in OTA_STAGE_OAL stage, instead of opening the *-wal
-**     file, the ota vfs opens the corresponding *-oal file instead. 
+**     the RBU target in RBU_STAGE_OAL stage, instead of opening the *-wal
+**     file, the rbu vfs opens the corresponding *-oal file instead. 
 **
 ** 3b. The *-shm pages returned by xShmMap() for a target db file in
-**     OTA_STAGE_OAL mode are actually stored in heap memory. This is to
+**     RBU_STAGE_OAL mode are actually stored in heap memory. This is to
 **     avoid creating a *-shm file on disk. Additionally, xShmLock() calls
-**     are no-ops on target database files in OTA_STAGE_OAL mode. This is
+**     are no-ops on target database files in RBU_STAGE_OAL mode. This is
 **     because assert() statements in some VFS implementations fail if 
 **     xShmLock() is called before xShmMap().
 **
 ** 3c. If an EXCLUSIVE lock is attempted on a target database file in any
-**     mode except OTA_STAGE_DONE (all work completed and checkpointed), it 
-**     fails with an SQLITE_BUSY error. This is to stop OTA connections
+**     mode except RBU_STAGE_DONE (all work completed and checkpointed), it 
+**     fails with an SQLITE_BUSY error. This is to stop RBU connections
 **     from automatically checkpointing a *-wal (or *-oal) file from within
 **     sqlite3_close().
 **
-** 3d. In OTA_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
+** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
 **     all xWrite() calls on the target database file perform no IO. 
 **     Instead the frame and page numbers that would be read and written
 **     are recorded. Additionally, successful attempts to obtain exclusive
@@ -2918,24 +2922,24 @@ sqlite3_int64 sqlite3ota_progress(sqlite3ota *pOta){
 **     file fail with SQLITE_INTERNAL errors.
 */
 
-static void otaUnlockShm(ota_file *p){
-  if( p->pOta ){
+static void rbuUnlockShm(rbu_file *p){
+  if( p->pRbu ){
     int (*xShmLock)(sqlite3_file*,int,int,int) = p->pReal->pMethods->xShmLock;
     int i;
     for(i=0; i<SQLITE_SHM_NLOCK;i++){
-      if( (1<<i) & p->pOta->mLock ){
+      if( (1<<i) & p->pRbu->mLock ){
         xShmLock(p->pReal, i, 1, SQLITE_SHM_UNLOCK|SQLITE_SHM_EXCLUSIVE);
       }
     }
-    p->pOta->mLock = 0;
+    p->pRbu->mLock = 0;
   }
 }
 
 /*
-** Close an ota file.
+** Close an rbu file.
 */
-static int otaVfsClose(sqlite3_file *pFile){
-  ota_file *p = (ota_file*)pFile;
+static int rbuVfsClose(sqlite3_file *pFile){
+  rbu_file *p = (rbu_file*)pFile;
   int rc;
   int i;
 
@@ -2948,12 +2952,12 @@ static int otaVfsClose(sqlite3_file *pFile){
   sqlite3_free(p->zDel);
 
   if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
-    ota_file **pp;
-    sqlite3_mutex_enter(p->pOtaVfs->mutex);
-    for(pp=&p->pOtaVfs->pMain; *pp!=p; pp=&((*pp)->pMainNext));
+    rbu_file **pp;
+    sqlite3_mutex_enter(p->pRbuVfs->mutex);
+    for(pp=&p->pRbuVfs->pMain; *pp!=p; pp=&((*pp)->pMainNext));
     *pp = p->pMainNext;
-    sqlite3_mutex_leave(p->pOtaVfs->mutex);
-    otaUnlockShm(p);
+    sqlite3_mutex_leave(p->pRbuVfs->mutex);
+    rbuUnlockShm(p);
     p->pReal->pMethods->xShmUnmap(p->pReal, 0);
   }
 
@@ -2967,7 +2971,7 @@ static int otaVfsClose(sqlite3_file *pFile){
 ** Read and return an unsigned 32-bit big-endian integer from the buffer 
 ** passed as the only argument.
 */
-static u32 otaGetU32(u8 *aBuf){
+static u32 rbuGetU32(u8 *aBuf){
   return ((u32)aBuf[0] << 24)
        + ((u32)aBuf[1] << 16)
        + ((u32)aBuf[2] <<  8)
@@ -2975,25 +2979,25 @@ static u32 otaGetU32(u8 *aBuf){
 }
 
 /*
-** Read data from an otaVfs-file.
+** Read data from an rbuVfs-file.
 */
-static int otaVfsRead(
+static int rbuVfsRead(
   sqlite3_file *pFile, 
   void *zBuf, 
   int iAmt, 
   sqlite_int64 iOfst
 ){
-  ota_file *p = (ota_file*)pFile;
-  sqlite3ota *pOta = p->pOta;
+  rbu_file *p = (rbu_file*)pFile;
+  sqlite3rbu *pRbu = p->pRbu;
   int rc;
 
-  if( pOta && pOta->eStage==OTA_STAGE_CAPTURE ){
+  if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
     assert( p->openFlags & SQLITE_OPEN_WAL );
-    rc = otaCaptureWalRead(p->pOta, iOfst, iAmt);
+    rc = rbuCaptureWalRead(p->pRbu, iOfst, iAmt);
   }else{
-    if( pOta && pOta->eStage==OTA_STAGE_OAL 
+    if( pRbu && pRbu->eStage==RBU_STAGE_OAL 
      && (p->openFlags & SQLITE_OPEN_WAL) 
-     && iOfst>=pOta->iOalSz 
+     && iOfst>=pRbu->iOalSz 
     ){
       rc = SQLITE_OK;
       memset(zBuf, 0, iAmt);
@@ -3004,7 +3008,7 @@ static int otaVfsRead(
       /* These look like magic numbers. But they are stable, as they are part
        ** of the definition of the SQLite file format, which may not change. */
       u8 *pBuf = (u8*)zBuf;
-      p->iCookie = otaGetU32(&pBuf[24]);
+      p->iCookie = rbuGetU32(&pBuf[24]);
       p->iWriteVer = pBuf[19];
     }
   }
@@ -3012,34 +3016,34 @@ static int otaVfsRead(
 }
 
 /*
-** Write data to an otaVfs-file.
+** Write data to an rbuVfs-file.
 */
-static int otaVfsWrite(
+static int rbuVfsWrite(
   sqlite3_file *pFile, 
   const void *zBuf, 
   int iAmt, 
   sqlite_int64 iOfst
 ){
-  ota_file *p = (ota_file*)pFile;
-  sqlite3ota *pOta = p->pOta;
+  rbu_file *p = (rbu_file*)pFile;
+  sqlite3rbu *pRbu = p->pRbu;
   int rc;
 
-  if( pOta && pOta->eStage==OTA_STAGE_CAPTURE ){
+  if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
     assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
-    rc = otaCaptureDbWrite(p->pOta, iOfst);
+    rc = rbuCaptureDbWrite(p->pRbu, iOfst);
   }else{
-    if( pOta && pOta->eStage==OTA_STAGE_OAL 
+    if( pRbu && pRbu->eStage==RBU_STAGE_OAL 
      && (p->openFlags & SQLITE_OPEN_WAL) 
-     && iOfst>=pOta->iOalSz
+     && iOfst>=pRbu->iOalSz
     ){
-      pOta->iOalSz = iAmt + iOfst;
+      pRbu->iOalSz = iAmt + iOfst;
     }
     rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
     if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
       /* These look like magic numbers. But they are stable, as they are part
       ** of the definition of the SQLite file format, which may not change. */
       u8 *pBuf = (u8*)zBuf;
-      p->iCookie = otaGetU32(&pBuf[24]);
+      p->iCookie = rbuGetU32(&pBuf[24]);
       p->iWriteVer = pBuf[19];
     }
   }
@@ -3047,19 +3051,19 @@ static int otaVfsWrite(
 }
 
 /*
-** Truncate an otaVfs-file.
+** Truncate an rbuVfs-file.
 */
-static int otaVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
-  ota_file *p = (ota_file*)pFile;
+static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  rbu_file *p = (rbu_file*)pFile;
   return p->pReal->pMethods->xTruncate(p->pReal, size);
 }
 
 /*
-** Sync an otaVfs-file.
+** Sync an rbuVfs-file.
 */
-static int otaVfsSync(sqlite3_file *pFile, int flags){
-  ota_file *p = (ota_file *)pFile;
-  if( p->pOta && p->pOta->eStage==OTA_STAGE_CAPTURE ){
+static int rbuVfsSync(sqlite3_file *pFile, int flags){
+  rbu_file *p = (rbu_file *)pFile;
+  if( p->pRbu && p->pRbu->eStage==RBU_STAGE_CAPTURE ){
     if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
       return SQLITE_INTERNAL;
     }
@@ -3069,23 +3073,23 @@ static int otaVfsSync(sqlite3_file *pFile, int flags){
 }
 
 /*
-** Return the current file-size of an otaVfs-file.
+** Return the current file-size of an rbuVfs-file.
 */
-static int otaVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  rbu_file *p = (rbu_file *)pFile;
   return p->pReal->pMethods->xFileSize(p->pReal, pSize);
 }
 
 /*
-** Lock an otaVfs-file.
+** Lock an rbuVfs-file.
 */
-static int otaVfsLock(sqlite3_file *pFile, int eLock){
-  ota_file *p = (ota_file*)pFile;
-  sqlite3ota *pOta = p->pOta;
+static int rbuVfsLock(sqlite3_file *pFile, int eLock){
+  rbu_file *p = (rbu_file*)pFile;
+  sqlite3rbu *pRbu = p->pRbu;
   int rc = SQLITE_OK;
 
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( pOta && eLock==SQLITE_LOCK_EXCLUSIVE && pOta->eStage!=OTA_STAGE_DONE ){
+  if( pRbu && eLock==SQLITE_LOCK_EXCLUSIVE && pRbu->eStage!=RBU_STAGE_DONE ){
     /* Do not allow EXCLUSIVE locks. Preventing SQLite from taking this 
     ** prevents it from checkpointing the database from sqlite3_close(). */
     rc = SQLITE_BUSY;
@@ -3097,38 +3101,38 @@ static int otaVfsLock(sqlite3_file *pFile, int eLock){
 }
 
 /*
-** Unlock an otaVfs-file.
+** Unlock an rbuVfs-file.
 */
-static int otaVfsUnlock(sqlite3_file *pFile, int eLock){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
+  rbu_file *p = (rbu_file *)pFile;
   return p->pReal->pMethods->xUnlock(p->pReal, eLock);
 }
 
 /*
-** Check if another file-handle holds a RESERVED lock on an otaVfs-file.
+** Check if another file-handle holds a RESERVED lock on an rbuVfs-file.
 */
-static int otaVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
+  rbu_file *p = (rbu_file *)pFile;
   return p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
 }
 
 /*
-** File control method. For custom operations on an otaVfs-file.
+** File control method. For custom operations on an rbuVfs-file.
 */
-static int otaVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
+  rbu_file *p = (rbu_file *)pFile;
   int (*xControl)(sqlite3_file*,int,void*) = p->pReal->pMethods->xFileControl;
   int rc;
 
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB)
        || p->openFlags & (SQLITE_OPEN_TRANSIENT_DB|SQLITE_OPEN_TEMP_JOURNAL)
   );
-  if( op==SQLITE_FCNTL_OTA ){
-    sqlite3ota *pOta = (sqlite3ota*)pArg;
+  if( op==SQLITE_FCNTL_RBU ){
+    sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
 
-    /* First try to find another OTA vfs lower down in the vfs stack. If
+    /* First try to find another RBU vfs lower down in the vfs stack. If
     ** one is found, this vfs will operate in pass-through mode. The lower
-    ** level vfs will do the special OTA handling.  */
+    ** level vfs will do the special RBU handling.  */
     rc = xControl(p->pReal, op, pArg);
 
     if( rc==SQLITE_NOTFOUND ){
@@ -3138,11 +3142,11 @@ static int otaVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
       rc = xControl(p->pReal, SQLITE_FCNTL_ZIPVFS, &dummy);
       if( rc==SQLITE_OK ){
         rc = SQLITE_ERROR;
-        pOta->zErrmsg = sqlite3_mprintf("ota/zipvfs setup error");
+        pRbu->zErrmsg = sqlite3_mprintf("rbu/zipvfs setup error");
       }else if( rc==SQLITE_NOTFOUND ){
-        pOta->pTargetFd = p;
-        p->pOta = pOta;
-        if( p->pWalFd ) p->pWalFd->pOta = pOta;
+        pRbu->pTargetFd = p;
+        p->pRbu = pRbu;
+        if( p->pWalFd ) p->pWalFd->pRbu = pRbu;
         rc = SQLITE_OK;
       }
     }
@@ -3151,9 +3155,9 @@ static int otaVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
 
   rc = xControl(p->pReal, op, pArg);
   if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
-    ota_vfs *pOtaVfs = p->pOtaVfs;
+    rbu_vfs *pRbuVfs = p->pRbuVfs;
     char *zIn = *(char**)pArg;
-    char *zOut = sqlite3_mprintf("ota(%s)/%z", pOtaVfs->base.zName, zIn);
+    char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
     *(char**)pArg = zOut;
     if( zOut==0 ) rc = SQLITE_NOMEM;
   }
@@ -3162,27 +3166,27 @@ static int otaVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
 }
 
 /*
-** Return the sector-size in bytes for an otaVfs-file.
+** Return the sector-size in bytes for an rbuVfs-file.
 */
-static int otaVfsSectorSize(sqlite3_file *pFile){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsSectorSize(sqlite3_file *pFile){
+  rbu_file *p = (rbu_file *)pFile;
   return p->pReal->pMethods->xSectorSize(p->pReal);
 }
 
 /*
-** Return the device characteristic flags supported by an otaVfs-file.
+** Return the device characteristic flags supported by an rbuVfs-file.
 */
-static int otaVfsDeviceCharacteristics(sqlite3_file *pFile){
-  ota_file *p = (ota_file *)pFile;
+static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
+  rbu_file *p = (rbu_file *)pFile;
   return p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
 }
 
 /*
 ** Take or release a shared-memory lock.
 */
-static int otaVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
-  ota_file *p = (ota_file*)pFile;
-  sqlite3ota *pOta = p->pOta;
+static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
+  rbu_file *p = (rbu_file*)pFile;
+  sqlite3rbu *pRbu = p->pRbu;
   int rc = SQLITE_OK;
 
 #ifdef SQLITE_AMALGAMATION
@@ -3190,7 +3194,7 @@ static int otaVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
 #endif
 
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( pOta && (pOta->eStage==OTA_STAGE_OAL || pOta->eStage==OTA_STAGE_MOVE) ){
+  if( pRbu && (pRbu->eStage==RBU_STAGE_OAL || pRbu->eStage==RBU_STAGE_MOVE) ){
     /* Magic number 1 is the WAL_CKPT_LOCK lock. Preventing SQLite from
     ** taking this lock also prevents any checkpoints from occurring. 
     ** todo: really, it's not clear why this might occur, as 
@@ -3199,7 +3203,7 @@ static int otaVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
   }else{
     int bCapture = 0;
     if( n==1 && (flags & SQLITE_SHM_EXCLUSIVE)
-     && pOta && pOta->eStage==OTA_STAGE_CAPTURE
+     && pRbu && pRbu->eStage==RBU_STAGE_CAPTURE
      && (ofst==WAL_LOCK_WRITE || ofst==WAL_LOCK_CKPT || ofst==WAL_LOCK_READ0)
     ){
       bCapture = 1;
@@ -3208,7 +3212,7 @@ static int otaVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
     if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
       rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
       if( bCapture && rc==SQLITE_OK ){
-        pOta->mLock |= (1 << ofst);
+        pRbu->mLock |= (1 << ofst);
       }
     }
   }
@@ -3219,22 +3223,22 @@ static int otaVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
 /*
 ** Obtain a pointer to a mapping of a single 32KiB page of the *-shm file.
 */
-static int otaVfsShmMap(
+static int rbuVfsShmMap(
   sqlite3_file *pFile, 
   int iRegion, 
   int szRegion, 
   int isWrite, 
   void volatile **pp
 ){
-  ota_file *p = (ota_file*)pFile;
+  rbu_file *p = (rbu_file*)pFile;
   int rc = SQLITE_OK;
-  int eStage = (p->pOta ? p->pOta->eStage : 0);
+  int eStage = (p->pRbu ? p->pRbu->eStage : 0);
 
-  /* If not in OTA_STAGE_OAL, allow this call to pass through. Or, if this
-  ** ota is in the OTA_STAGE_OAL state, use heap memory for *-shm space 
+  /* If not in RBU_STAGE_OAL, allow this call to pass through. Or, if this
+  ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space 
   ** instead of a file on disk.  */
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eStage==OTA_STAGE_OAL || eStage==OTA_STAGE_MOVE ){
+  if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
     if( iRegion<=p->nShm ){
       int nByte = (iRegion+1) * sizeof(char*);
       char **apNew = (char**)sqlite3_realloc(p->apShm, nByte);
@@ -3273,25 +3277,25 @@ static int otaVfsShmMap(
 /*
 ** Memory barrier.
 */
-static void otaVfsShmBarrier(sqlite3_file *pFile){
-  ota_file *p = (ota_file *)pFile;
+static void rbuVfsShmBarrier(sqlite3_file *pFile){
+  rbu_file *p = (rbu_file *)pFile;
   p->pReal->pMethods->xShmBarrier(p->pReal);
 }
 
 /*
 ** The xShmUnmap method.
 */
-static int otaVfsShmUnmap(sqlite3_file *pFile, int delFlag){
-  ota_file *p = (ota_file*)pFile;
+static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
+  rbu_file *p = (rbu_file*)pFile;
   int rc = SQLITE_OK;
-  int eStage = (p->pOta ? p->pOta->eStage : 0);
+  int eStage = (p->pRbu ? p->pRbu->eStage : 0);
 
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eStage==OTA_STAGE_OAL || eStage==OTA_STAGE_MOVE ){
+  if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
     /* no-op */
   }else{
     /* Release the checkpointer and writer locks */
-    otaUnlockShm(p);
+    rbuUnlockShm(p);
     rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
   }
   return rc;
@@ -3303,52 +3307,52 @@ static int otaVfsShmUnmap(sqlite3_file *pFile, int delFlag){
 ** file-handle opened by the same database connection on the corresponding
 ** database file.
 */
-static ota_file *otaFindMaindb(ota_vfs *pOtaVfs, const char *zWal){
-  ota_file *pDb;
-  sqlite3_mutex_enter(pOtaVfs->mutex);
-  for(pDb=pOtaVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext);
-  sqlite3_mutex_leave(pOtaVfs->mutex);
+static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal){
+  rbu_file *pDb;
+  sqlite3_mutex_enter(pRbuVfs->mutex);
+  for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext);
+  sqlite3_mutex_leave(pRbuVfs->mutex);
   return pDb;
 }
 
 /*
-** Open an ota file handle.
+** Open an rbu file handle.
 */
-static int otaVfsOpen(
+static int rbuVfsOpen(
   sqlite3_vfs *pVfs,
   const char *zName,
   sqlite3_file *pFile,
   int flags,
   int *pOutFlags
 ){
-  static sqlite3_io_methods otavfs_io_methods = {
+  static sqlite3_io_methods rbuvfs_io_methods = {
     2,                            /* iVersion */
-    otaVfsClose,                  /* xClose */
-    otaVfsRead,                   /* xRead */
-    otaVfsWrite,                  /* xWrite */
-    otaVfsTruncate,               /* xTruncate */
-    otaVfsSync,                   /* xSync */
-    otaVfsFileSize,               /* xFileSize */
-    otaVfsLock,                   /* xLock */
-    otaVfsUnlock,                 /* xUnlock */
-    otaVfsCheckReservedLock,      /* xCheckReservedLock */
-    otaVfsFileControl,            /* xFileControl */
-    otaVfsSectorSize,             /* xSectorSize */
-    otaVfsDeviceCharacteristics,  /* xDeviceCharacteristics */
-    otaVfsShmMap,                 /* xShmMap */
-    otaVfsShmLock,                /* xShmLock */
-    otaVfsShmBarrier,             /* xShmBarrier */
-    otaVfsShmUnmap                /* xShmUnmap */
+    rbuVfsClose,                  /* xClose */
+    rbuVfsRead,                   /* xRead */
+    rbuVfsWrite,                  /* xWrite */
+    rbuVfsTruncate,               /* xTruncate */
+    rbuVfsSync,                   /* xSync */
+    rbuVfsFileSize,               /* xFileSize */
+    rbuVfsLock,                   /* xLock */
+    rbuVfsUnlock,                 /* xUnlock */
+    rbuVfsCheckReservedLock,      /* xCheckReservedLock */
+    rbuVfsFileControl,            /* xFileControl */
+    rbuVfsSectorSize,             /* xSectorSize */
+    rbuVfsDeviceCharacteristics,  /* xDeviceCharacteristics */
+    rbuVfsShmMap,                 /* xShmMap */
+    rbuVfsShmLock,                /* xShmLock */
+    rbuVfsShmBarrier,             /* xShmBarrier */
+    rbuVfsShmUnmap                /* xShmUnmap */
   };
-  ota_vfs *pOtaVfs = (ota_vfs*)pVfs;
-  sqlite3_vfs *pRealVfs = pOtaVfs->pRealVfs;
-  ota_file *pFd = (ota_file *)pFile;
+  rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
+  sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
+  rbu_file *pFd = (rbu_file *)pFile;
   int rc = SQLITE_OK;
   const char *zOpen = zName;
 
-  memset(pFd, 0, sizeof(ota_file));
+  memset(pFd, 0, sizeof(rbu_file));
   pFd->pReal = (sqlite3_file*)&pFd[1];
-  pFd->pOtaVfs = pOtaVfs;
+  pFd->pRbuVfs = pRbuVfs;
   pFd->openFlags = flags;
   if( zName ){
     if( flags & SQLITE_OPEN_MAIN_DB ){
@@ -3376,9 +3380,9 @@ static int otaVfsOpen(
       pFd->zWal = z;
     }
     else if( flags & SQLITE_OPEN_WAL ){
-      ota_file *pDb = otaFindMaindb(pOtaVfs, zName);
+      rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName);
       if( pDb ){
-        if( pDb->pOta && pDb->pOta->eStage==OTA_STAGE_OAL ){
+        if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
           /* This call is to open a *-wal file. Intead, open the *-oal. This
           ** code ensures that the string passed to xOpen() is terminated by a
           ** pair of '\0' bytes in case the VFS attempts to extract a URI 
@@ -3394,7 +3398,7 @@ static int otaVfsOpen(
           }else{
             rc = SQLITE_NOMEM;
           }
-          pFd->pOta = pDb->pOta;
+          pFd->pRbu = pDb->pRbu;
         }
         pDb->pWalFd = pFd;
       }
@@ -3408,12 +3412,12 @@ static int otaVfsOpen(
     /* The xOpen() operation has succeeded. Set the sqlite3_file.pMethods
     ** pointer and, if the file is a main database file, link it into the
     ** mutex protected linked list of all such files.  */
-    pFile->pMethods = &otavfs_io_methods;
+    pFile->pMethods = &rbuvfs_io_methods;
     if( flags & SQLITE_OPEN_MAIN_DB ){
-      sqlite3_mutex_enter(pOtaVfs->mutex);
-      pFd->pMainNext = pOtaVfs->pMain;
-      pOtaVfs->pMain = pFd;
-      sqlite3_mutex_leave(pOtaVfs->mutex);
+      sqlite3_mutex_enter(pRbuVfs->mutex);
+      pFd->pMainNext = pRbuVfs->pMain;
+      pRbuVfs->pMain = pFd;
+      sqlite3_mutex_leave(pRbuVfs->mutex);
     }
   }else{
     sqlite3_free(pFd->zDel);
@@ -3425,8 +3429,8 @@ static int otaVfsOpen(
 /*
 ** Delete the file located at zPath.
 */
-static int otaVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xDelete(pRealVfs, zPath, dirSync);
 }
 
@@ -3434,35 +3438,35 @@ static int otaVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
 ** Test for access permissions. Return true if the requested permission
 ** is available, or false otherwise.
 */
-static int otaVfsAccess(
+static int rbuVfsAccess(
   sqlite3_vfs *pVfs, 
   const char *zPath, 
   int flags, 
   int *pResOut
 ){
-  ota_vfs *pOtaVfs = (ota_vfs*)pVfs;
-  sqlite3_vfs *pRealVfs = pOtaVfs->pRealVfs;
+  rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
+  sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
   int rc;
 
   rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
 
-  /* If this call is to check if a *-wal file associated with an OTA target
-  ** database connection exists, and the OTA update is in OTA_STAGE_OAL,
+  /* If this call is to check if a *-wal file associated with an RBU target
+  ** database connection exists, and the RBU update is in RBU_STAGE_OAL,
   ** the following special handling is activated:
   **
   **   a) if the *-wal file does exist, return SQLITE_CANTOPEN. This
-  **      ensures that the OTA extension never tries to update a database
+  **      ensures that the RBU extension never tries to update a database
   **      in wal mode, even if the first page of the database file has
   **      been damaged. 
   **
   **   b) if the *-wal file does not exist, claim that it does anyway,
   **      causing SQLite to call xOpen() to open it. This call will also
-  **      be intercepted (see the otaVfsOpen() function) and the *-oal
+  **      be intercepted (see the rbuVfsOpen() function) and the *-oal
   **      file opened instead.
   */
   if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
-    ota_file *pDb = otaFindMaindb(pOtaVfs, zPath);
-    if( pDb && pDb->pOta && pDb->pOta->eStage==OTA_STAGE_OAL ){
+    rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath);
+    if( pDb && pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
       if( *pResOut ){
         rc = SQLITE_CANTOPEN;
       }else{
@@ -3479,13 +3483,13 @@ static int otaVfsAccess(
 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
 ** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
 */
-static int otaVfsFullPathname(
+static int rbuVfsFullPathname(
   sqlite3_vfs *pVfs, 
   const char *zPath, 
   int nOut, 
   char *zOut
 ){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
 }
 
@@ -3493,8 +3497,8 @@ static int otaVfsFullPathname(
 /*
 ** Open the dynamic library located at zPath and return a handle.
 */
-static void *otaVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xDlOpen(pRealVfs, zPath);
 }
 
@@ -3503,29 +3507,29 @@ static void *otaVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
 ** utf-8 string describing the most recent error encountered associated 
 ** with dynamic libraries.
 */
-static void otaVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static void rbuVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   pRealVfs->xDlError(pRealVfs, nByte, zErrMsg);
 }
 
 /*
 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
 */
-static void (*otaVfsDlSym(
+static void (*rbuVfsDlSym(
   sqlite3_vfs *pVfs, 
   void *pArg, 
   const char *zSym
 ))(void){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xDlSym(pRealVfs, pArg, zSym);
 }
 
 /*
 ** Close the dynamic library handle pHandle.
 */
-static void otaVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xDlClose(pRealVfs, pHandle);
+static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
+  pRealVfs->xDlClose(pRealVfs, pHandle);
 }
 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
 
@@ -3533,8 +3537,8 @@ static void otaVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
 ** Populate the buffer pointed to by zBufOut with nByte bytes of 
 ** random data.
 */
-static int otaVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static int rbuVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xRandomness(pRealVfs, nByte, zBufOut);
 }
 
@@ -3542,45 +3546,45 @@ static int otaVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
 ** Sleep for nMicro microseconds. Return the number of microseconds 
 ** actually slept.
 */
-static int otaVfsSleep(sqlite3_vfs *pVfs, int nMicro){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static int rbuVfsSleep(sqlite3_vfs *pVfs, int nMicro){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xSleep(pRealVfs, nMicro);
 }
 
 /*
 ** Return the current time as a Julian Day number in *pTimeOut.
 */
-static int otaVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
-  sqlite3_vfs *pRealVfs = ((ota_vfs*)pVfs)->pRealVfs;
+static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
   return pRealVfs->xCurrentTime(pRealVfs, pTimeOut);
 }
 
 /*
 ** No-op.
 */
-static int otaVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
+static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
   return 0;
 }
 
 /*
-** Deregister and destroy an OTA vfs created by an earlier call to
-** sqlite3ota_create_vfs().
+** Deregister and destroy an RBU vfs created by an earlier call to
+** sqlite3rbu_create_vfs().
 */
-void sqlite3ota_destroy_vfs(const char *zName){
+void sqlite3rbu_destroy_vfs(const char *zName){
   sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
-  if( pVfs && pVfs->xOpen==otaVfsOpen ){
-    sqlite3_mutex_free(((ota_vfs*)pVfs)->mutex);
+  if( pVfs && pVfs->xOpen==rbuVfsOpen ){
+    sqlite3_mutex_free(((rbu_vfs*)pVfs)->mutex);
     sqlite3_vfs_unregister(pVfs);
     sqlite3_free(pVfs);
   }
 }
 
 /*
-** Create an OTA VFS named zName that accesses the underlying file-system
+** Create an RBU VFS named zName that accesses the underlying file-system
 ** via existing VFS zParent. The new object is registered as a non-default
 ** VFS with SQLite before returning.
 */
-int sqlite3ota_create_vfs(const char *zName, const char *zParent){
+int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
 
   /* Template for VFS */
   static sqlite3_vfs vfs_template = {
@@ -3590,36 +3594,36 @@ int sqlite3ota_create_vfs(const char *zName, const char *zParent){
     0,                            /* pNext */
     0,                            /* zName */
     0,                            /* pAppData */
-    otaVfsOpen,                   /* xOpen */
-    otaVfsDelete,                 /* xDelete */
-    otaVfsAccess,                 /* xAccess */
-    otaVfsFullPathname,           /* xFullPathname */
+    rbuVfsOpen,                   /* xOpen */
+    rbuVfsDelete,                 /* xDelete */
+    rbuVfsAccess,                 /* xAccess */
+    rbuVfsFullPathname,           /* xFullPathname */
 
 #ifndef SQLITE_OMIT_LOAD_EXTENSION
-    otaVfsDlOpen,                 /* xDlOpen */
-    otaVfsDlError,                /* xDlError */
-    otaVfsDlSym,                  /* xDlSym */
-    otaVfsDlClose,                /* xDlClose */
+    rbuVfsDlOpen,                 /* xDlOpen */
+    rbuVfsDlError,                /* xDlError */
+    rbuVfsDlSym,                  /* xDlSym */
+    rbuVfsDlClose,                /* xDlClose */
 #else
     0, 0, 0, 0,
 #endif
 
-    otaVfsRandomness,             /* xRandomness */
-    otaVfsSleep,                  /* xSleep */
-    otaVfsCurrentTime,            /* xCurrentTime */
-    otaVfsGetLastError,           /* xGetLastError */
+    rbuVfsRandomness,             /* xRandomness */
+    rbuVfsSleep,                  /* xSleep */
+    rbuVfsCurrentTime,            /* xCurrentTime */
+    rbuVfsGetLastError,           /* xGetLastError */
     0,                            /* xCurrentTimeInt64 (version 2) */
     0, 0, 0                       /* Unimplemented version 3 methods */
   };
 
-  ota_vfs *pNew = 0;              /* Newly allocated VFS */
+  rbu_vfs *pNew = 0;              /* Newly allocated VFS */
   int nName;
   int rc = SQLITE_OK;
 
   int nByte;
   nName = strlen(zName);
-  nByte = sizeof(ota_vfs) + nName + 1;
-  pNew = (ota_vfs*)sqlite3_malloc(nByte);
+  nByte = sizeof(rbu_vfs) + nName + 1;
+  pNew = (rbu_vfs*)sqlite3_malloc(nByte);
   if( pNew==0 ){
     rc = SQLITE_NOMEM;
   }else{
@@ -3632,7 +3636,7 @@ int sqlite3ota_create_vfs(const char *zName, const char *zParent){
       char *zSpace;
       memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
       pNew->base.mxPathname = pParent->mxPathname;
-      pNew->base.szOsFile = sizeof(ota_file) + pParent->szOsFile;
+      pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
       pNew->pRealVfs = pParent;
       pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
       memcpy(zSpace, zName, nName);
@@ -3658,4 +3662,4 @@ int sqlite3ota_create_vfs(const char *zName, const char *zParent){
 
 /**************************************************************************/
 
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_OTA) */
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
diff --git a/ext/ota/sqlite3ota.h b/ext/rbu/sqlite3rbu.h
similarity index 63%
rename from ext/ota/sqlite3ota.h
rename to ext/rbu/sqlite3rbu.h
index 76f5aba5fb..c3e32f9410 100644
--- a/ext/ota/sqlite3ota.h
+++ b/ext/rbu/sqlite3rbu.h
@@ -10,7 +10,7 @@
 **
 *************************************************************************
 **
-** This file contains the public interface for the OTA extension. 
+** This file contains the public interface for the RBU extension. 
 */
 
 /*
@@ -47,14 +47,14 @@
 ** to read from the original database snapshot. In other words, partially 
 ** applied transactions are not visible to other clients. 
 **
-** "OTA" stands for "Over The Air" update. As in a large database update
+** "RBU" stands for "Resumable Bulk Update". As in a large database update
 ** transmitted via a wireless network to a mobile device. A transaction
-** applied using this extension is hence refered to as an "OTA update".
+** applied using this extension is hence refered to as an "RBU update".
 **
 **
 ** LIMITATIONS
 **
-** An "OTA update" transaction is subject to the following limitations:
+** An "RBU update" transaction is subject to the following limitations:
 **
 **   * The transaction must consist of INSERT, UPDATE and DELETE operations
 **     only.
@@ -79,41 +79,41 @@
 **
 ** PREPARATION
 **
-** An "OTA update" is stored as a separate SQLite database. A database
-** containing an OTA update is an "OTA database". For each table in the 
-** target database to be updated, the OTA database should contain a table
+** An "RBU update" is stored as a separate SQLite database. A database
+** containing an RBU update is an "RBU database". For each table in the 
+** target database to be updated, the RBU database should contain a table
 ** named "data_<target name>" containing the same set of columns as the
-** target table, and one more - "ota_control". The data_% table should 
+** target table, and one more - "rbu_control". The data_% table should 
 ** have no PRIMARY KEY or UNIQUE constraints, but each column should have
 ** the same type as the corresponding column in the target database.
-** The "ota_control" column should have no type at all. For example, if
+** The "rbu_control" column should have no type at all. For example, if
 ** the target database contains:
 **
 **   CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE);
 **
-** Then the OTA database should contain:
+** Then the RBU database should contain:
 **
-**   CREATE TABLE data_t1(a INTEGER, b TEXT, c, ota_control);
+**   CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control);
 **
 ** The order of the columns in the data_% table does not matter.
 **
 ** If the target database table is a virtual table or a table that has no
 ** PRIMARY KEY declaration, the data_% table must also contain a column 
-** named "ota_rowid". This column is mapped to the tables implicit primary 
+** named "rbu_rowid". This column is mapped to the tables implicit primary 
 ** key column - "rowid". Virtual tables for which the "rowid" column does 
-** not function like a primary key value cannot be updated using OTA. For 
+** not function like a primary key value cannot be updated using RBU. For 
 ** example, if the target db contains either of the following:
 **
 **   CREATE VIRTUAL TABLE x1 USING fts3(a, b);
 **   CREATE TABLE x1(a, b)
 **
-** then the OTA database should contain:
+** then the RBU database should contain:
 **
-**   CREATE TABLE data_x1(a, b, ota_rowid, ota_control);
+**   CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control);
 **
 ** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
 ** target table must be present in the input table. For virtual tables,
-** hidden columns are optional - they are updated by OTA if present in
+** hidden columns are optional - they are updated by RBU if present in
 ** the input table, or not otherwise. For example, to write to an fts4
 ** table with a hidden languageid column such as:
 **
@@ -121,12 +121,12 @@
 **
 ** Either of the following input table schemas may be used:
 **
-**   CREATE TABLE data_ft1(a, b, langid, ota_rowid, ota_control);
-**   CREATE TABLE data_ft1(a, b, ota_rowid, ota_control);
+**   CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control);
+**   CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control);
 **
-** For each row to INSERT into the target database as part of the OTA 
+** For each row to INSERT into the target database as part of the RBU 
 ** update, the corresponding data_% table should contain a single record
-** with the "ota_control" column set to contain integer value 0. The
+** with the "rbu_control" column set to contain integer value 0. The
 ** other columns should be set to the values that make up the new record 
 ** to insert. 
 **
@@ -134,54 +134,54 @@
 ** possible to insert a NULL value into the IPK column. Attempting to 
 ** do so results in an SQLITE_MISMATCH error.
 **
-** For each row to DELETE from the target database as part of the OTA 
+** For each row to DELETE from the target database as part of the RBU 
 ** update, the corresponding data_% table should contain a single record
-** with the "ota_control" column set to contain integer value 1. The
+** with the "rbu_control" column set to contain integer value 1. The
 ** real primary key values of the row to delete should be stored in the
 ** corresponding columns of the data_% table. The values stored in the
 ** other columns are not used.
 **
-** For each row to UPDATE from the target database as part of the OTA 
+** For each row to UPDATE from the target database as part of the RBU 
 ** update, the corresponding data_% table should contain a single record
-** with the "ota_control" column set to contain a value of type text.
+** with the "rbu_control" column set to contain a value of type text.
 ** The real primary key values identifying the row to update should be 
 ** stored in the corresponding columns of the data_% table row, as should
 ** the new values of all columns being update. The text value in the 
-** "ota_control" column must contain the same number of characters as
+** "rbu_control" column must contain the same number of characters as
 ** there are columns in the target database table, and must consist entirely
 ** of 'x' and '.' characters (or in some special cases 'd' - see below). For 
 ** each column that is being updated, the corresponding character is set to
 ** 'x'. For those that remain as they are, the corresponding character of the
-** ota_control value should be set to '.'. For example, given the tables 
+** rbu_control value should be set to '.'. For example, given the tables 
 ** above, the update statement:
 **
 **   UPDATE t1 SET c = 'usa' WHERE a = 4;
 **
 ** is represented by the data_t1 row created by:
 **
-**   INSERT INTO data_t1(a, b, c, ota_control) VALUES(4, NULL, 'usa', '..x');
+**   INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x');
 **
-** Instead of an 'x' character, characters of the ota_control value specified
+** Instead of an 'x' character, characters of the rbu_control value specified
 ** for UPDATEs may also be set to 'd'. In this case, instead of updating the
 ** target table with the value stored in the corresponding data_% column, the
-** user-defined SQL function "ota_delta()" is invoked and the result stored in
-** the target table column. ota_delta() is invoked with two arguments - the
+** user-defined SQL function "rbu_delta()" is invoked and the result stored in
+** the target table column. rbu_delta() is invoked with two arguments - the
 ** original value currently stored in the target table column and the 
 ** value specified in the data_xxx table.
 **
 ** For example, this row:
 **
-**   INSERT INTO data_t1(a, b, c, ota_control) VALUES(4, NULL, 'usa', '..d');
+**   INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d');
 **
 ** is similar to an UPDATE statement such as: 
 **
-**   UPDATE t1 SET c = ota_delta(c, 'usa') WHERE a = 4;
+**   UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4;
 **
 ** If the target database table is a virtual table or a table with no PRIMARY
-** KEY, the ota_control value should not include a character corresponding 
-** to the ota_rowid value. For example, this:
+** KEY, the rbu_control value should not include a character corresponding 
+** to the rbu_rowid value. For example, this:
 **
-**   INSERT INTO data_ft1(a, b, ota_rowid, ota_control) 
+**   INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control) 
 **       VALUES(NULL, 'usa', 12, '.x');
 **
 ** causes a result similar to:
@@ -189,7 +189,7 @@
 **   UPDATE ft1 SET b = 'usa' WHERE rowid = 12;
 **
 ** The data_xxx tables themselves should have no PRIMARY KEY declarations.
-** However, OTA is more efficient if reading the rows in from each data_xxx
+** However, RBU is more efficient if reading the rows in from each data_xxx
 ** table in "rowid" order is roughly the same as reading them sorted by
 ** the PRIMARY KEY of the corresponding target database table. In other 
 ** words, rows should be sorted using the destination table PRIMARY KEY 
@@ -197,107 +197,107 @@
 **
 ** USAGE
 **
-** The API declared below allows an application to apply an OTA update 
+** The API declared below allows an application to apply an RBU update 
 ** stored on disk to an existing target database. Essentially, the 
 ** application:
 **
-**     1) Opens an OTA handle using the sqlite3ota_open() function.
+**     1) Opens an RBU handle using the sqlite3rbu_open() function.
 **
 **     2) Registers any required virtual table modules with the database
-**        handle returned by sqlite3ota_db(). Also, if required, register
-**        the ota_delta() implementation.
+**        handle returned by sqlite3rbu_db(). Also, if required, register
+**        the rbu_delta() implementation.
 **
-**     3) Calls the sqlite3ota_step() function one or more times on
-**        the new handle. Each call to sqlite3ota_step() performs a single
+**     3) Calls the sqlite3rbu_step() function one or more times on
+**        the new handle. Each call to sqlite3rbu_step() performs a single
 **        b-tree operation, so thousands of calls may be required to apply 
 **        a complete update.
 **
-**     4) Calls sqlite3ota_close() to close the OTA update handle. If
-**        sqlite3ota_step() has been called enough times to completely
-**        apply the update to the target database, then the OTA database
-**        is marked as fully applied. Otherwise, the state of the OTA 
-**        update application is saved in the OTA database for later 
+**     4) Calls sqlite3rbu_close() to close the RBU update handle. If
+**        sqlite3rbu_step() has been called enough times to completely
+**        apply the update to the target database, then the RBU database
+**        is marked as fully applied. Otherwise, the state of the RBU 
+**        update application is saved in the RBU database for later 
 **        resumption.
 **
 ** See comments below for more detail on APIs.
 **
 ** If an update is only partially applied to the target database by the
-** time sqlite3ota_close() is called, various state information is saved 
-** within the OTA database. This allows subsequent processes to automatically
-** resume the OTA update from where it left off.
+** time sqlite3rbu_close() is called, various state information is saved 
+** within the RBU database. This allows subsequent processes to automatically
+** resume the RBU update from where it left off.
 **
-** To remove all OTA extension state information, returning an OTA database 
+** To remove all RBU extension state information, returning an RBU database 
 ** to its original contents, it is sufficient to drop all tables that begin
-** with the prefix "ota_"
+** with the prefix "rbu_"
 **
 ** DATABASE LOCKING
 **
-** An OTA update may not be applied to a database in WAL mode. Attempting
+** An RBU update may not be applied to a database in WAL mode. Attempting
 ** to do so is an error (SQLITE_ERROR).
 **
-** While an OTA handle is open, a SHARED lock may be held on the target
+** While an RBU handle is open, a SHARED lock may be held on the target
 ** database file. This means it is possible for other clients to read the
 ** database, but not to write it.
 **
-** If an OTA update is started and then suspended before it is completed,
+** If an RBU update is started and then suspended before it is completed,
 ** then an external client writes to the database, then attempting to resume
-** the suspended OTA update is also an error (SQLITE_BUSY).
+** the suspended RBU update is also an error (SQLITE_BUSY).
 */
 
-#ifndef _SQLITE3OTA_H
-#define _SQLITE3OTA_H
+#ifndef _SQLITE3RBU_H
+#define _SQLITE3RBU_H
 
 #include "sqlite3.h"              /* Required for error code definitions */
 
-typedef struct sqlite3ota sqlite3ota;
+typedef struct sqlite3rbu sqlite3rbu;
 
 /*
-** Open an OTA handle.
+** Open an RBU handle.
 **
-** Argument zTarget is the path to the target database. Argument zOta is
-** the path to the OTA database. Each call to this function must be matched
-** by a call to sqlite3ota_close(). When opening the databases, OTA passes
+** Argument zTarget is the path to the target database. Argument zRbu is
+** the path to the RBU database. Each call to this function must be matched
+** by a call to sqlite3rbu_close(). When opening the databases, RBU passes
 ** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget
-** or zOta begin with "file:", it will be interpreted as an SQLite 
+** or zRbu begin with "file:", it will be interpreted as an SQLite 
 ** database URI, not a regular file name.
 **
-** If the zState argument is passed a NULL value, the OTA extension stores 
+** If the zState argument is passed a NULL value, the RBU extension stores 
 ** the current state of the update (how many rows have been updated, which 
-** indexes are yet to be updated etc.) within the OTA database itself. This
-** can be convenient, as it means that the OTA application does not need to
+** indexes are yet to be updated etc.) within the RBU database itself. This
+** can be convenient, as it means that the RBU application does not need to
 ** organize removing a separate state file after the update is concluded. 
 ** Or, if zState is non-NULL, it must be a path to a database file in which 
-** the OTA extension can store the state of the update.
+** the RBU extension can store the state of the update.
 **
-** When resuming an OTA update, the zState argument must be passed the same
-** value as when the OTA update was started.
+** When resuming an RBU update, the zState argument must be passed the same
+** value as when the RBU update was started.
 **
-** Once the OTA update is finished, the OTA extension does not 
+** Once the RBU update is finished, the RBU extension does not 
 ** automatically remove any zState database file, even if it created it.
 **
-** By default, OTA uses the default VFS to access the files on disk. To
+** By default, RBU uses the default VFS to access the files on disk. To
 ** use a VFS other than the default, an SQLite "file:" URI containing a
 ** "vfs=..." option may be passed as the zTarget option.
 **
-** IMPORTANT NOTE FOR ZIPVFS USERS: The OTA extension works with all of
+** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of
 ** SQLite's built-in VFSs, including the multiplexor VFS. However it does
 ** not work out of the box with zipvfs. Refer to the comment describing
-** the zipvfs_create_vfs() API below for details on using OTA with zipvfs.
+** the zipvfs_create_vfs() API below for details on using RBU with zipvfs.
 */
-sqlite3ota *sqlite3ota_open(
+sqlite3rbu *sqlite3rbu_open(
   const char *zTarget, 
-  const char *zOta,
+  const char *zRbu,
   const char *zState
 );
 
 /*
-** Internally, each OTA connection uses a separate SQLite database 
-** connection to access the target and ota update databases. This
+** Internally, each RBU connection uses a separate SQLite database 
+** connection to access the target and rbu update databases. This
 ** API allows the application direct access to these database handles.
 **
-** The first argument passed to this function must be a valid, open, OTA
+** The first argument passed to this function must be a valid, open, RBU
 ** handle. The second argument should be passed zero to access the target
-** database handle, or non-zero to access the ota update database handle.
+** database handle, or non-zero to access the rbu update database handle.
 ** Accessing the underlying database handles may be useful in the
 ** following scenarios:
 **
@@ -305,44 +305,44 @@ sqlite3ota *sqlite3ota_open(
 **     call sqlite3_create_module() on the target database handle to 
 **     register the required virtual table implementations.
 **
-**   * If the data_xxx tables in the OTA source database are virtual 
+**   * If the data_xxx tables in the RBU source database are virtual 
 **     tables, the application may need to call sqlite3_create_module() on
-**     the ota update db handle to any required virtual table
+**     the rbu update db handle to any required virtual table
 **     implementations.
 **
-**   * If the application uses the "ota_delta()" feature described above,
+**   * If the application uses the "rbu_delta()" feature described above,
 **     it must use sqlite3_create_function() or similar to register the
-**     ota_delta() implementation with the target database handle.
+**     rbu_delta() implementation with the target database handle.
 **
-** If an error has occurred, either while opening or stepping the OTA object,
+** If an error has occurred, either while opening or stepping the RBU object,
 ** this function may return NULL. The error code and message may be collected
-** when sqlite3ota_close() is called.
+** when sqlite3rbu_close() is called.
 */
-sqlite3 *sqlite3ota_db(sqlite3ota*, int bOta);
+sqlite3 *sqlite3rbu_db(sqlite3rbu*, int bRbu);
 
 /*
-** Do some work towards applying the OTA update to the target db. 
+** Do some work towards applying the RBU update to the target db. 
 **
 ** Return SQLITE_DONE if the update has been completely applied, or 
 ** SQLITE_OK if no error occurs but there remains work to do to apply
-** the OTA update. If an error does occur, some other error code is 
+** the RBU update. If an error does occur, some other error code is 
 ** returned. 
 **
-** Once a call to sqlite3ota_step() has returned a value other than
-** SQLITE_OK, all subsequent calls on the same OTA handle are no-ops
+** Once a call to sqlite3rbu_step() has returned a value other than
+** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
 ** that immediately return the same value.
 */
-int sqlite3ota_step(sqlite3ota *pOta);
+int sqlite3rbu_step(sqlite3rbu *pRbu);
 
 /*
-** Close an OTA handle. 
+** Close an RBU handle. 
 **
-** If the OTA update has been completely applied, mark the OTA database
+** If the RBU update has been completely applied, mark the RBU database
 ** as fully applied. Otherwise, assuming no error has occurred, save the
-** current state of the OTA update appliation to the OTA database.
+** current state of the RBU update appliation to the RBU database.
 **
-** If an error has already occurred as part of an sqlite3ota_step()
-** or sqlite3ota_open() call, or if one occurs within this function, an
+** If an error has already occurred as part of an sqlite3rbu_step()
+** or sqlite3rbu_open() call, or if one occurs within this function, an
 ** SQLite error code is returned. Additionally, *pzErrmsg may be set to
 ** point to a buffer containing a utf-8 formatted English language error
 ** message. It is the responsibility of the caller to eventually free any 
@@ -352,67 +352,67 @@ int sqlite3ota_step(sqlite3ota *pOta);
 ** update has been partially applied, or SQLITE_DONE if it has been 
 ** completely applied.
 */
-int sqlite3ota_close(sqlite3ota *pOta, char **pzErrmsg);
+int sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg);
 
 /*
 ** Return the total number of key-value operations (inserts, deletes or 
 ** updates) that have been performed on the target database since the
-** current OTA update was started.
+** current RBU update was started.
 */
-sqlite3_int64 sqlite3ota_progress(sqlite3ota *pOta);
+sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu);
 
 /*
-** Create an OTA VFS named zName that accesses the underlying file-system
+** Create an RBU VFS named zName that accesses the underlying file-system
 ** via existing VFS zParent. Or, if the zParent parameter is passed NULL, 
-** then the new OTA VFS uses the default system VFS to access the file-system.
+** then the new RBU VFS uses the default system VFS to access the file-system.
 ** The new object is registered as a non-default VFS with SQLite before 
 ** returning.
 **
-** Part of the OTA implementation uses a custom VFS object. Usually, this
-** object is created and deleted automatically by OTA. 
+** Part of the RBU implementation uses a custom VFS object. Usually, this
+** object is created and deleted automatically by RBU. 
 **
 ** The exception is for applications that also use zipvfs. In this case,
-** the custom VFS must be explicitly created by the user before the OTA
-** handle is opened. The OTA VFS should be installed so that the zipvfs
-** VFS uses the OTA VFS, which in turn uses any other VFS layers in use 
+** the custom VFS must be explicitly created by the user before the RBU
+** handle is opened. The RBU VFS should be installed so that the zipvfs
+** VFS uses the RBU VFS, which in turn uses any other VFS layers in use 
 ** (for example multiplexor) to access the file-system. For example,
-** to assemble an OTA enabled VFS stack that uses both zipvfs and 
+** to assemble an RBU enabled VFS stack that uses both zipvfs and 
 ** multiplexor (error checking omitted):
 **
 **     // Create a VFS named "multiplex" (not the default).
 **     sqlite3_multiplex_initialize(0, 0);
 **
-**     // Create an ota VFS named "ota" that uses multiplexor. If the
-**     // second argument were replaced with NULL, the "ota" VFS would
+**     // Create an rbu VFS named "rbu" that uses multiplexor. If the
+**     // second argument were replaced with NULL, the "rbu" VFS would
 **     // access the file-system via the system default VFS, bypassing the
 **     // multiplexor.
-**     sqlite3ota_create_vfs("ota", "multiplex");
+**     sqlite3rbu_create_vfs("rbu", "multiplex");
 **
-**     // Create a zipvfs VFS named "zipvfs" that uses ota.
-**     zipvfs_create_vfs_v3("zipvfs", "ota", 0, xCompressorAlgorithmDetector);
+**     // Create a zipvfs VFS named "zipvfs" that uses rbu.
+**     zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector);
 **
 **     // Make zipvfs the default VFS.
 **     sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1);
 **
-** Because the default VFS created above includes a OTA functionality, it
-** may be used by OTA clients. Attempting to use OTA with a zipvfs VFS stack
-** that does not include the OTA layer results in an error.
+** Because the default VFS created above includes a RBU functionality, it
+** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack
+** that does not include the RBU layer results in an error.
 **
-** The overhead of adding the "ota" VFS to the system is negligible for 
-** non-OTA users. There is no harm in an application accessing the 
-** file-system via "ota" all the time, even if it only uses OTA functionality 
+** The overhead of adding the "rbu" VFS to the system is negligible for 
+** non-RBU users. There is no harm in an application accessing the 
+** file-system via "rbu" all the time, even if it only uses RBU functionality 
 ** occasionally.
 */
-int sqlite3ota_create_vfs(const char *zName, const char *zParent);
+int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
 
 /*
-** Deregister and destroy an OTA vfs created by an earlier call to
-** sqlite3ota_create_vfs().
+** Deregister and destroy an RBU vfs created by an earlier call to
+** sqlite3rbu_create_vfs().
 **
 ** VFS objects are not reference counted. If a VFS object is destroyed
 ** before all database handles that use it have been closed, the results
 ** are undefined.
 */
-void sqlite3ota_destroy_vfs(const char *zName);
+void sqlite3rbu_destroy_vfs(const char *zName);
 
-#endif /* _SQLITE3OTA_H */
+#endif /* _SQLITE3RBU_H */
diff --git a/ext/ota/test_ota.c b/ext/rbu/test_rbu.c
similarity index 71%
rename from ext/ota/test_ota.c
rename to ext/rbu/test_rbu.c
index 33ef634030..fbaea16268 100644
--- a/ext/ota/test_ota.c
+++ b/ext/rbu/test_rbu.c
@@ -14,23 +14,23 @@
 #include "sqlite3.h"
 
 #if defined(SQLITE_TEST)
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_OTA)
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
 
-#include "sqlite3ota.h"
+#include "sqlite3rbu.h"
 #include <tcl.h>
 #include <assert.h>
 
 /* From main.c (apparently...) */
 extern const char *sqlite3ErrName(int);
 
-void test_ota_delta(sqlite3_context *pCtx, int nArg, sqlite3_value **apVal){
+void test_rbu_delta(sqlite3_context *pCtx, int nArg, sqlite3_value **apVal){
   Tcl_Interp *interp = (Tcl_Interp*)sqlite3_user_data(pCtx);
   Tcl_Obj *pScript;
   int i;
 
   pScript = Tcl_NewObj();
   Tcl_IncrRefCount(pScript);
-  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj("ota_delta", -1));
+  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj("rbu_delta", -1));
   for(i=0; i<nArg; i++){
     sqlite3_value *pIn = apVal[i];
     const char *z = (const char*)sqlite3_value_text(pIn);
@@ -48,15 +48,15 @@ void test_ota_delta(sqlite3_context *pCtx, int nArg, sqlite3_value **apVal){
 }
 
 
-static int test_sqlite3ota_cmd(
+static int test_sqlite3rbu_cmd(
   ClientData clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int ret = TCL_OK;
-  sqlite3ota *pOta = (sqlite3ota*)clientData;
-  const char *azMethod[] = { "step", "close", "create_ota_delta", 0 };
+  sqlite3rbu *pRbu = (sqlite3rbu*)clientData;
+  const char *azMethod[] = { "step", "close", "create_rbu_delta", 0 };
   int iMethod;
 
   if( objc!=2 ){
@@ -69,7 +69,7 @@ static int test_sqlite3ota_cmd(
 
   switch( iMethod ){
     case 0: /* step */ {
-      int rc = sqlite3ota_step(pOta);
+      int rc = sqlite3rbu_step(pRbu);
       Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
       break;
     }
@@ -78,7 +78,7 @@ static int test_sqlite3ota_cmd(
       char *zErrmsg = 0;
       int rc;
       Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
-      rc = sqlite3ota_close(pOta, &zErrmsg);
+      rc = sqlite3rbu_close(pRbu, &zErrmsg);
       if( rc==SQLITE_OK || rc==SQLITE_DONE ){
         Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
         assert( zErrmsg==0 );
@@ -93,10 +93,10 @@ static int test_sqlite3ota_cmd(
       break;
     }
 
-    case 2: /* create_ota_delta */ {
-      sqlite3 *db = sqlite3ota_db(pOta, 0);
+    case 2: /* create_rbu_delta */ {
+      sqlite3 *db = sqlite3rbu_db(pRbu, 0);
       int rc = sqlite3_create_function(
-          db, "ota_delta", -1, SQLITE_UTF8, (void*)interp, test_ota_delta, 0, 0
+          db, "rbu_delta", -1, SQLITE_UTF8, (void*)interp, test_rbu_delta, 0, 0
       );
       Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
       ret = (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
@@ -112,39 +112,39 @@ static int test_sqlite3ota_cmd(
 }
 
 /*
-** Tclcmd: sqlite3ota CMD <target-db> <ota-db> ?<state-db>?
+** Tclcmd: sqlite3rbu CMD <target-db> <rbu-db> ?<state-db>?
 */
-static int test_sqlite3ota(
+static int test_sqlite3rbu(
   ClientData clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
-  sqlite3ota *pOta = 0;
+  sqlite3rbu *pRbu = 0;
   const char *zCmd;
   const char *zTarget;
-  const char *zOta;
+  const char *zRbu;
   const char *zStateDb = 0;
 
   if( objc!=4 && objc!=5 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB OTA-DB ?STATE-DB?");
+    Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB RBU-DB ?STATE-DB?");
     return TCL_ERROR;
   }
   zCmd = Tcl_GetString(objv[1]);
   zTarget = Tcl_GetString(objv[2]);
-  zOta = Tcl_GetString(objv[3]);
+  zRbu = Tcl_GetString(objv[3]);
   if( objc==5 ) zStateDb = Tcl_GetString(objv[4]);
 
-  pOta = sqlite3ota_open(zTarget, zOta, zStateDb);
-  Tcl_CreateObjCommand(interp, zCmd, test_sqlite3ota_cmd, (ClientData)pOta, 0);
+  pRbu = sqlite3rbu_open(zTarget, zRbu, zStateDb);
+  Tcl_CreateObjCommand(interp, zCmd, test_sqlite3rbu_cmd, (ClientData)pRbu, 0);
   Tcl_SetObjResult(interp, objv[1]);
   return TCL_OK;
 }
 
 /*
-** Tclcmd: sqlite3ota_create_vfs ?-default? NAME PARENT
+** Tclcmd: sqlite3rbu_create_vfs ?-default? NAME PARENT
 */
-static int test_sqlite3ota_create_vfs(
+static int test_sqlite3rbu_create_vfs(
   ClientData clientData,
   Tcl_Interp *interp,
   int objc,
@@ -163,7 +163,7 @@ static int test_sqlite3ota_create_vfs(
   zParent = Tcl_GetString(objv[objc-1]);
   if( zParent[0]=='\0' ) zParent = 0;
 
-  rc = sqlite3ota_create_vfs(zName, zParent);
+  rc = sqlite3rbu_create_vfs(zName, zParent);
   if( rc!=SQLITE_OK ){
     Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
     return TCL_ERROR;
@@ -177,9 +177,9 @@ static int test_sqlite3ota_create_vfs(
 }
 
 /*
-** Tclcmd: sqlite3ota_destroy_vfs NAME
+** Tclcmd: sqlite3rbu_destroy_vfs NAME
 */
-static int test_sqlite3ota_destroy_vfs(
+static int test_sqlite3rbu_destroy_vfs(
   ClientData clientData,
   Tcl_Interp *interp,
   int objc,
@@ -193,14 +193,14 @@ static int test_sqlite3ota_destroy_vfs(
   }
 
   zName = Tcl_GetString(objv[1]);
-  sqlite3ota_destroy_vfs(zName);
+  sqlite3rbu_destroy_vfs(zName);
   return TCL_OK;
 }
 
 /*
-** Tclcmd: sqlite3ota_internal_test
+** Tclcmd: sqlite3rbu_internal_test
 */
-static int test_sqlite3ota_internal_test(
+static int test_sqlite3rbu_internal_test(
   ClientData clientData,
   Tcl_Interp *interp,
   int objc,
@@ -213,24 +213,24 @@ static int test_sqlite3ota_internal_test(
     return TCL_ERROR;
   }
 
-  db = sqlite3ota_db(0, 0);
+  db = sqlite3rbu_db(0, 0);
   if( db!=0 ){
-    Tcl_AppendResult(interp, "sqlite3ota_db(0, 0)!=0", 0);
+    Tcl_AppendResult(interp, "sqlite3rbu_db(0, 0)!=0", 0);
     return TCL_ERROR;
   }
 
   return TCL_OK;
 }
 
-int SqliteOta_Init(Tcl_Interp *interp){ 
+int SqliteRbu_Init(Tcl_Interp *interp){ 
   static struct {
      char *zName;
      Tcl_ObjCmdProc *xProc;
   } aObjCmd[] = {
-    { "sqlite3ota", test_sqlite3ota },
-    { "sqlite3ota_create_vfs", test_sqlite3ota_create_vfs },
-    { "sqlite3ota_destroy_vfs", test_sqlite3ota_destroy_vfs },
-    { "sqlite3ota_internal_test", test_sqlite3ota_internal_test },
+    { "sqlite3rbu", test_sqlite3rbu },
+    { "sqlite3rbu_create_vfs", test_sqlite3rbu_create_vfs },
+    { "sqlite3rbu_destroy_vfs", test_sqlite3rbu_destroy_vfs },
+    { "sqlite3rbu_internal_test", test_sqlite3rbu_internal_test },
   };
   int i;
   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
@@ -241,7 +241,6 @@ int SqliteOta_Init(Tcl_Interp *interp){
 
 #else
 #include <tcl.h>
-int SqliteOta_Init(Tcl_Interp *interp){ return TCL_OK; }
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_OTA) */
+int SqliteRbu_Init(Tcl_Interp *interp){ return TCL_OK; }
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
 #endif /* defined(SQLITE_TEST) */
-
diff --git a/main.mk b/main.mk
index 0219689201..7f2d6f0304 100644
--- a/main.mk
+++ b/main.mk
@@ -65,7 +65,7 @@ LIBOBJ+= vdbe.o parse.o \
          mutex.o mutex_noop.o mutex_unix.o mutex_w32.o \
          notify.o opcodes.o os.o os_unix.o os_win.o \
          pager.o pcache.o pcache1.o pragma.o prepare.o printf.o \
-         random.o resolve.o rowset.o rtree.o select.o sqlite3ota.o status.o \
+         random.o resolve.o rowset.o rtree.o select.o sqlite3rbu.o status.o \
          table.o threads.o tokenize.o treeview.o trigger.o \
          update.o userauth.o util.o vacuum.o \
          vdbeapi.o vdbeaux.o vdbeblob.o vdbemem.o vdbesort.o \
@@ -226,8 +226,8 @@ SRC += \
   $(TOP)/ext/userauth/sqlite3userauth.h 
 
 SRC += \
-  $(TOP)/ext/ota/sqlite3ota.c \
-  $(TOP)/ext/ota/sqlite3ota.h
+  $(TOP)/ext/rbu/sqlite3rbu.c \
+  $(TOP)/ext/rbu/sqlite3rbu.h
 
 
 # Generated source code files
@@ -246,7 +246,7 @@ SRC += \
 TESTSRC = \
   $(TOP)/ext/fts3/fts3_term.c \
   $(TOP)/ext/fts3/fts3_test.c \
-  $(TOP)/ext/ota/test_ota.c \
+  $(TOP)/ext/rbu/test_rbu.c \
   $(TOP)/src/test1.c \
   $(TOP)/src/test2.c \
   $(TOP)/src/test3.c \
@@ -446,11 +446,12 @@ sqldiff$(EXE):	$(TOP)/tool/sqldiff.c sqlite3.c sqlite3.h
 		$(TOP)/tool/sqldiff.c sqlite3.c $(TLIBS) $(THREADLIB)
 
 fuzzershell$(EXE):	$(TOP)/tool/fuzzershell.c sqlite3.c sqlite3.h
-	$(TCCX) -o fuzzershell$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION\
+	$(TCCX) -o fuzzershell$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
 		$(TOP)/tool/fuzzershell.c sqlite3.c $(TLIBS) $(THREADLIB)
 
 fuzzcheck$(EXE):	$(TOP)/test/fuzzcheck.c sqlite3.c sqlite3.h
-	$(TCCX) -o fuzzcheck$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION\
+	$(TCCX) -o fuzzcheck$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
+		-DSQLITE_ENABLE_MEMSYS5 \
 		$(TOP)/test/fuzzcheck.c sqlite3.c $(TLIBS) $(THREADLIB)
 
 mptester$(EXE):	sqlite3.c $(TOP)/mptest/mptest.c
@@ -666,8 +667,8 @@ fts5.c: $(FTS5_SRC)
 userauth.o:	$(TOP)/ext/userauth/userauth.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/userauth/userauth.c
 
-sqlite3ota.o:	$(TOP)/ext/ota/sqlite3ota.c $(HDR) $(EXTHDR)
-	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/ota/sqlite3ota.c
+sqlite3rbu.o:	$(TOP)/ext/rbu/sqlite3rbu.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/rbu/sqlite3rbu.c
 
 
 # Rules for building test programs and for running tests
@@ -724,8 +725,11 @@ queryplantest:	testfixture$(EXE) sqlite3$(EXE)
 fuzztest:	fuzzcheck$(EXE) $(FUZZDATA)
 	./fuzzcheck$(EXE) $(FUZZDATA)
 
+fastfuzztest:	fuzzcheck$(EXE) $(FUZZDATA)
+	./fuzzcheck$(EXE) --limit-mem 100M $(FUZZDATA)
+
 valgrindfuzz:	fuzzcheck$(EXE) $(FUZZDATA)
-	valgrind ./fuzzcheck$(EXE) --cell-size-check --quiet $(FUZZDATA)
+	valgrind ./fuzzcheck$(EXE) --cell-size-check --limit-mem 10M $(FUZZDATA)
 
 # A very quick test using only testfixture and omitting all the slower
 # tests.  Designed to run in under 3 minutes on a workstation.
@@ -736,7 +740,7 @@ quicktest:	./testfixture$(EXE)
 # The default test case.  Runs most of the faster standard TCL tests,
 # and fuzz tests, and sqlite3_analyzer and sqldiff tests.
 #
-test:	$(TESTPROGS) fuzztest
+test:	$(TESTPROGS) fastfuzztest
 	./testfixture$(EXE) $(TOP)/test/veryquick.test $(TESTOPTS)
 
 # Run a test using valgrind.  This can take a really long time
@@ -811,8 +815,8 @@ wordcount$(EXE):	$(TOP)/test/wordcount.c sqlite3.c
 speedtest1$(EXE):	$(TOP)/test/speedtest1.c sqlite3.o
 	$(TCC) -I. $(OTAFLAGS) -o speedtest1$(EXE) $(TOP)/test/speedtest1.c sqlite3.o $(THREADLIB) 
 
-ota$(EXE): $(TOP)/ext/ota/ota.c $(TOP)/ext/ota/sqlite3ota.c sqlite3.o 
-	$(TCC) -I. -o ota$(EXE) $(TOP)/ext/ota/ota.c sqlite3.o \
+rbu$(EXE): $(TOP)/ext/rbu/rbu.c $(TOP)/ext/rbu/sqlite3rbu.c sqlite3.o 
+	$(TCC) -I. -o rbu$(EXE) $(TOP)/ext/rbu/rbu.c sqlite3.o \
 	  $(THREADLIB)
 
 loadfts: $(TOP)/tool/loadfts.c libsqlite3.a
diff --git a/manifest b/manifest
index 0430c68b87..01a5320a85 100644
--- a/manifest
+++ b/manifest
@@ -1,9 +1,9 @@
-C Merge\strunk\schanges,\sincluding\sfixes\sfor\scompiler\swarnings\sin\sfts5\scode,\swith\sthis\sbranch.
-D 2015-07-16T20:24:42.461
+C Merge\slatest\strunk\schanges\swith\sthis\sbranch.
+D 2015-07-27T10:46:48.669
 F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
-F Makefile.in 6e8af213d49e6325bf283ebed7662254f8e15bda
+F Makefile.in 4de3ef40c8b3b75c0c55ff4242a43c8ce1ad90ee
 F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
-F Makefile.msc efafcbf2be203b61dc7b6301703544753c513cb2
+F Makefile.msc 3c258b2f98adb08c7ca5950bee2d6670d6ee3f9a
 F Makefile.vxworks e1b65dea203f054e71653415bd8f96dcaed47858
 F README.md 8ecc12493ff9f820cdea6520a9016001cb2e59b7
 F VERSION ce0ae95abd7121c534f6917c1c8f2b70d9acd4db
@@ -23,7 +23,7 @@ F autoconf/depcomp 0b26f101e3bc9fd1ff0be1da9fb4a82371142f92 x
 F autoconf/install-sh 06ee6336e63bb845c8439d777c32eb2eccc4fbf1 x
 F autoconf/ltmain.sh 7a658a24028f02331c1d2446562758083c5eadd1
 F autoconf/missing d7c9981a81af13370d4ed152b24c0a82b7028585 x
-F autoconf/tea/Makefile.in d55bcc63832caf0309c2ff80358756116618cfca
+F autoconf/tea/Makefile.in b438a7020446c8a8156e8d97c8914a04833da6fd
 F autoconf/tea/README 3e9a3c060f29a44344ab50aec506f4db903fb873
 F autoconf/tea/aclocal.m4 52c47aac44ce0ddb1f918b6993e8beb8eee88f43
 F autoconf/tea/configure.ac 93d43c79e936fb16556e22498177d7e8571efa04
@@ -78,7 +78,7 @@ F ext/fts3/README.content fdc666a70d5257a64fee209f97cf89e0e6e32b51
 F ext/fts3/README.syntax a19711dc5458c20734b8e485e75fb1981ec2427a
 F ext/fts3/README.tokenizers e0a8b81383ea60d0334d274fadf305ea14a8c314
 F ext/fts3/README.txt 8c18f41574404623b76917b9da66fcb0ab38328d
-F ext/fts3/fts3.c d2f7981f4d7dfeb76aac82a15c7f37f425329c0f
+F ext/fts3/fts3.c b04b0c57761fdba2ae562d9d9ba50c7c4a95d9ea
 F ext/fts3/fts3.h 3a10a0af180d502cecc50df77b1b22df142817fe
 F ext/fts3/fts3Int.h 601743955ac43a0e82e6828a931c07bb3b0c95ff
 F ext/fts3/fts3_aux.c 9edc3655fcb287f0467d0a4b886a01c6185fe9f1
@@ -110,9 +110,9 @@ F ext/fts5/fts5Int.h 8d9bce1847a10df2e4ed9492ea4f3868276748fb
 F ext/fts5/fts5_aux.c 044cb176a815f4388308738437f6e130aa384fb0
 F ext/fts5/fts5_buffer.c 80f9ba4431848cb857e3d2158f5280093dcd8015
 F ext/fts5/fts5_config.c fdfa63ae8e527ecfaa50f94063c610429cc887cf
-F ext/fts5/fts5_expr.c ac0614f843cf5c80a85c4c6aa44bbede62a51bb2
+F ext/fts5/fts5_expr.c 56dcbcbdc9029dd76a31360de664559839f4be41
 F ext/fts5/fts5_hash.c ff07722c73587c12781213133edbdb22cd156378
-F ext/fts5/fts5_index.c 60c688801ce59f421c6073da047a3ebc0b3ec079
+F ext/fts5/fts5_index.c e0580e54ce3f44f516231d07be6ce21a550fc9dc
 F ext/fts5/fts5_main.c 0de7ba81488d2c502c8e794eaf7983d468e4c6e9
 F ext/fts5/fts5_storage.c 877399c557f273a725b5e4fc26f07e67ca90570a
 F ext/fts5/fts5_tcl.c 85eb4e0d0fefa9420b78151496ad4599a1783e20
@@ -200,25 +200,26 @@ F ext/misc/totype.c 4a167594e791abeed95e0a8db028822b5e8fe512
 F ext/misc/vfslog.c fe40fab5c077a40477f7e5eba994309ecac6cc95
 F ext/misc/vtshim.c babb0dc2bf116029e3e7c9a618b8a1377045303e
 F ext/misc/wholenumber.c 784b12543d60702ebdd47da936e278aa03076212
-F ext/ota/ota.c 3a849c3b0a4ad6e63125668be9f67be03621216e
-F ext/ota/ota1.test abdcbe746db4c7f7b51e842b576cacb33eef28f5
-F ext/ota/ota10.test 85e0f6e7964db5007590c1b299e75211ed4240d4
-F ext/ota/ota11.test 2f606cd2b4af260a86b549e91b9f395450fc75cb
-F ext/ota/ota12.test e4c0b9a14255ffbe04d241fc15da2c65b3c06846
-F ext/ota/ota13.test f7a3d73fa5d3fabf2755b569f125fce7390a874c
-F ext/ota/ota3.test 3fe3521fbdce32d0e4e116a60999c3cba47712c5
-F ext/ota/ota5.test ad0799daf8923ddebffe75ae8c5504ca90b7fadb
-F ext/ota/ota6.test 3bde7f69a894748b27206b6753462ec3b75b6bb6
-F ext/ota/ota7.test 1fe2c5761705374530e29f70c39693076028221a
-F ext/ota/ota8.test cd70e63a0c29c45c0906692827deafa34638feda
-F ext/ota/ota9.test d3eee95dd836824d07a22e5efcdb7bf6e869358b
-F ext/ota/otaA.test ab67f7f53670b81c750dcc946c5b704f51c429a4
-F ext/ota/otacrash.test 8346192b2d46cbe7787d5d65904d81d3262a3cbf
-F ext/ota/otafault.test 8c43586c2b96ca16bbce00b5d7e7d67316126db8
-F ext/ota/otafault2.test fa202a98ca221faec318f3e5c5f39485b1256561
-F ext/ota/sqlite3ota.c 21575d86eac30482a9bfbb2a531f433015e0e03c
-F ext/ota/sqlite3ota.h 4c66588429338b8977f33caa4c1d026d16fc383e
-F ext/ota/test_ota.c a876f88550d7d59a3ef62d4c1a5c04c4c2f1ebe1
+F ext/rbu/rbu.c e572f7ddef2ef3a73d03e7b44d36448e466772b7 w ext/ota/ota.c
+F ext/rbu/rbu1.test 57601977588603e82700a43c279bd55282ffa482 w ext/ota/ota1.test
+F ext/rbu/rbu10.test 046b0980041d30700464a800bbf6733ed2df515d w ext/ota/ota10.test
+F ext/rbu/rbu11.test 9bc68c2d3dbeb1720153626e3bd0466dcc017702 w ext/ota/ota11.test
+F ext/rbu/rbu12.test bde22ed0004dd5d1888c72a84ae407e574aeae16 w ext/ota/ota12.test
+F ext/rbu/rbu13.test 462ff799c4afedc3ef8a47ff818c0ffbf14ae4f2 w ext/ota/ota13.test
+F ext/rbu/rbu14.test 01f5dcba904aecadbaea69d4ccdc2ea43dd30560
+F ext/rbu/rbu3.test 8bd4c6b87367c358981b6a47dc3d654fa60bff90 w ext/ota/ota3.test
+F ext/rbu/rbu5.test 2e24fee3e615aecd99bbdd46967935a641e866f7 w ext/ota/ota5.test
+F ext/rbu/rbu6.test 32e8ed60631b6facdb6366bd2b5f5f25245e7edb w ext/ota/ota6.test
+F ext/rbu/rbu7.test fd025d5ba440fcfe151fbb0e3835e1e7fe964fa1 w ext/ota/ota7.test
+F ext/rbu/rbu8.test 3bbf2c35d71a843c463efe93946f14ad10c3ede0 w ext/ota/ota8.test
+F ext/rbu/rbu9.test 0806d1772c9f4981774ff028de6656e4183082af w ext/ota/ota9.test
+F ext/rbu/rbuA.test c1a7b3e2d926b8f8448bb3b4ae787e314ee4b2b3 w ext/ota/otaA.test
+F ext/rbu/rbucrash.test 8d2ed5d4b05fef6c00c2a6b5f7ead71fa172a695 w ext/ota/otacrash.test
+F ext/rbu/rbufault.test cc0be8d5d392d98b0c2d6a51be377ea989250a89 w ext/ota/otafault.test
+F ext/rbu/rbufault2.test 9a7f19edd6ea35c4c9f807d8a3db0a03a5670c06 w ext/ota/otafault2.test
+F ext/rbu/sqlite3rbu.c dbd7e4b31821398dcdeb21492970401ff1027881 w ext/ota/sqlite3ota.c
+F ext/rbu/sqlite3rbu.h 6a280298e9eeb8ef59841a620f07f4f844651545 w ext/ota/sqlite3ota.h
+F ext/rbu/test_rbu.c f99698956cc9158d6bf865e461e2d15876538ac1 w ext/ota/test_ota.c
 F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
 F ext/rtree/rtree.c 0f9b595bd0debcbedf1d7a63d0e0678d619e6c9c
 F ext/rtree/rtree.h 834dbcb82dc85b2481cde6a07cdadfddc99e9b9e
@@ -248,7 +249,7 @@ F ext/userauth/userauth.c 5fa3bdb492f481bbc1709fc83c91ebd13460c69e
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 7f0c666075028f306001ec9e883cf20dcb2deb64
+F main.mk 538244d18f37f30a45da813a7bc43294e6fda8cc
 F mkopcodec.awk c2ff431854d702cdd2d779c9c0d1f58fa16fa4ea
 F mkopcodeh.awk 0e7f04a8eb90f92259e47d80110e4e98d7ce337a
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
@@ -282,7 +283,7 @@ F src/delete.c 8857a6f27560718f65d43bdbec86c967ae1f8dfa
 F src/expr.c c5c58e4d01c7ceb2266791d8d877f1b23a88e316
 F src/fault.c 160a0c015b6c2629d3899ed2daf63d75754a32bb
 F src/fkey.c c9b63a217d86582c22121699a47f22f524608869
-F src/func.c a98ea5880dc50e9ca6dd6f57079a37b9cfcdecf1
+F src/func.c 824bea430d3a2b7dbc62806ad54da8fdb8ed9e3f
 F src/global.c 508e4087f7b41d688e4762dcf4d4fe28cfbc87f9
 F src/hash.c 4263fbc955f26c2e8cdc0cf214bc42435aa4e4f5
 F src/hash.h c8f3c31722cf3277d03713909761e152a5b81094
@@ -291,8 +292,8 @@ F src/insert.c b5f8b35a1b7924020e48cade5b2b5017bca7906b
 F src/journal.c b4124532212b6952f42eb2c12fa3c25701d8ba8d
 F src/legacy.c ba1863ea58c4c840335a84ec276fc2b25e22bc4e
 F src/lempar.c 92bafa308607dd985ca389a788cd9e0a2b608712
-F src/loadext.c e722f4b832f923744788365df5fb8515c0bc8a47
-F src/main.c 92d79bfa1a36c7c554700bb58eb8327abff1ac5c
+F src/loadext.c dfcee8c7c032cd0fd55af3e0fc1fcfb01e426df2
+F src/main.c 0a60b7ca8252c3a6f95438fa4ce8fe5b275c69f2
 F src/malloc.c 19461e159bccf0e2cf06a50e867963d0a7b124a8
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c abe6ee469b6c5a35c7f22bfeb9c9bac664a1c987
@@ -329,15 +330,15 @@ F src/resolve.c 2d47554370de8de6dd5be060cef9559eec315005
 F src/rowset.c eccf6af6d620aaa4579bd3b72c1b6395d9e9fa1e
 F src/select.c 57ef3d98c4400b93eea318813be41b2af2da2217
 F src/shell.c 8af3cced094aebb5f57a8ad739b9dafc7867eed7
-F src/sqlite.h.in 3d951bf985839de7fcf4d3f69568bb4df2641abe
+F src/sqlite.h.in f623dd30a4fb7df2fb44a2a85e27813d25e486c2
 F src/sqlite3.rc 992c9f5fb8285ae285d6be28240a7e8d3a7f2bad
-F src/sqlite3ext.h be1a718b7d2ce40ceba725ae92c8eb5f18003066
-F src/sqliteInt.h c67d0a1368484dd156e7d13caa62862adc2ebefa
+F src/sqlite3ext.h a0b948ebc89bac13941254641326a6aa248c2cc4
+F src/sqliteInt.h 81f458941cfb30c5536c37930fb6f41e66171284
 F src/sqliteLimit.h 216557999cb45f2e3578ed53ebefe228d779cb46
 F src/status.c f266ad8a2892d659b74f0f50cb6a88b6e7c12179
 F src/table.c 51b46b2a62d1b3a959633d593b89bab5e2c9155e
-F src/tclsqlite.c 13b9c2aa725882de807377fa889682eff2a74114
-F src/test1.c 375d7bd56d9f806095deb91a3dafe61bd0e367c8
+F src/tclsqlite.c d9439b6a910985b7fff43ba6756bcef00de22649
+F src/test1.c ab312f4160fdd9c82e65e8b123e35ef17e879c07
 F src/test2.c 577961fe48961b2f2e5c8b56ee50c3f459d3359d
 F src/test3.c 64d2afdd68feac1bb5e2ffb8226c8c639f798622
 F src/test4.c d168f83cc78d02e8d35567bb5630e40dcd85ac1e
@@ -351,7 +352,7 @@ F src/test_autoext.c dea8a01a7153b9adc97bd26161e4226329546e12
 F src/test_backup.c 2e6e6a081870150f20c526a2e9d0d29cda47d803
 F src/test_blob.c e5a7a81d61a780da79101aeb1e60d300af169e07
 F src/test_btree.c 2e9978eca99a9a4bfa8cae949efb00886860a64f
-F src/test_config.c b14036415582c329d2a7b154ce079e0f623113ce
+F src/test_config.c fb2e5d354d9a077f5fbb261652eff4787deb104f
 F src/test_demovfs.c 0de72c2c89551629f58486fde5734b7d90758852
 F src/test_devsym.c e7498904e72ba7491d142d5c83b476c4e76993bc
 F src/test_fs.c ced436e3d4b8e4681328409b8081051ce614e28f
@@ -362,7 +363,7 @@ F src/test_intarray.c 870124b95ec4c645d4eb84f15efb7133528fb1a5
 F src/test_intarray.h 9dc57417fb65bc7835cc18548852cc08cc062202
 F src/test_journal.c 5360fbe1d1e4416ca36290562fd5a2e3f70f32aa
 F src/test_loadext.c a5251f956ab6af21e138dc1f9c0399394a510cb4
-F src/test_malloc.c 208f09a4e21defa496bc1094fcfadea19385a112
+F src/test_malloc.c 27d9e11b6e9d30267465d41ad81edbe24256408b
 F src/test_multiplex.c 9fefd23f6cc3fa9bf0748a5e453167e7b9f193ce
 F src/test_multiplex.h c08e4e8f8651f0c5e0509b138ff4d5b43ed1f5d3
 F src/test_mutex.c dbdfaff8580071f2212a0deae3325a93a737819c
@@ -390,10 +391,10 @@ F src/update.c 487747b328b7216bb7f6af0695d6937d5c9e605f
 F src/utf.c fc6b889ba0779b7722634cdeaa25f1930d93820c
 F src/util.c 46358a204b35971a839341cf64599d65b151ba88
 F src/vacuum.c 2ddd5cad2a7b9cef7f9e431b8c7771634c6b1701
-F src/vdbe.c 5ee4a2bf871418f61d06dc256b9b3a0084b5ec46
+F src/vdbe.c 86be40a4568f5385048ea6623adfd11ddb7bf710
 F src/vdbe.h 7a75045d879118b9d3af7e8b3c108f2f27c51473
 F src/vdbeInt.h 8b54e01ad0463590e7cffabce0bc36da9ee4f816
-F src/vdbeapi.c 2fa7ed7520313d6dd1dc6e6495999201c630adfc
+F src/vdbeapi.c adabbd66eb2e3a10f3998485ee0be7e326d06ee4
 F src/vdbeaux.c 787f5f9d58f4c6f39294ed06909ba602d1a402e6
 F src/vdbeblob.c 4f2e8e075d238392df98c5e03a64342465b03f90
 F src/vdbemem.c ae38a0d35ae71cf604381a887c170466ba518090
@@ -401,12 +402,12 @@ F src/vdbesort.c f5009e7a35e3065635d8918b9a31f498a499976b
 F src/vdbetrace.c 8befe829faff6d9e6f6e4dee5a7d3f85cc85f1a0
 F src/vtab.c 082b35a25a26e3d36f365ca8cd73c1922532f05e
 F src/vxworks.h c18586c8edc1bddbc15c004fa16aeb1e1342b4fb
-F src/wal.c 6c9354c72452ab5699a44381ae03004ee2893824
+F src/wal.c 6fb6b68969e4692593c2552c4e7bff5882de2cb8
 F src/wal.h df01efe09c5cb8c8e391ff1715cca294f89668a4
 F src/walker.c c253b95b4ee44b21c406e2a1052636c31ea27804
 F src/where.c 909eba3b6db984eb2adfbca9de2c237ee7056adb
 F src/whereInt.h 5f87e3c4b0551747d119730dfebddd3c54f04047
-F src/wherecode.c 0669481cabaf5caf934b6bb825df15bc57f60d40
+F src/wherecode.c 5da5049224f12db314931ae7e0919b4914a2a0b1
 F src/whereexpr.c 9ce1c9cfedbf80c93c7d899497025ec8256ce652
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
 F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
@@ -732,10 +733,10 @@ F test/func5.test cdd224400bc3e48d891827cc913a57051a426fa4
 F test/fuzz-oss1.test 4912e528ec9cf2f42134456933659d371c9e0d74
 F test/fuzz.test 96083052bf5765e4518c1ba686ce2bab785670d1
 F test/fuzz2.test 76dc35b32b6d6f965259508508abce75a6c4d7e1
-F test/fuzz3.test 0d13010d1c13003a3aa57dda2f69b6b71ccac46e
+F test/fuzz3.test 53fabcd5f0f430f8b221282f6c12c4d0903c21eb
 F test/fuzz_common.tcl a87dfbb88c2a6b08a38e9a070dabd129e617b45b
 F test/fuzz_malloc.test 328f70aaca63adf29b4c6f06505ed0cf57ca7c26
-F test/fuzzcheck.c b973b06b500e6fc052d7059257cdf70df1f3a986
+F test/fuzzcheck.c 79980bbc00e19ad44c3ba6699e643348572757a2
 F test/fuzzdata1.db 7ee3227bad0e7ccdeb08a9e6822916777073c664
 F test/fuzzdata2.db f03a420d3b822cc82e4f894ca957618fbe9c4973
 F test/fuzzdata3.db 1d6044c33a114007f02b6e6846f1fa232f607bfd
@@ -817,13 +818,13 @@ F test/lock5.test c6c5e0ebcb21c61a572870cc86c0cb9f14cede38
 F test/lock6.test ad5b387a3a8096afd3c68a55b9535056431b0cf5
 F test/lock7.test 49f1eaff1cdc491cc5dee3669f3c671d9f172431
 F test/lock_common.tcl 7ffb45accf6ee91c736df9bafe0806a44358f035
-F test/lookaside.test 93f07bac140c5bb1d49f3892d2684decafdc7af2
+F test/lookaside.test 90052e87282de256d613fcf8c9cbb845e4001d2f
 F test/main.test 16131264ea0c2b93b95201f0c92958e85f2ba11a
 F test/make-where7.tcl 05c16b5d4f5d6512881dfec560cb793915932ef9
 F test/malloc.test 21c213365f2cca95ab2d7dc078dc8525f96065f8
 F test/malloc3.test e3b32c724b5a124b57cb0ed177f675249ad0c66a
 F test/malloc4.test 957337613002b7058a85116493a262f679f3a261
-F test/malloc5.test 21f6552bacb9efe649e6ba10a52f2cedaecce242
+F test/malloc5.test 02ed7c5313f0a68d95f2dfca8c8962132bd1f04b
 F test/malloc6.test 2f039d9821927eacae43e1831f815e157659a151
 F test/malloc7.test 7c68a32942858bc715284856c5507446bba88c3a
 F test/malloc8.test 9b7a3f8cb9cf0b12fff566e80a980b1767bd961d
@@ -846,8 +847,8 @@ F test/manydb.test 28385ae2087967aa05c38624cec7d96ec74feb3e
 F test/mem5.test c6460fba403c5703141348cd90de1c294188c68f
 F test/memdb.test c1f2a343ad14398d5d6debda6ea33e80d0dafcc7
 F test/memleak.test 10b9c6c57e19fc68c32941495e9ba1c50123f6e2
-F test/memsubsys1.test 1733c617e246642db5bf3b9f78c18e2b14fac96c
-F test/memsubsys2.test 3a1c1a9de48e5726faa85108b02459fae8cb9ee9
+F test/memsubsys1.test d2b2d6ca37890b26703a2258df8fd66f9869da02
+F test/memsubsys2.test 3e4a8d0c05fd3e5fa92017c64666730a520c7e08
 F test/minmax.test 42fbad0e81afaa6e0de41c960329f2b2c3526efd
 F test/minmax2.test b44bae787fc7b227597b01b0ca5575c7cb54d3bc
 F test/minmax3.test cc1e8b010136db0d01a6f2a29ba5a9f321034354
@@ -889,7 +890,6 @@ F test/orderby6.test 8b38138ab0972588240b3fca0985d2e400432859
 F test/orderby7.test 3d1383d52ade5b9eb3a173b3147fdd296f0202da
 F test/orderby8.test 23ef1a5d72bd3adcc2f65561c654295d1b8047bd
 F test/oserror.test 14fec2796c2b6fe431c7823750e8a18a761176d7
-F test/ota.test 3a8d97cbf8f7210dc6a638797c4e4cd674036927
 F test/ovfl.test 4f7ca651cba5c059a12d8c67dddd49bec5747799
 F test/pager1.test 1acbdb14c5952a72dd43129cabdbf69aaa3ed1fa
 F test/pager2.test 67b8f40ae98112bcdba1f2b2d03ea83266418c71
@@ -901,11 +901,11 @@ F test/pagerfault3.test 1003fcda009bf48a8e22a516e193b6ef0dd1bbd8
 F test/pageropt.test 6b8f6a123a5572c195ad4ae40f2987007923bbd6
 F test/pagesize.test 5769fc62d8c890a83a503f67d47508dfdc543305
 F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
-F test/pcache2.test c70d92547550136ba6f818e6a44fe246d2738604
+F test/pcache2.test af7f3deb1a819f77a6d0d81534e97d1cf62cd442
 F test/percentile.test 4243af26b8f3f4555abe166f723715a1f74c77ff
-F test/permutations.test 6a88fd9ca15b804e9c20990773262ca67494058f
+F test/permutations.test ac3b00c299250cc087d4a527b5c75a0f8aef4e54
 F test/pragma.test be7195f0aa72bdb8a512133e9640ac40f15b57a2
-F test/pragma2.test f624a496a95ee878e81e59961eade66d5c00c028
+F test/pragma2.test 8e72df3a16c0fda748ad52abf79cb8256b04a6fe
 F test/pragma3.test 6f849ccffeee7e496d2f2b5e74152306c0b8757c
 F test/printf.test b3ff34e73d59124140eaf89f7672e21bc2ca5fcc
 F test/printf2.test 0b61566dd1c0f0b802f59dffa228c5dc5aa6b054
@@ -919,15 +919,16 @@ F test/quota2.test 7dc12e08b11cbc4c16c9ba2aa2e040ea8d8ab4b8
 F test/quote.test 215897dbe8de1a6f701265836d6601cc6ed103e6
 F test/randexpr1.tcl 40dec52119ed3a2b8b2a773bce24b63a3a746459
 F test/randexpr1.test eda062a97e60f9c38ae8d806b03b0ddf23d796df
+F test/rbu.test 168573d353cd0fd10196b87b0caa322c144ef736 w test/ota.test
 F test/rdonly.test 64e2696c322e3538df0b1ed624e21f9a23ed9ff8
 F test/regexp1.test 497ea812f264d12b6198d6e50a76be4a1973a9d8
 F test/reindex.test 44edd3966b474468b823d481eafef0c305022254
-F test/releasetest.tcl 2aaffa548a8f8d10053b20bcf68a1b5a01081e51
+F test/releasetest.tcl 8eb718bca8bca71c0c0145384f9915bb7e53fca3
 F test/resolver01.test f4022acafda7f4d40eca94dbf16bc5fc4ac30ceb
 F test/rollback.test 458fe73eb3ffdfdf9f6ba3e9b7350a6220414dea
 F test/rollback2.test fc14cf6d1a2b250d2735ef16124b971bce152f14
 F test/rollbackfault.test 6a004f71087cc399296cffbb5429ea6da655ae65
-F test/rowallock.test f7f834125f11ff62f6e1ae7d0b07fd9228f2d5a2
+F test/rowallock.test 3f88ec6819489d0b2341c7a7528ae17c053ab7cc
 F test/rowhash.test 0bc1d31415e4575d10cacf31e1a66b5cc0f8be81
 F test/rowid.test 742b5741584a8a44fd83e856cc2896688401d645
 F test/rtree.test 0c8d9dd458d6824e59683c19ab2ffa9ef946f798
@@ -983,9 +984,9 @@ F test/shell4.test ddf0a99044e2245a87fc17423e3aaa1445b3243b
 F test/shell5.test c04e9f9f948305706b88377c464c7f08ce7479f9
 F test/shortread1.test bb591ef20f0fd9ed26d0d12e80eee6d7ac8897a3
 F test/show_speedtest1_rtree.tcl 32e6c5f073d7426148a6936a0408f4b5b169aba5
-F test/shrink.test 06deac10d591186017466ce67d10645150bfdeec
+F test/shrink.test 1b4330b1fd9e818c04726d45cb28db73087535ce
 F test/sidedelete.test f0ad71abe6233e3b153100f3b8d679b19a488329
-F test/skipscan1.test 2ddfe5d168462170c4487f534e2a99fb006b2076
+F test/skipscan1.test d37a75b4be4eb9dedeb69b4f38b1d0a74b5021d7
 F test/skipscan2.test d1d1450952b7275f0b0a3a981f0230532743951a
 F test/skipscan3.test ec5bab3f81c7038b43450e7b3062e04a198bdbb5
 F test/skipscan5.test 67817a4b6857c47e0e33ba3e506da6f23ef68de2
@@ -1006,7 +1007,7 @@ F test/speed3.test d32043614c08c53eafdc80f33191d5bd9b920523
 F test/speed4.test abc0ad3399dcf9703abed2fff8705e4f8e416715
 F test/speed4p.explain 6b5f104ebeb34a038b2f714150f51d01143e59aa
 F test/speed4p.test 0e51908951677de5a969b723e03a27a1c45db38b
-F test/speedtest1.c 54f211994e2fb5b3f7c5c82137378f46ca89aae8
+F test/speedtest1.c 857439869d1cb4db35e1c720ee9c2756eb9ea2a0
 F test/spellfix.test 0597065ff57042df1f138e6a2611ae19c2698135
 F test/sqldiff1.test 8f6bc7c6a5b3585d350d779c6078869ba402f8f5
 F test/sqllimits1.test e05786eaed7950ff6a2d00031d001d8a26131e68
@@ -1028,7 +1029,7 @@ F test/tclsqlite.test 7fb866443c7deceed22b63948ccd6f76b52ad054
 F test/tempdb.test 19d0f66e2e3eeffd68661a11c83ba5e6ace9128c
 F test/temptable.test d2c9b87a54147161bcd1822e30c1d1cd891e5b30
 F test/temptrigger.test 8ec228b0db5d7ebc4ee9b458fc28cb9e7873f5e1
-F test/tester.tcl b3a41e20f98a029a76e930b33d0711c5854267bb
+F test/tester.tcl 83cc29c89259490b25d2d7e47535d6f2ed5a57c7
 F test/thread001.test 9f22fd3525a307ff42a326b6bc7b0465be1745a5
 F test/thread002.test e630504f8a06c00bf8bbe68528774dd96aeb2e58
 F test/thread003.test ee4c9efc3b86a6a2767516a37bd64251272560a7
@@ -1244,9 +1245,9 @@ F test/vtabF.test fd5ad376f5a34fe0891df1f3cddb4fe7c3eb077e
 F test/vtab_alter.test 9e374885248f69e251bdaacf480b04a197f125e5
 F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8
 F test/vtab_shared.test ea8778d5b0df200adef2ca7c00c3c37d4375f772
-F test/wal.test 885f32b2b390b30b4aa3dbb0e568f8f78d40f5cc
+F test/wal.test dbfc482e10c7263298833bb1fc60b3ac9d6340a1
 F test/wal2.test 1f841d2048080d32f552942e333fd99ce541dada
-F test/wal3.test b22eb662bcbc148c5f6d956eaf94b047f7afe9c0
+F test/wal3.test 2b5445e5da44780b9b44712f5a38523f7aeb0941
 F test/wal4.test 4744e155cd6299c6bd99d3eab1c82f77db9cdb3c
 F test/wal5.test 88b5d9a6a3d1532497ee9f4296f010d66f07e33c
 F test/wal6.test 527581f5527bf9c24394991e2be83000aace5f9e
@@ -1307,7 +1308,7 @@ F test/without_rowid4.test 4e08bcbaee0399f35d58b5581881e7a6243d458a
 F test/without_rowid5.test 61256715b686359df48ca1742db50cc7e3e7b862
 F test/without_rowid6.test db0dbf03c49030aa3c1ba5f618620334bd2baf5f
 F test/wordcount.c 9915e06cb33d8ca8109b8700791afe80d305afda
-F test/zeroblob.test fb3c0e4ab172d386954deda24c03f500e121d80d
+F test/zeroblob.test 3857870fe681b8185654414a9bccfde80b62a0fa
 F test/zerodamage.test cf6748bad89553cc1632be51a6f54e487e4039ac
 F tool/build-all-msvc.bat 9058bd90a3c078a3d8c17d40e853aaa0f47885f4 x
 F tool/build-shell.sh 950f47c6174f1eea171319438b93ba67ff5bf367
@@ -1330,7 +1331,7 @@ F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e
 F tool/mkpragmatab.tcl 84af2b180484323a2ea22a2279e8bd9e3e1e492e
 F tool/mkspeedsql.tcl a1a334d288f7adfe6e996f2e712becf076745c97
 F tool/mksqlite3c-noext.tcl 87240b09c20042999b41d5fabe091b7111287835
-F tool/mksqlite3c.tcl f29898d34f1dcd77ccc4e6fd7dcc2f9ebb54622f
+F tool/mksqlite3c.tcl 421ecbd437d8cd7123e67430ee8146218396680d
 F tool/mksqlite3h.tcl 44730d586c9031638cdd2eb443b801c0d2dbd9f8
 F tool/mksqlite3internalh.tcl eb994013e833359137eb53a55acdad0b5ae1049b
 F tool/mkvsix.tcl 3b58b9398f91c7dbf18d49eb87cefeee9efdbce1
@@ -1365,7 +1366,7 @@ F tool/vdbe_profile.tcl 67746953071a9f8f2f668b73fe899074e2c6d8c1
 F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
 F tool/warnings.sh 48bd54594752d5be3337f12c72f28d2080cb630b
 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
-P 862418e3506d4b7cca9c44d58c2eb9dc915d75c9 e9bf275cd969eca6fb41384d3637528d6a19f819
-R 13b93e3f59e7dab4e2705105f60947d5
+P 7190d79ba452ceb1af77ce1375278b097816a8be ee348b12754abda1fe13231c1868faca9d78481c
+R 40e42aeae28824a45cc18d6d2ef8dc07
 U dan
-Z 0c71c25a3e3a21d59d6227b0b3745fb8
+Z 349213ca34455d17cf2d8b985651aa92
diff --git a/manifest.uuid b/manifest.uuid
index d8592d7e89..59ebea83f4 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-7190d79ba452ceb1af77ce1375278b097816a8be
\ No newline at end of file
+5ec933c257884019484db7f533ce920012e47a1c
\ No newline at end of file
diff --git a/src/func.c b/src/func.c
index d0565357d5..6ecd743969 100644
--- a/src/func.c
+++ b/src/func.c
@@ -1122,16 +1122,14 @@ static void zeroblobFunc(
   sqlite3_value **argv
 ){
   i64 n;
-  sqlite3 *db = sqlite3_context_db_handle(context);
+  int rc;
   assert( argc==1 );
   UNUSED_PARAMETER(argc);
   n = sqlite3_value_int64(argv[0]);
-  testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
-  testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
-  if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
-    sqlite3_result_error_toobig(context);
-  }else{
-    sqlite3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */
+  if( n<0 ) n = 0;
+  rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
+  if( rc ){
+    sqlite3_result_error_code(context, rc);
   }
 }
 
diff --git a/src/loadext.c b/src/loadext.c
index dcdbb28126..1d398c54ce 100644
--- a/src/loadext.c
+++ b/src/loadext.c
@@ -405,7 +405,9 @@ static const sqlite3_api_routines sqlite3Apis = {
   sqlite3_strglob,
   /* Version 3.8.11 and later */
   (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup,
-  sqlite3_value_free
+  sqlite3_value_free,
+  sqlite3_result_zeroblob64,
+  sqlite3_bind_zeroblob64
 };
 
 /*
diff --git a/src/main.c b/src/main.c
index faeee6af2e..36206eec8c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -642,6 +642,7 @@ int sqlite3_config(int op, ...){
 ** the lookaside memory.
 */
 static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
+#ifndef SQLITE_OMIT_LOOKASIDE
   void *pStart;
   if( db->lookaside.nOut ){
     return SQLITE_BUSY;
@@ -692,6 +693,7 @@ static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
     db->lookaside.bEnabled = 0;
     db->lookaside.bMalloced = 0;
   }
+#endif /* SQLITE_OMIT_LOOKASIDE */
   return SQLITE_OK;
 }
 
diff --git a/src/sqlite.h.in b/src/sqlite.h.in
index 34849814fb..4489c37ea4 100644
--- a/src/sqlite.h.in
+++ b/src/sqlite.h.in
@@ -967,9 +967,9 @@ struct sqlite3_io_methods {
 ** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other
 ** VFS should return SQLITE_NOTFOUND for this opcode.
 **
-** <li>[[SQLITE_FCNTL_OTA]]
-** The [SQLITE_FCNTL_OTA] opcode is implemented by the special VFS used by
-** the OTA extension only.  All other VFS should return SQLITE_NOTFOUND for
+** <li>[[SQLITE_FCNTL_RBU]]
+** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by
+** the RBU extension only.  All other VFS should return SQLITE_NOTFOUND for
 ** this opcode.  
 ** </ul>
 */
@@ -997,7 +997,7 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_WIN32_SET_HANDLE       23
 #define SQLITE_FCNTL_WAL_BLOCK              24
 #define SQLITE_FCNTL_ZIPVFS                 25
-#define SQLITE_FCNTL_OTA                    26
+#define SQLITE_FCNTL_RBU                    26
 
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -3562,6 +3562,7 @@ int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
                          void(*)(void*), unsigned char encoding);
 int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
+int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);
 
 /*
 ** CAPI3REF: Number Of SQL Parameters
@@ -4534,8 +4535,8 @@ typedef void (*sqlite3_destructor_type)(void*);
 ** to by the second parameter and which is N bytes long where N is the
 ** third parameter.
 **
-** ^The sqlite3_result_zeroblob() interfaces set the result of
-** the application-defined function to be a BLOB containing all zero
+** ^The sqlite3_result_zeroblob() and zeroblob64() interfaces set the result 
+** of the application-defined function to be a BLOB containing all zero
 ** bytes and N bytes in size, where N is the value of the 2nd parameter.
 **
 ** ^The sqlite3_result_double() interface sets the result from
@@ -4651,6 +4652,7 @@ void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
 void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
 void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
 void sqlite3_result_zeroblob(sqlite3_context*, int n);
+int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
 
 /*
 ** CAPI3REF: Define New Collating Sequences
diff --git a/src/sqlite3ext.h b/src/sqlite3ext.h
index b56cc4e54c..48a5bf744b 100644
--- a/src/sqlite3ext.h
+++ b/src/sqlite3ext.h
@@ -270,6 +270,8 @@ struct sqlite3_api_routines {
   /* Version 3.8.11 and later */
   sqlite3_value *(*value_dup)(const sqlite3_value*);
   void (*value_free)(sqlite3_value*);
+  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
+  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
 };
 
 /*
@@ -503,6 +505,8 @@ struct sqlite3_api_routines {
 /* Version 3.8.11 and later */
 #define sqlite3_value_dup              sqlite3_api->value_dup
 #define sqlite3_value_free             sqlite3_api->value_free
+#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
+#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
 #endif /* SQLITE_CORE */
 
 #ifndef SQLITE_CORE
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index c520e8abc3..d26cd19eb7 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -189,10 +189,14 @@
 ** Make sure that the compiler intrinsics we desire are enabled when
 ** compiling with an appropriate version of MSVC.
 */
-#if defined(_MSC_VER) && _MSC_VER>=1300 && !defined(_WIN32_WCE)
-#  include <intrin.h>
-#  pragma intrinsic(_byteswap_ushort)
-#  pragma intrinsic(_byteswap_ulong)
+#if defined(_MSC_VER) && _MSC_VER>=1300
+#  if !defined(_WIN32_WCE)
+#    include <intrin.h>
+#    pragma intrinsic(_byteswap_ushort)
+#    pragma intrinsic(_byteswap_ulong)
+#  else
+#    include <cmnintrin.h>
+#  endif
 #endif
 
 /*
diff --git a/src/tclsqlite.c b/src/tclsqlite.c
index 262863b31e..f024317e90 100644
--- a/src/tclsqlite.c
+++ b/src/tclsqlite.c
@@ -3761,7 +3761,7 @@ static void init_all(Tcl_Interp *interp){
     extern int SqliteSuperlock_Init(Tcl_Interp*);
     extern int SqlitetestSyscall_Init(Tcl_Interp*);
     extern int Fts5tcl_Init(Tcl_Interp *);
-    extern int SqliteOta_Init(Tcl_Interp*);
+    extern int SqliteRbu_Init(Tcl_Interp*);
 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
     extern int Sqlitetestfts3_Init(Tcl_Interp *interp);
 #endif
@@ -3805,7 +3805,7 @@ static void init_all(Tcl_Interp *interp){
     SqliteSuperlock_Init(interp);
     SqlitetestSyscall_Init(interp);
     Fts5tcl_Init(interp);
-    SqliteOta_Init(interp);
+    SqliteRbu_Init(interp);
 
 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
     Sqlitetestfts3_Init(interp);
diff --git a/src/test1.c b/src/test1.c
index 15fd8c7f7d..ceccf10db8 100644
--- a/src/test1.c
+++ b/src/test1.c
@@ -3008,6 +3008,43 @@ static int test_bind_zeroblob(
   return TCL_OK;
 }
 
+/*
+** Usage:   sqlite3_bind_zeroblob64  STMT IDX N
+**
+** Test the sqlite3_bind_zeroblob64 interface.  STMT is a prepared statement.
+** IDX is the index of a wildcard in the prepared statement.  This command
+** binds a N-byte zero-filled BLOB to the wildcard.
+*/
+static int test_bind_zeroblob64(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  i64 n;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  if( Tcl_GetWideIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_zeroblob64(pStmt, idx, n);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
 /*
 ** Usage:   sqlite3_bind_int  STMT N VALUE
 **
@@ -6796,6 +6833,7 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
      { "sqlite3_connection_pointer",    get_sqlite_pointer, 0 },
      { "sqlite3_bind_int",              test_bind_int,      0 },
      { "sqlite3_bind_zeroblob",         test_bind_zeroblob, 0 },
+     { "sqlite3_bind_zeroblob64",       test_bind_zeroblob64, 0 },
      { "sqlite3_bind_int64",            test_bind_int64,    0 },
      { "sqlite3_bind_double",           test_bind_double,   0 },
      { "sqlite3_bind_null",             test_bind_null     ,0 },
diff --git a/src/test_config.c b/src/test_config.c
index 7e0a7ae6a9..0aa29c70d7 100644
--- a/src/test_config.c
+++ b/src/test_config.c
@@ -436,10 +436,10 @@ Tcl_SetVar2(interp, "sqlite_options", "mergesort", "1", TCL_GLOBAL_ONLY);
   Tcl_SetVar2(interp, "sqlite_options", "or_opt", "1", TCL_GLOBAL_ONLY);
 #endif
 
-#ifdef SQLITE_ENABLE_OTA
-  Tcl_SetVar2(interp, "sqlite_options", "ota", "1", TCL_GLOBAL_ONLY);
+#ifdef SQLITE_ENABLE_RBU
+  Tcl_SetVar2(interp, "sqlite_options", "rbu", "1", TCL_GLOBAL_ONLY);
 #else
-  Tcl_SetVar2(interp, "sqlite_options", "ota", "0", TCL_GLOBAL_ONLY);
+  Tcl_SetVar2(interp, "sqlite_options", "rbu", "0", TCL_GLOBAL_ONLY);
 #endif
 
 #ifdef SQLITE_OMIT_PAGER_PRAGMAS
diff --git a/src/test_malloc.c b/src/test_malloc.c
index 94a2282923..3ab177dcb7 100644
--- a/src/test_malloc.c
+++ b/src/test_malloc.c
@@ -938,8 +938,8 @@ static int test_config_pagecache(
   int objc,
   Tcl_Obj *CONST objv[]
 ){
-  int sz, N, rc;
-  Tcl_Obj *pResult;
+  int sz, N;
+  Tcl_Obj *pRes;
   static char *buf = 0;
   if( objc!=3 ){
     Tcl_WrongNumArgs(interp, 1, objv, "SIZE N");
@@ -948,17 +948,20 @@ static int test_config_pagecache(
   if( Tcl_GetIntFromObj(interp, objv[1], &sz) ) return TCL_ERROR;
   if( Tcl_GetIntFromObj(interp, objv[2], &N) ) return TCL_ERROR;
   free(buf);
+  buf = 0;
+
+  /* Set the return value */
+  pRes = Tcl_NewObj();
+  Tcl_ListObjAppendElement(0, pRes, Tcl_NewIntObj(sqlite3GlobalConfig.szPage));
+  Tcl_ListObjAppendElement(0, pRes, Tcl_NewIntObj(sqlite3GlobalConfig.nPage));
+  Tcl_SetObjResult(interp, pRes);
+
   if( sz<0 ){
-    buf = 0;
-    rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, 0, 0, 0);
+    sqlite3_config(SQLITE_CONFIG_PAGECACHE, 0, 0, 0);
   }else{
     buf = malloc( sz*N );
-    rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, buf, sz, N);
+    sqlite3_config(SQLITE_CONFIG_PAGECACHE, buf, sz, N);
   }
-  pResult = Tcl_NewObj();
-  Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc));
-  Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(N));
-  Tcl_SetObjResult(interp, pResult);
   return TCL_OK;
 }
 
diff --git a/src/vdbe.c b/src/vdbe.c
index 296a12bc9f..fe97087c09 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -2702,7 +2702,7 @@ case OP_MakeRecord: {
     len = sqlite3VdbeSerialTypeLen(serial_type);
     if( pRec->flags & MEM_Zero ){
       if( nData ){
-        sqlite3VdbeMemExpandBlob(pRec);
+        if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
       }else{
         nZero += pRec->u.nZero;
         len -= pRec->u.nZero;
diff --git a/src/vdbeapi.c b/src/vdbeapi.c
index 4687aac510..ebd5ef29a2 100644
--- a/src/vdbeapi.c
+++ b/src/vdbeapi.c
@@ -162,7 +162,10 @@ int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
 const void *sqlite3_value_blob(sqlite3_value *pVal){
   Mem *p = (Mem*)pVal;
   if( p->flags & (MEM_Blob|MEM_Str) ){
-    sqlite3VdbeMemExpandBlob(p);
+    if( sqlite3VdbeMemExpandBlob(p)!=SQLITE_OK ){
+      assert( p->flags==MEM_Null && p->z==0 );
+      return 0;
+    }
     p->flags |= MEM_Blob;
     return p->n ? p->z : 0;
   }else{
@@ -424,6 +427,15 @@ void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
 }
+int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
+  Mem *pOut = pCtx->pOut;
+  assert( sqlite3_mutex_held(pOut->db->mutex) );
+  if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
+    return SQLITE_TOOBIG;
+  }
+  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
+  return SQLITE_OK;
+}
 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
   pCtx->isError = errCode;
   pCtx->fErrorOrAux = 1;
@@ -1403,6 +1415,20 @@ int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
   }
   return rc;
 }
+int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
+  int rc;
+  Vdbe *p = (Vdbe *)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
+    rc = SQLITE_TOOBIG;
+  }else{
+    assert( (n & 0x7FFFFFFF)==n );
+    rc = sqlite3_bind_zeroblob(pStmt, i, n);
+  }
+  rc = sqlite3ApiExit(p->db, rc);
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
 
 /*
 ** Return the number of wildcards that can be potentially bound to.
diff --git a/src/wal.c b/src/wal.c
index 69f335d792..f7e2594001 100644
--- a/src/wal.c
+++ b/src/wal.c
@@ -648,9 +648,9 @@ static void walIndexWriteHdr(Wal *pWal){
   pWal->hdr.isInit = 1;
   pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
   walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
-  memcpy((void *)&aHdr[1], (void *)&pWal->hdr, sizeof(WalIndexHdr));
+  memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
   walShmBarrier(pWal);
-  memcpy((void *)&aHdr[0], (void *)&pWal->hdr, sizeof(WalIndexHdr));
+  memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
 }
 
 /*
@@ -952,13 +952,13 @@ static void walCleanupHash(Wal *pWal){
   ** via the hash table even after the cleanup.
   */
   if( iLimit ){
-    int i;           /* Loop counter */
+    int j;           /* Loop counter */
     int iKey;        /* Hash key */
-    for(i=1; i<=iLimit; i++){
-      for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){
-        if( aHash[iKey]==i ) break;
+    for(j=1; j<=iLimit; j++){
+      for(iKey=walHash(aPgno[j]); aHash[iKey]; iKey=walNextHash(iKey)){
+        if( aHash[iKey]==j ) break;
       }
-      assert( aHash[iKey]==i );
+      assert( aHash[iKey]==j );
     }
   }
 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
diff --git a/src/wherecode.c b/src/wherecode.c
index e1f0f86615..9747f7f375 100644
--- a/src/wherecode.c
+++ b/src/wherecode.c
@@ -1296,7 +1296,11 @@ Bitmask sqlite3WhereCodeOneLoopStart(
               r = sqlite3GetTempRange(pParse, nPk);
               for(iPk=0; iPk<nPk; iPk++){
                 int iCol = pPk->aiColumn[iPk];
-                sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur, r+iPk, 0);
+                int rx;
+                rx = sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur,r+iPk,0);
+                if( rx!=r+iPk ){
+                  sqlite3VdbeAddOp2(v, OP_SCopy, rx, r+iPk);
+                }
               }
 
               /* Check if the temp table already contains this key. If so,
diff --git a/test/fuzz3.test b/test/fuzz3.test
index e54b811142..b432671822 100644
--- a/test/fuzz3.test
+++ b/test/fuzz3.test
@@ -21,12 +21,7 @@ source $testdir/tester.tcl
 # These tests deal with corrupt database files
 #
 database_may_be_corrupt
-db close
-sqlite3_shutdown
-sqlite3_config_pagecache 0 0
-sqlite3_initialize
-autoinstall_test_functions
-sqlite3 db test.db
+test_set_config_pagecache 0 0
 
 
 expr srand(123)
@@ -176,4 +171,6 @@ for {set ii 0} {$ii < 5000} {incr ii} {
   } $::cksum
 }
 
+test_restore_config_pagecache
 finish_test
+
diff --git a/test/fuzzcheck.c b/test/fuzzcheck.c
index d17a9a1289..c678e2af7a 100644
--- a/test/fuzzcheck.c
+++ b/test/fuzzcheck.c
@@ -682,6 +682,64 @@ static void rebuild_database(sqlite3 *db){
   if( rc ) fatalError("cannot rebuild: %s", sqlite3_errmsg(db));
 }
 
+/*
+** Return the value of a hexadecimal digit.  Return -1 if the input
+** is not a hex digit.
+*/
+static int hexDigitValue(char c){
+  if( c>='0' && c<='9' ) return c - '0';
+  if( c>='a' && c<='f' ) return c - 'a' + 10;
+  if( c>='A' && c<='F' ) return c - 'A' + 10;
+  return -1;
+}
+
+/*
+** Interpret zArg as an integer value, possibly with suffixes.
+*/
+static int integerValue(const char *zArg){
+  sqlite3_int64 v = 0;
+  static const struct { char *zSuffix; int iMult; } aMult[] = {
+    { "KiB", 1024 },
+    { "MiB", 1024*1024 },
+    { "GiB", 1024*1024*1024 },
+    { "KB",  1000 },
+    { "MB",  1000000 },
+    { "GB",  1000000000 },
+    { "K",   1000 },
+    { "M",   1000000 },
+    { "G",   1000000000 },
+  };
+  int i;
+  int isNeg = 0;
+  if( zArg[0]=='-' ){
+    isNeg = 1;
+    zArg++;
+  }else if( zArg[0]=='+' ){
+    zArg++;
+  }
+  if( zArg[0]=='0' && zArg[1]=='x' ){
+    int x;
+    zArg += 2;
+    while( (x = hexDigitValue(zArg[0]))>=0 ){
+      v = (v<<4) + x;
+      zArg++;
+    }
+  }else{
+    while( isdigit(zArg[0]) ){
+      v = v*10 + zArg[0] - '0';
+      zArg++;
+    }
+  }
+  for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){
+    if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
+      v *= aMult[i].iMult;
+      break;
+    }
+  }
+  if( v>0x7fffffff ) fatalError("parameter too large - max 2147483648");
+  return (int)(isNeg? -v : v);
+}
+
 /*
 ** Print sketchy documentation for this utility program
 */
@@ -696,6 +754,7 @@ static void showHelp(void){
 "  --help                Show this help text\n"
 "  -q                    Reduced output\n"
 "  --quiet               Reduced output\n"
+"  --limit-mem N         Limit memory used by test SQLite instance to N bytes\n"
 "  --limit-vdbe          Panic if an sync SQL runs for more than 100,000 cycles\n"
 "  --load-sql ARGS...    Load SQL scripts fro files into SOURCE-DB\n"
 "  --load-db ARGS...     Load template databases from files into SOURCE_DB\n"
@@ -739,6 +798,7 @@ int main(int argc, char **argv){
   int cellSzCkFlag = 0;        /* --cell-size-check */
   int sqlFuzz = 0;             /* True for SQL fuzz testing. False for DB fuzz */
   int iTimeout = 120;          /* Default 120-second timeout */
+  int nMem = 0;                /* Memory limit */
 
   iBegin = timeOfDay();
 #ifdef __unix__
@@ -756,12 +816,16 @@ int main(int argc, char **argv){
       }else
       if( strcmp(z,"dbid")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
-        onlyDbid = atoi(argv[++i]);
+        onlyDbid = integerValue(argv[++i]);
       }else
       if( strcmp(z,"help")==0 ){
         showHelp();
         return 0;
       }else
+      if( strcmp(z,"limit-mem")==0 ){
+        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
+        nMem = integerValue(argv[++i]);
+      }else
       if( strcmp(z,"limit-vdbe")==0 ){
         vdbeLimitFlag = 1;
       }else
@@ -794,11 +858,11 @@ int main(int argc, char **argv){
       }else
       if( strcmp(z,"sqlid")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
-        onlySqlid = atoi(argv[++i]);
+        onlySqlid = integerValue(argv[++i]);
       }else
       if( strcmp(z,"timeout")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
-        iTimeout = atoi(argv[++i]);
+        iTimeout = integerValue(argv[++i]);
       }else
       if( strcmp(z,"timeout-test")==0 ){
         timeoutTest = 1;
@@ -928,6 +992,17 @@ int main(int argc, char **argv){
     if( sqlite3_memory_used()>0 ){
       fatalError("SQLite has memory in use before the start of testing");
     }
+
+    /* Limit available memory, if requested */
+    if( nMem>0 ){
+      void *pHeap;
+      sqlite3_shutdown();
+      pHeap = malloc(nMem);
+      if( pHeap==0 ){
+        fatalError("failed to allocate %d bytes of heap memory", nMem);
+      }
+      sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128);
+    }
   
     /* Register the in-memory virtual filesystem
     */
diff --git a/test/lookaside.test b/test/lookaside.test
index 0b239a04d5..a89110ee1d 100644
--- a/test/lookaside.test
+++ b/test/lookaside.test
@@ -29,9 +29,10 @@ if {[info exists ::G(perm:presql)]} {
   return
 }
 
+test_set_config_pagecache 0 0
+
 catch {db close}
 sqlite3_shutdown
-sqlite3_config_pagecache 0 0
 sqlite3_config_scratch 0 0
 sqlite3_initialize
 autoinstall_test_functions
@@ -129,4 +130,5 @@ do_test lookaside-4.1 {
 sqlite3_initialize
 autoinstall_test_functions
 
+test_restore_config_pagecache
 finish_test
diff --git a/test/malloc5.test b/test/malloc5.test
index c9ee5dbc7d..8f0db04c2a 100644
--- a/test/malloc5.test
+++ b/test/malloc5.test
@@ -39,6 +39,8 @@ ifcapable !memorymanage {
    return
 }
 
+test_set_config_pagecache 0 100
+
 sqlite3_soft_heap_limit 0
 sqlite3 db test.db
 db eval {PRAGMA cache_size=1}
@@ -410,5 +412,6 @@ do_test malloc5-6.3.6 {
 db2 close
 
 sqlite3_soft_heap_limit $::soft_limit
+test_restore_config_pagecache
 finish_test
 catch {db close}
diff --git a/test/memsubsys1.test b/test/memsubsys1.test
index 3eb3cd4a95..8265ce6317 100644
--- a/test/memsubsys1.test
+++ b/test/memsubsys1.test
@@ -25,6 +25,8 @@ if {[permutation] == "memsubsys1"} {
   return
 }
 
+test_set_config_pagecache 0 0
+
 # This procedure constructs a new database in test.db.  It fills
 # this database with many small records (enough to force multiple
 # rebalance operations in the btree-layer and to require a large
@@ -310,10 +312,11 @@ do_test memsubsys1-8.4 {
 db close
 sqlite3_shutdown
 sqlite3_config_memstatus 1
-sqlite3_config_pagecache 0 0
 sqlite3_config_scratch 0 0
 sqlite3_config_lookaside 100 500
 sqlite3_config serialized
 sqlite3_initialize
 autoinstall_test_functions
+
+test_restore_config_pagecache
 finish_test
diff --git a/test/memsubsys2.test b/test/memsubsys2.test
index a40f4e4f03..68e4e22d32 100644
--- a/test/memsubsys2.test
+++ b/test/memsubsys2.test
@@ -80,8 +80,11 @@ do_test memsubsys2-2.1 {
   sqlite3_free [set x [sqlite3_malloc 100000]]
   expr {$x!="0"}
 } {1}
-do_test memsubsys2-2.2 {
-  expr {[sqlite3_memory_highwater 0]>=[sqlite3_memory_used]+$highwater}
+do_test memsubsys2-2.2.1 {
+  expr {[sqlite3_memory_highwater 0]>=[sqlite3_memory_used]+100000}
+} {1}
+do_test memsubsys2-2.2.2 {
+  expr {[sqlite3_memory_highwater 0]>=$highwater+50000}
 } {1}
 
 # Test 3: Verify that turning of memstatus disables the statistics
diff --git a/test/pcache2.test b/test/pcache2.test
index c59dfb25d4..a0d7496c86 100644
--- a/test/pcache2.test
+++ b/test/pcache2.test
@@ -16,6 +16,8 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 
+test_set_config_pagecache 0 0
+
 # Set up a pcache memory pool so that we can easily track how many
 # pages are being used for cache.
 #
@@ -78,4 +80,5 @@ sqlite3_config serialized
 sqlite3_initialize
 autoinstall_test_functions
 
+test_restore_config_pagecache
 finish_test
diff --git a/test/permutations.test b/test/permutations.test
index 9881efb71b..c01dc22c55 100644
--- a/test/permutations.test
+++ b/test/permutations.test
@@ -113,7 +113,7 @@ set allquicktests [test_set $alltests -exclude {
   vtab_err.test walslow.test walcrash.test walcrash3.test
   walthread.test rtree3.test indexfault.test securedel2.test
   sort3.test sort4.test fts4growth.test fts4growth2.test
-  bigsort.test ota.test
+  bigsort.test rbu.test
 }]
 if {[info exists ::env(QUICKTEST_INCLUDE)]} {
   set allquicktests [concat $allquicktests $::env(QUICKTEST_INCLUDE)]
@@ -417,16 +417,16 @@ test_suite "memsubsys1" -description {
 } -files [
   test_set $::allquicktests -exclude ioerr5.test malloc5.test mmap1.test
 ] -initialize {
+  test_set_config_pagecache 4096 24
   catch {db close}
   sqlite3_shutdown
-  sqlite3_config_pagecache 4096 24
   sqlite3_config_scratch 25000 1
   sqlite3_initialize
   autoinstall_test_functions
 } -shutdown {
+  test_restore_config_pagecache
   catch {db close}
   sqlite3_shutdown
-  sqlite3_config_pagecache 0 0
   sqlite3_config_scratch 0 0
   sqlite3_initialize
   autoinstall_test_functions
@@ -444,16 +444,16 @@ test_suite "memsubsys2" -description {
 } -files [
   test_set $::allquicktests -exclude ioerr5.test malloc5.test
 ] -initialize {
+  test_set_config_pagecache 512 5
   catch {db close}
   sqlite3_shutdown
-  sqlite3_config_pagecache 512 5
   sqlite3_config_scratch 1000 1
   sqlite3_initialize
   autoinstall_test_functions
 } -shutdown {
+  test_restore_config_pagecache
   catch {db close}
   sqlite3_shutdown
-  sqlite3_config_pagecache 0 0
   sqlite3_config_scratch 0 0
   sqlite3_initialize
   autoinstall_test_functions
@@ -962,10 +962,10 @@ test_suite "rtree" -description {
   All R-tree related tests. Provides coverage of source file rtree.c.
 } -files [glob -nocomplain $::testdir/../ext/rtree/*.test]
 
-test_suite "ota" -description {
-  OTA tests.
+test_suite "rbu" -description {
+  RBU tests.
 } -files [
-  test_set [glob -nocomplain $::testdir/../ext/ota/*.test] -exclude ota.test
+  test_set [glob -nocomplain $::testdir/../ext/rbu/*.test] -exclude rbu.test
 ]
 
 test_suite "no_optimization" -description {
diff --git a/test/pragma2.test b/test/pragma2.test
index 3ade8c1a07..12d5cce5f7 100644
--- a/test/pragma2.test
+++ b/test/pragma2.test
@@ -30,6 +30,8 @@ ifcapable !pragma||!schema_pragmas {
   return
 }
 
+test_set_config_pagecache 0 0
+
 # Delete the preexisting database to avoid the special setup
 # that the "all.test" script does.
 #
@@ -208,5 +210,5 @@ do_execsql_test pragma2-4.8 {
   PRAGMA lock_status;
 } {main unlocked temp unknown aux1 exclusive}
    
-
+test_restore_config_pagecache
 finish_test
diff --git a/test/ota.test b/test/rbu.test
similarity index 76%
rename from test/ota.test
rename to test/rbu.test
index 9dc01c2b3a..4054195075 100644
--- a/test/ota.test
+++ b/test/rbu.test
@@ -5,14 +5,13 @@
 #    May you share freely, never taking more than you give.
 #
 #***********************************************************************
-# This file runs all rtree related tests.
+# This file runs all RBU related tests.
 #
 
 set testdir [file dirname $argv0]
 source $testdir/permutations.test
 
-ifcapable !ota { finish_test ; return }
+ifcapable !rbu { finish_test ; return }
 
-run_test_suite ota
+run_test_suite rbu
 finish_test
-
diff --git a/test/releasetest.tcl b/test/releasetest.tcl
index 6e475c9d29..43473e2a0d 100644
--- a/test/releasetest.tcl
+++ b/test/releasetest.tcl
@@ -116,7 +116,7 @@ array set ::Configs [strip_comments {
     -DSQLITE_ENABLE_FTS4=1
     -DSQLITE_ENABLE_RTREE=1
     -DSQLITE_ENABLE_STAT4
-    -DSQLITE_ENABLE_OTA
+    -DSQLITE_ENABLE_RBU
     -DSQLITE_MAX_ATTACHED=125
   }
   "Device-One" {
diff --git a/test/rowallock.test b/test/rowallock.test
index 57dbbb2c2a..a1cab8d327 100644
--- a/test/rowallock.test
+++ b/test/rowallock.test
@@ -17,6 +17,11 @@ source $testdir/tester.tcl
 source $testdir/lock_common.tcl
 set testprefix rowallock
 
+set mmap_res 1000000
+ifcapable !mmap {
+  set mmap_res 0
+}
+
 do_multiclient_test tn {
   code2 { db2 close }
   code3 { db3 close }
@@ -36,7 +41,7 @@ do_multiclient_test tn {
 
   do_execsql_test 1.$tn.2 {
     PRAGMA mmap_size = 1000000;
-  } {1000000}
+  } $mmap_res
   do_execsql_test 1.$tn.2.1 {
     SELECT * FROM t1;
   } {1 2 3 4}
diff --git a/test/shrink.test b/test/shrink.test
index 6cc0786d28..7c9bed08b0 100644
--- a/test/shrink.test
+++ b/test/shrink.test
@@ -15,6 +15,7 @@
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+test_set_config_pagecache 0 0
 
 unset -nocomplain baseline
 do_test shrink-1.1 {
@@ -43,4 +44,5 @@ do_test shrink-1.3 {
   expr {$::baseline > [sqlite3_memory_used]+500000}
 } {1}
 
+test_restore_config_pagecache
 finish_test
diff --git a/test/skipscan1.test b/test/skipscan1.test
index 4f996df972..ac26711603 100644
--- a/test/skipscan1.test
+++ b/test/skipscan1.test
@@ -292,4 +292,34 @@ do_execsql_test skipscan1-7.3 {
   EXPLAIN QUERY PLAN SELECT * FROM t1 WHERE b=1;
 } {~/ANY/}
 
+# Ticket 8fd39115d8f46ece70e7d4b3c481d1bd86194746  2015-07-23
+# Incorrect code generated for a skipscan within an OR optimization
+# on a WITHOUT ROWID table.
+#
+do_execsql_test skipscan1-8.1 {
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(x, y, PRIMARY KEY(x,y)) WITHOUT ROWID;
+  INSERT INTO t1(x,y) VALUES(1,'AB');
+  INSERT INTO t1(x,y) VALUES(2,'CD');
+  ANALYZE;
+  DROP TABLE IF EXISTS sqlite_stat4;
+  DELETE FROM sqlite_stat1;
+  INSERT INTO sqlite_stat1(tbl,idx,stat) VALUES('t1','t1','1000000 100 1');
+  ANALYZE sqlite_master;
+  SELECT * FROM t1
+   WHERE (y = 'AB' AND x <= 4)
+      OR (y = 'EF' AND x = 5);
+} {1 AB}
+do_execsql_test skipscan1-8.1eqp {
+  EXPLAIN QUERY PLAN
+  SELECT * FROM t1
+   WHERE (y = 'AB' AND x <= 4)
+      OR (y = 'EF' AND x = 5);
+} {/ANY/}
+do_execsql_test skipscan1-8.2 {
+  SELECT * FROM t1
+   WHERE y = 'AB' OR (y = 'CD' AND x = 2)
+  ORDER BY +x;
+} {1 AB 2 CD}
+
 finish_test
diff --git a/test/speedtest1.c b/test/speedtest1.c
index 9ac9fbb962..b34dae65ae 100644
--- a/test/speedtest1.c
+++ b/test/speedtest1.c
@@ -51,8 +51,8 @@ static const char zHelp[] =
 #if SQLITE_VERSION_NUMBER<3005000
 # define sqlite3_int64 sqlite_int64
 #endif
-#ifdef SQLITE_ENABLE_OTA
-# include "sqlite3ota.h"
+#ifdef SQLITE_ENABLE_RBU
+# include "sqlite3rbu.h"
 #endif
 
 /* All global state is held in this structure */
@@ -1240,10 +1240,10 @@ int main(int argc, char **argv){
         noSync = 1;
       }else if( strcmp(z,"notnull")==0 ){
         g.zNN = "NOT NULL";
-#ifdef SQLITE_ENABLE_OTA
-      }else if( strcmp(z,"ota")==0 ){
-        sqlite3ota_create_vfs("ota", 0);
-        sqlite3_vfs_register(sqlite3_vfs_find("ota"), 1);
+#ifdef SQLITE_ENABLE_RBU
+      }else if( strcmp(z,"rbu")==0 ){
+        sqlite3ota_create_vfs("rbu", 0);
+        sqlite3_vfs_register(sqlite3_vfs_find("rbu"), 1);
 #endif
       }else if( strcmp(z,"pagesize")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
diff --git a/test/tester.tcl b/test/tester.tcl
index 8022d6a538..d7effc6038 100644
--- a/test/tester.tcl
+++ b/test/tester.tcl
@@ -2041,6 +2041,45 @@ proc db_delete_and_reopen {{file test.db}} {
   sqlite3 db $file
 }
 
+# Close any connections named [db], [db2] or [db3]. Then use sqlite3_config
+# to configure the size of the PAGECACHE allocation using the parameters
+# provided to this command. Save the old PAGECACHE parameters in a global 
+# variable so that [test_restore_config_pagecache] can restore the previous
+# configuration.
+#
+# Before returning, reopen connection [db] on file test.db.
+#
+proc test_set_config_pagecache {sz nPg} {
+  catch {db close}
+  catch {db2 close}
+  catch {db3 close}
+
+  sqlite3_shutdown
+  set ::old_pagecache_config [sqlite3_config_pagecache $sz $nPg]
+  sqlite3_initialize
+  autoinstall_test_functions
+  reset_db
+}
+
+# Close any connections named [db], [db2] or [db3]. Then use sqlite3_config
+# to configure the size of the PAGECACHE allocation to the size saved in
+# the global variable by an earlier call to [test_set_config_pagecache].
+#
+# Before returning, reopen connection [db] on file test.db.
+#
+proc test_restore_config_pagecache {} {
+  catch {db close}
+  catch {db2 close}
+  catch {db3 close}
+
+  sqlite3_shutdown
+  eval sqlite3_config_pagecache $::old_pagecache_config
+  unset ::old_pagecache_config 
+  sqlite3_initialize
+  autoinstall_test_functions
+  sqlite3 db test.db
+}
+
 # If the library is compiled with the SQLITE_DEFAULT_AUTOVACUUM macro set
 # to non-zero, then set the global variable $AUTOVACUUM to 1.
 set AUTOVACUUM $sqlite_options(default_autovacuum)
diff --git a/test/wal.test b/test/wal.test
index 675be73791..bfe3634577 100644
--- a/test/wal.test
+++ b/test/wal.test
@@ -22,6 +22,7 @@ source $testdir/wal_common.tcl
 set testprefix wal
 
 ifcapable !wal {finish_test ; return }
+test_set_config_pagecache 0 0
 
 proc reopen_db {} {
   catch { db close }
@@ -1587,4 +1588,5 @@ foreach mode {OFF MEMORY PERSIST DELETE TRUNCATE WAL} {
   db close
 }
 
+test_restore_config_pagecache
 finish_test
diff --git a/test/wal3.test b/test/wal3.test
index 18e6075a4a..33bb285c53 100644
--- a/test/wal3.test
+++ b/test/wal3.test
@@ -34,6 +34,10 @@ db func a_string a_string
 # of test cases tests that nothing appears to go wrong when this is
 # done.
 #
+set ans 4056
+if {[info exists G(perm:name)] && $G(perm:name)=="memsubsys1"} {
+  set ans 4251
+}
 do_test wal3-1.0 {
   execsql {
     PRAGMA cache_size = 2000;
@@ -61,7 +65,7 @@ do_test wal3-1.0 {
     PRAGMA cache_size = 10;
   }
   wal_frame_count test.db-wal 1024
-} 4056
+} $ans
 
 for {set i 1} {$i < 50} {incr i} {
 
diff --git a/test/zeroblob.test b/test/zeroblob.test
index e70fd0b748..0514644a28 100644
--- a/test/zeroblob.test
+++ b/test/zeroblob.test
@@ -17,12 +17,15 @@
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set testprefix zeroblob
 
 ifcapable !incrblob {
   finish_test
   return
 }
 
+test_set_config_pagecache 0 0
+
 # When zeroblob() is used for the last field of a column, then the
 # content of the zeroblob is never instantiated on the VDBE stack.
 # But it does get inserted into the database correctly.
@@ -41,8 +44,9 @@ do_test zeroblob-1.1 {
   }
   set ::sqlite3_max_blobsize
 } {10}
+
 do_test zeroblob-1.1.1 {
-  expr {[sqlite3_memory_highwater]<$::memused+25000}
+  expr {[sqlite3_memory_highwater]<$::memused+35000}
 } {1}
 do_test zeroblob-1.2 {
   execsql {
@@ -264,5 +268,53 @@ do_test zeroblob-10.1 {
   catchsql {INSERT INTO t10 VALUES(zeroblob(1e9),zeroblob(1e9),zeroblob(1e9))}
 } {1 {string or blob too big}}
 
+#-------------------------------------------------------------------------
+# Test the zeroblob() function on its own with negative or oversized 
+# arguments.
+#
+do_execsql_test 11.0 { 
+  SELECT length(zeroblob(-1444444444444444));
+} {0}
+do_catchsql_test 11.1 { 
+  SELECT zeroblob(5000 * 1024 * 1024);
+} {1 {string or blob too big}}
+do_catchsql_test 11.2 { 
+  SELECT quote(zeroblob(5000 * 1024 * 1024));
+} {1 {string or blob too big}}
+do_catchsql_test 11.3 { 
+  SELECT quote(zeroblob(-1444444444444444));
+} {0 X''}
+do_catchsql_test 11.4 {
+  SELECT quote(test_zeroblob(-1));
+} {0 X''}
 
+#-------------------------------------------------------------------------
+# Test the sqlite3_bind_zeroblob64() API.
+#
+proc bind_and_run {stmt nZero} {
+  sqlite3_bind_zeroblob64 $stmt 1 $nZero
+  sqlite3_step $stmt
+  set ret [sqlite3_column_int $stmt 0]
+  sqlite3_reset $stmt
+  set ret
+}
+set stmt [sqlite3_prepare db "SELECT length(?)" -1 dummy]
+
+do_test 12.1 { bind_and_run $stmt 40 } 40
+do_test 12.2 { bind_and_run $stmt  0 }  0
+do_test 12.3 { bind_and_run $stmt 1000 } 1000
+
+do_test 12.4 { 
+  list [catch { bind_and_run $stmt [expr 5000 * 1024 * 1024] } msg] $msg 
+} {1 SQLITE_TOOBIG}
+do_test 12.5 {
+  sqlite3_step $stmt
+  set ret [sqlite3_column_int $stmt 0]
+  sqlite3_reset $stmt
+  set ret
+} {1000}
+
+sqlite3_finalize $stmt
+
+test_restore_config_pagecache
 finish_test
diff --git a/tool/mksqlite3c.tcl b/tool/mksqlite3c.tcl
index 2cf77a6327..e52b036612 100644
--- a/tool/mksqlite3c.tcl
+++ b/tool/mksqlite3c.tcl
@@ -113,7 +113,7 @@ foreach hdr {
    rtree.h
    sqlite3.h
    sqlite3ext.h
-   sqlite3ota.h
+   sqlite3rbu.h
    sqliteicu.h
    sqliteInt.h
    sqliteLimit.h
@@ -219,7 +219,7 @@ proc copy_file {filename} {
         regsub {^SQLITE_API } $line {} line
         # Add the SQLITE_PRIVATE or SQLITE_API keyword before functions.
         # so that linkage can be modified at compile-time.
-        if {[regexp {^sqlite3(_|ota_)} $funcname]} {
+        if {[regexp {^sqlite3(_|rbu_)} $funcname]} {
           set line SQLITE_API
           append line " " [string trim $rettype]
           if {[string index $rettype end] ne "*"} {
@@ -376,7 +376,7 @@ foreach file {
    rtree.c
    icu.c
    fts3_icu.c
-   sqlite3ota.c
+   sqlite3rbu.c
    dbstat.c
 } {
   copy_file tsrc/$file