Fix problems in the previous commit.

FossilOrigin-Name: 74ad80eb745c708bdbbbf24cbbbf50971e84182f
Add extra (somewhat inefficient) trace callbacks for triggers if SQLITE_TRACE_TRIGGER is defined.
2017-01-21 16:21:24 +00:00 · 2017-01-21 15:58:42 +00:00 · 2017-01-21 15:55:41 +00:00 · 2017-01-21 14:11:28 +00:00 · 2017-01-20 20:43:14 +00:00 · 2017-01-20 16:47:34 +00:00
51 changed files with 1701 additions and 385 deletions
@@ -2039,7 +2039,7 @@ static void fts5SegIterNext(
      else if( pLeaf->nn>pLeaf->szLeaf ){
        pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
            &pLeaf->p[pLeaf->szLeaf], iOff
-            );
+        );
        pIter->iLeafOffset = iOff;
        pIter->iEndofDoclist = iOff;
        bNewTerm = 1;
@@ -2073,6 +2073,7 @@ static void fts5SegIterNext(
      */
      int nSz;
      assert( p->rc==SQLITE_OK );
+      assert( pIter->iLeafOffset<=pIter->pLeaf->nn );
      fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
      pIter->bDel = (nSz & 0x0001);
      pIter->nPos = nSz>>1;
@@ -3067,7 +3068,7 @@ static void fts5ChunkIterate(
      break;
    }else{
      pgno++;
-      pData = fts5DataRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
+      pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
      if( pData==0 ) break;
      pChunk = &pData->p[4];
      nChunk = MIN(nRem, pData->szLeaf - 4);
@@ -5829,7 +5830,7 @@ static void fts5IndexIntegrityCheckSegment(
    ** ignore this b-tree entry. Otherwise, load it into memory. */
    if( iIdxLeaf<pSeg->pgnoFirst ) continue;
    iRow = FTS5_SEGMENT_ROWID(pSeg->iSegid, iIdxLeaf);
-    pLeaf = fts5DataRead(p, iRow);
+    pLeaf = fts5LeafRead(p, iRow);
    if( pLeaf==0 ) break;

    /* Check that the leaf contains at least one term, and that it is equal
@@ -95,6 +95,7 @@ static int vtshimCreate(
  if( rc ){
    sqlite3_free(pNew);
    *ppVtab = 0;
+    return rc;
  }
  pNew->pAux = pAux;
  pNew->ppPrev = &pAux->pAllVtab;
@@ -133,6 +134,7 @@ static int vtshimConnect(
  if( rc ){
    sqlite3_free(pNew);
    *ppVtab = 0;
+    return rc;
  }
  pNew->pAux = pAux;
  pNew->ppPrev = &pAux->pAllVtab;
@@ -0,0 +1,66 @@
+# 2014 October 22
+#
+# 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.
+#
+#***********************************************************************
+#
+
+if {![info exists testdir]} {
+  set testdir [file join [file dirname [info script]] .. .. test]
+}
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+set ::testprefix rbufault4
+
+for {set tn 1} {1} {incr tn} {
+  reset_db
+  do_execsql_test 1.0 {
+    CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
+    CREATE INDEX i1b ON t1(b);
+    CREATE INDEX i1c ON t1(c);
+    INSERT INTO t1 VALUES(1, 2, 3);
+    INSERT INTO t1 VALUES(4, 5, 6);
+  }
+
+  forcedelete test.db2
+  sqlite3rbu_vacuum rbu test.db test.db2
+  for {set i 0} {$i < $tn} {incr i} { rbu step }
+  set rc [rbu close]
+  if {$rc!="SQLITE_OK"} { 
+    if {$rc!="SQLITE_DONE"} {error $rc}
+    break
+  }
+  faultsim_save
+
+  do_faultsim_test $tn -faults oom-t* -prep {
+    faultsim_restore
+  } -body {
+    sqlite3rbu_vacuum rbu test.db test.db2
+    while 1 {
+      set rc [rbu step]
+      if {$rc=="SQLITE_DONE"} break
+      if {$rc!="SQLITE_OK"} { error $rc }
+    }
+  } -test {
+    catch {rbu close}
+    faultsim_test_result {0 {}} {1 SQLITE_NOMEM} {1 SQLITE_IOERR_NOMEM}
+
+    sqlite3rbu_vacuum rbu test.db test.db2
+    while {[rbu step]=="SQLITE_OK"} {}
+    set trc [rbu close]
+    if {$trc!="SQLITE_DONE"} { error "Got $trc instead of SQLITE_DONE!" }
+
+    set rc [db one {PRAGMA integrity_check}]
+    if {$rc!="ok"} { error "Got $rc instead of ok!" }
+  }
+}
+
+
+
+finish_test
+
@@ -0,0 +1,254 @@
+# 2017 January 13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file contains tests for resumption of RBU operations in the
+# case where the previous RBU process crashed.
+#
+
+source [file join [file dirname [info script]] rbu_common.tcl]
+set ::testprefix rburesume
+
+forcedelete test.db-shm test.db-oal
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a PRIMARY KEY, b, c);
+  CREATE INDEX t1a ON t1(a);
+  CREATE INDEX t1b ON t1(b);
+  CREATE INDEX t1c ON t1(c);
+  WITH s(i) AS (
+    VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<50
+  )
+  INSERT INTO t1 SELECT randomblob(50), randomblob(75), randomblob(100) FROM s;
+}
+db_save_and_close
+
+do_test 1.1 {
+  list [file exists test.db] \
+       [file exists test.db-wal] \
+       [file exists test.db-shm] \
+       [file exists test.db-oal]
+} {1 0 0 0}
+
+# Each iteration of the following loop:
+#
+#   1. Restores the db to the state it was in following test case 1.0
+#   2. Opens an RBU vacuum and steps it $n times.
+#   3. Closes the RBU vacuum handled opened in (2).
+#   4. Opens a second RBU vacuum handle, resumes and completes the vacuum op. 
+#
+# The loop runs until $n is large enough that step (2) vacuums the entire
+# database.
+#
+for {set n 1} {$n < 5000} {incr n} {
+  db_restore
+  forcedelete state.db
+  sqlite3rbu_vacuum rbu test.db state.db
+  for {set i 0} {$i<$n} {incr i} {
+    set rc [rbu step]
+    if {$rc == "SQLITE_DONE"} break
+  }
+  rbu close
+  if {$rc == "SQLITE_DONE"} break
+
+  do_test 1.2.$n.1 {
+    sqlite3rbu_vacuum rbu test.db state.db
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
+  } {SQLITE_DONE}
+
+  do_test 1.2.$n.2 {
+    sqlite3 db2 test.db
+    db2 eval { 
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    }
+  } {50 ok}
+  db2 close
+}
+
+# Each iteration of this loop:
+#
+#   1. Restores the db to the state it was in following test case 1.0
+#   2. Opens an RBU vacuum and steps it $n times.
+#   3. Takes a copy of all database files and the state db.
+#   4. Opens a second RBU vacuum handle on the copy, resumes and completes the
+#      vacuum op. 
+#
+# The loop runs until $n is large enough that step (2) vacuums the entire
+# database.
+#
+for {set n 1} {$n < 5000} {incr n} {
+  db_restore
+  forcedelete state.db state.db-shm state.db-oal state.db-wal
+  sqlite3rbu_vacuum rbu test.db state.db
+  for {set i 0} {$i<$n} {incr i} {
+    set rc [rbu step]
+    if {$rc == "SQLITE_DONE"} break
+  }
+  if {$rc == "SQLITE_DONE"} {
+    rbu close
+    break
+  }
+
+  foreach f {test.db test.db-oal test.db-wal test.db-shm test.db-vacuum} {
+    set f2 [string map [list test.db test.db2] $f]
+    if {[file exists $f]} {
+      forcecopy $f $f2
+    } else {
+      forcedelete $f2
+    }
+  }
+  forcecopy state.db state.db2
+  rbu close
+
+  do_test 1.3.$n.1 {
+    sqlite3rbu_vacuum rbu test.db2 state.db2
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
+  } {SQLITE_DONE}
+
+  do_test 1.3.$n.2 {
+    sqlite3 db2 test.db2
+    db2 eval { 
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    }
+  } {50 ok}
+  db2 close
+}
+
+# Each iteration of this loop:
+#
+#   1. Restores the db to the state it was in following test case 1.0
+#   2. Opens an RBU vacuum and steps it 10 times. Then closes it.
+#   2. Opens an RBU vacuum and steps it $n times.
+#   3. Takes a copy of all database files and the state db.
+#   4. Opens a second RBU vacuum handle on the copy, resumes and completes the
+#      vacuum op. 
+#
+# The loop runs until $n is large enough that step (3) vacuums the entire
+# database.
+#
+for {set n 1} {$n < 5000} {incr n} {
+  db_restore
+  forcedelete state.db state.db-shm state.db-oal state.db-wal
+
+  sqlite3rbu_vacuum rbu test.db state.db
+  for {set i 0} {$i<10} {incr i} {
+    rbu step
+  }
+  rbu close
+
+  sqlite3rbu_vacuum rbu test.db state.db
+  for {set i 0} {$i<$n} {incr i} {
+    set rc [rbu step]
+    if {$rc == "SQLITE_DONE"} break
+  }
+  if {$rc == "SQLITE_DONE"} {
+    rbu close
+    break
+  }
+
+  foreach f {test.db test.db-oal test.db-wal test.db-shm test.db-vacuum} {
+    set f2 [string map [list test.db test.db2] $f]
+    if {[file exists $f]} {
+      forcecopy $f $f2
+    } else {
+      forcedelete $f2
+    }
+  }
+  forcecopy state.db state.db2
+  rbu close
+
+  do_test 1.4.$n.1 {
+    sqlite3rbu_vacuum rbu test.db2 state.db2
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
+  } {SQLITE_DONE}
+
+  do_test 1.4.$n.2 {
+    sqlite3 db2 test.db2
+    db2 eval { 
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    }
+  } {50 ok}
+  db2 close
+}
+
+forcedelete rbu.db
+do_test 2.0 {
+  sqlite3 db2 rbu.db
+  db2 eval {
+    CREATE TABLE data_t1(a, b, c, rbu_control);
+    WITH s(i) AS (
+        VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<10
+    )
+    INSERT INTO data_t1 
+      SELECT randomblob(50), randomblob(75), randomblob(100), 0 FROM s;
+  }
+  db2 close
+} {}
+
+# Each iteration of this loop:
+#
+#   1. Restores the db to the state it was in following test case 1.0
+#   2. Opens an RBU handle to apply the RBU update created in test case 2.0.
+#   3. Steps the RBU handle $n times.
+#   4. Takes a copy of all database files and the state db.
+#   5. Opens a second RBU handle on the copy, resumes and completes the
+#      RBU op. Checks it worked as expected.
+#
+# The loop runs until $n is large enough that step (3) applies the entire
+# update.
+#
+for {set n 1} {$n < 5000} {incr n} {
+  db_restore
+  forcedelete state.db state.db-shm state.db-oal state.db-wal
+  sqlite3rbu rbu test.db rbu.db state.db
+
+  for {set i 0} {$i<$n} {incr i} {
+    set rc [rbu step]
+    if {$rc == "SQLITE_DONE"} break
+  }
+  if {$rc == "SQLITE_DONE"} {
+    rbu close
+    break
+  }
+
+  foreach f {test.db test.db-oal test.db-wal test.db-shm test.db-vacuum} {
+    set f2 [string map [list test.db test.db2] $f]
+    if {[file exists $f]} {
+      forcecopy $f $f2
+    } else {
+      forcedelete $f2
+    }
+  }
+  forcecopy state.db state.db2
+  rbu close
+
+  do_test 2.$n.1 {
+    sqlite3rbu rbu test.db2 rbu.db state.db2
+    while {[rbu step]=="SQLITE_OK"} {}
+    rbu close
+  } {SQLITE_DONE}
+
+  do_test 2.$n.2 {
+    sqlite3 db2 test.db2
+    db2 eval { 
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    }
+  } {60 ok}
+  db2 close
+}
+
+finish_test
+
@@ -199,6 +199,37 @@ if {$::tcl_platform(platform)=="unix"} {
  }
 }

+#-------------------------------------------------------------------------
+# Test the outcome of some other connection running a checkpoint while
+# the incremental checkpoint is suspended.
+#
+reset_db
+do_execsql_test 6.0 {
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
+  CREATE INDEX i1b ON t1(b);
+  CREATE INDEX i1c ON t1(c);
+  INSERT INTO t1 VALUES(1, 2, 3);
+  INSERT INTO t1 VALUES(4, 5, 6);
+}
+forcedelete test.db2
+
+do_test 6.1 {
+  sqlite3rbu_vacuum rbu test.db test.db2
+  while {[rbu state]!="checkpoint"} { rbu step }
+  rbu close
+} {SQLITE_OK}
+
+do_execsql_test 6.2 {
+  SELECT 1 FROM sqlite_master LIMIT 1;
+  PRAGMA wal_checkpoint;
+} {1 0 4 4}
+
+do_test 6.3 {
+  sqlite3rbu_vacuum rbu test.db test.db2
+  while {[rbu step]!="SQLITE_DONE"} { rbu step }
+  rbu close
+  execsql { PRAGMA integrity_check }
+} {ok}

 finish_test

@@ -2333,7 +2333,7 @@ static RbuState *rbuLoadState(sqlite3rbu *p){
 ** 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 rbuOpenDatabase(sqlite3rbu *p){
+static void rbuOpenDatabase(sqlite3rbu *p, int *pbRetry){
  assert( p->rc || (p->dbMain==0 && p->dbRbu==0) );
  assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 );

@@ -2408,7 +2408,7 @@ static void rbuOpenDatabase(sqlite3rbu *p){
    }else{
      RbuState *pState = rbuLoadState(p);
      if( pState ){
-        bOpen = (pState->eStage>RBU_STAGE_MOVE);
+        bOpen = (pState->eStage>=RBU_STAGE_MOVE);
        rbuFreeState(pState);
      }
    }
@@ -2420,6 +2420,15 @@ static void rbuOpenDatabase(sqlite3rbu *p){
    if( !rbuIsVacuum(p) ){
      p->dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
    }else if( p->pRbuFd->pWalFd ){
+      if( pbRetry ){
+        p->pRbuFd->bNolock = 0;
+        sqlite3_close(p->dbRbu);
+        sqlite3_close(p->dbMain);
+        p->dbMain = 0;
+        p->dbRbu = 0;
+        *pbRetry = 1;
+        return;
+      }
      p->rc = SQLITE_ERROR;
      p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database");
    }else{
@@ -2600,16 +2609,18 @@ static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
    if( rc2!=SQLITE_INTERNAL ) p->rc = rc2;
  }

-  if( p->rc==SQLITE_OK ){
+  if( p->rc==SQLITE_OK && p->nFrame>0 ){
    p->eStage = RBU_STAGE_CKPT;
    p->nStep = (pState ? pState->nRow : 0);
    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 = RBU_STAGE_DONE;
+  if( p->rc==SQLITE_OK ){
+    if( p->nFrame==0 || (pState && pState->iWalCksum!=p->iWalCksum) ){
+      p->rc = SQLITE_DONE;
+      p->eStage = RBU_STAGE_DONE;
+    }
  }
 }

@@ -2782,7 +2793,7 @@ static void rbuMoveOalFile(sqlite3rbu *p){
 #endif

      if( p->rc==SQLITE_OK ){
-        rbuOpenDatabase(p);
+        rbuOpenDatabase(p, 0);
        rbuSetupCheckpoint(p, 0);
      }
    }
@@ -3493,6 +3504,7 @@ static sqlite3rbu *openRbuHandle(
    /* Open the target, RBU and state databases */
    if( p->rc==SQLITE_OK ){
      char *pCsr = (char*)&p[1];
+      int bRetry = 0;
      if( zTarget ){
        p->zTarget = pCsr;
        memcpy(p->zTarget, zTarget, nTarget+1);
@@ -3504,7 +3516,18 @@ static sqlite3rbu *openRbuHandle(
      if( zState ){
        p->zState = rbuMPrintf(p, "%s", zState);
      }
-      rbuOpenDatabase(p);
+
+      /* If the first attempt to open the database file fails and the bRetry
+      ** flag it set, this means that the db was not opened because it seemed
+      ** to be a wal-mode db. But, this may have happened due to an earlier
+      ** RBU vacuum operation leaving an old wal file in the directory.
+      ** If this is the case, it will have been checkpointed and deleted
+      ** when the handle was closed and a second attempt to open the 
+      ** database may succeed.  */
+      rbuOpenDatabase(p, &bRetry);
+      if( bRetry ){
+        rbuOpenDatabase(p, 0);
+      }
    }

    if( p->rc==SQLITE_OK ){
@@ -893,7 +893,7 @@ wordcount$(EXE):	$(TOP)/test/wordcount.c sqlite3.c
 		$(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) 
+	$(TCCX) -I. $(OTAFLAGS) -o speedtest1$(EXE) $(TOP)/test/speedtest1.c sqlite3.o $(THREADLIB) 

 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 \
@@ -1,5 +1,5 @@
-C Changes\sto\sthe\sprintf\simplementation\sfor\sbetter\sperformance.
-D 2017-01-04T00:26:28.506
+C Fix\sproblems\sin\sthe\sprevious\scommit.
+D 2017-01-21T16:21:24.115
 F Makefile.in 41bd4cad981487345c4a84081074bcdb876e4b2e
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
 F Makefile.msc b8ca53350ae545e3562403d5da2a69cec79308da
@@ -104,7 +104,7 @@ F ext/fts5/fts5_buffer.c 4c1502d4c956cd092c89ce4480867f9d8bf325cd
 F ext/fts5/fts5_config.c 5af9c360e99669d29f06492c370892394aba0857
 F ext/fts5/fts5_expr.c dc2cee9f56b1818b85df59304b8104a5dfb8ab60
 F ext/fts5/fts5_hash.c 880998e596b60f078348d48732ca4ad9a90caad2
-F ext/fts5/fts5_index.c fdbe46da11e81c1817cd4cb2de25ffdb4dd83711
+F ext/fts5/fts5_index.c f67032a9a529ba52a545e6e3ab970764199c05d4
 F ext/fts5/fts5_main.c f85281445dcf8be32d18841c93a6f90fe27dbfe2
 F ext/fts5/fts5_storage.c de0ed8a06738bde433afe11e92295ceaffbc4e58
 F ext/fts5/fts5_tcl.c 4a901f00c8553740dba63511603f5527d741c26a
@@ -227,7 +227,7 @@ F ext/misc/spellfix.c a4723b6aff748a417b5091b68a46443265c40f0d
 F ext/misc/totype.c 4a167594e791abeed95e0a8db028822b5e8fe512
 F ext/misc/vfslog.c fe40fab5c077a40477f7e5eba994309ecac6cc95
 F ext/misc/vfsstat.c bf10ef0bc51e1ad6756629e1edb142f7a8db1178
-F ext/misc/vtshim.c babb0dc2bf116029e3e7c9a618b8a1377045303e
+F ext/misc/vtshim.c 1976e6dd68dd0d64508c91a6dfab8e75f8aaf6cd
 F ext/misc/wholenumber.c 784b12543d60702ebdd47da936e278aa03076212
 F ext/rbu/rbu.c b2c0b5e6ae1a89affc0edfc127ebfa5f637a0ce4
 F ext/rbu/rbu1.test 43836fac8c7179a358eaf38a8a1ef3d6e6285842
@@ -252,12 +252,14 @@ F ext/rbu/rbudor.test 99b05cc0df613e962c2c8085cfb05686a09cf315
 F ext/rbu/rbufault.test cc0be8d5d392d98b0c2d6a51be377ea989250a89
 F ext/rbu/rbufault2.test 9a7f19edd6ea35c4c9f807d8a3db0a03a5670c06
 F ext/rbu/rbufault3.test 54a399888ac4af44c68f9f58afbed23149428bca
+F ext/rbu/rbufault4.test 34e70701cbec51571ffbd9fbf9d4e0f2ec495ca7
 F ext/rbu/rbufts.test 828cd689da825f0a7b7c53ffc1f6f7fdb6fa5bda
 F ext/rbu/rbuprogress.test e3e25fb7622641b8f2df7c6b7a7eb6fddfc46a4b
+F ext/rbu/rburesume.test 8acb77f4a422ff55acfcfc9cc15a5cb210b1de83
 F ext/rbu/rbusave.test 0f43b6686084f426ddd040b878426452fd2c2f48
 F ext/rbu/rbuvacuum.test 4a977447c15c2581ab668781d9ef4294382530e0
-F ext/rbu/rbuvacuum2.test 2569205b74ff40fbf3bda2fce33a58eb40eebdcc
-F ext/rbu/sqlite3rbu.c e074c38798b90591f7f0cf0032d62f152ce5a95e
+F ext/rbu/rbuvacuum2.test 2074ab14fe66e1c7e7210c62562650dcd215bbaa
+F ext/rbu/sqlite3rbu.c bb0de6cdbdb14a7d55a097238a434b7e99caf318
 F ext/rbu/sqlite3rbu.h 6fb6294c34a9ca93b5894a33bca530c6f08decba
 F ext/rbu/test_rbu.c 5aa22616afac6f71ebd3d9bc9bf1006cfabcca88
 F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
@@ -312,7 +314,7 @@ F ext/userauth/userauth.c 5fa3bdb492f481bbc1709fc83c91ebd13460c69e
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 2cf5f0362c5687fd8e912c3a327b49a2e8ba0f9b
+F main.mk 8f620f3418d7252a3f428f5aacf674b5507807a8
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -325,14 +327,14 @@ F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
 F sqlite3.1 fc7ad8990fc8409983309bb80de8c811a7506786
 F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
 F src/alter.c 3b23977620ce9662ac54443f65b87ba996e36121
-F src/analyze.c 3c4a63ff7a55faefecf6eb1589932fdbc06b2415
+F src/analyze.c 317dbaf31c16050582b09bf4f323b4e0f1813251
 F src/attach.c 8c476f8bd5d2afe11d925f890d30e527e5b0ce43
 F src/auth.c 930b376a9c56998557367e6f7f8aaeac82a2a792
 F src/backup.c faf17e60b43233c214aae6a8179d24503a61e83b
 F src/bitvec.c 17ea48eff8ba979f1f5b04cc484c7bb2be632f33
 F src/btmutex.c 0e9ce2d56159b89b9bc8e197e023ee11e39ff8ca
-F src/btree.c d2c100618784bd89c089fcef03ff6e789768ecae
-F src/btree.h 2349a588abcd7e0c04f984e15c5c777b61637583
+F src/btree.c e6b8f39d7dd1ad65f1747956de36f2595172a23d
+F src/btree.h e6d352808956ec163a17f832193a3e198b3fb0ac
 F src/btreeInt.h 10c4b77c2fb399580babbcc7cf652ac10dba796e
 F src/build.c 9e799f1edd910dfa8a0bc29bd390d35d310596af
 F src/callback.c 2e76147783386374bf01b227f752c81ec872d730
@@ -340,8 +342,8 @@ F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
 F src/ctime.c 9f2296a4e5d26ebf0e0d95a0af4628f1ea694e7a
 F src/date.c dc3f1391d9297f8c748132813aaffcb117090d6e
 F src/dbstat.c 19ee7a4e89979d4df8e44cfac7a8f905ec89b77d
-F src/delete.c c8bc10d145c9666a34ae906250326fdaa8d58fa5
-F src/expr.c 449cbb8b9857ff8eb685b72555086818a178858c
+F src/delete.c 8a444fea8340989d6b1be2e122c55bfc61ce69be
+F src/expr.c f06f41e5e5daca10fb090e70a2502dcc0dbc992b
 F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
 F src/fkey.c 2e9aabe1aee76273aff8a84ee92c464e095400ae
 F src/func.c c67273e1ec08abbdcc14c189892a3ff6eeece86b
@@ -350,11 +352,11 @@ F src/hash.c 63d0ee752a3b92d4695b2b1f5259c4621b2cfebd
 F src/hash.h ab34c5c54a9e9de2e790b24349ba5aab3dbb4fd4
 F src/hwtime.h 747c1bbe9df21a92e9c50f3bbec1de841dc5e5da
 F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
-F src/insert.c 91ba5d0143e66479081536ebbaff1850ec9f57d9
+F src/insert.c 05e47e2de7b712a3a4148cd469e5f60873f5ef13
 F src/legacy.c 75d3023be8f0d2b99d60f905090341a03358c58e
-F src/loadext.c 5d6642d141c07d366e43d359e94ec9de47add41d
+F src/loadext.c a68d8d1d14cf7488bb29dc5311cb1ce9a4404258
 F src/main.c e207b81542d13b9f13d61e78ca441f9781f055b0
-F src/malloc.c f3fad34cd570022abca558c573f1761fb09a8212
+F src/malloc.c fc1b9f445290f2145da48fc08730c26e6082b640
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c 6919bcf12f221868ea066eec27e579fed95ce98b
 F src/mem2.c f1940d9e91948dd6a908fbb9ce3835c36b5d83c3
@@ -381,23 +383,23 @@ F src/parse.y 29153738a7322054359320eb00b5a4cd44389f20
 F src/pcache.c 51070ec9b8251bbf9c6ea3d35fd96a458752929e
 F src/pcache.h 2cedcd8407eb23017d92790b112186886e179490
 F src/pcache1.c e3967219b2a92b9edcb9324a4ba75009090d3953
-F src/pragma.c 5a23557e490e7ac5afef097efc4b59dce5b482c2
-F src/pragma.h f9b221b2c8949ea941dbee49934299e4ed5af41c
+F src/pragma.c 0e7a7c6f1c6fd8ff50c0fff65b8bb80174bc49c5
+F src/pragma.h 61aa5389118594bebb28120a6720401aee34ce1a
 F src/prepare.c b1140c3d0cf59bc85ace00ce363153041b424b7a
 F src/printf.c ff10a9b9902cd2afe5f655f3013c6307d969b1fd
 F src/random.c 80f5d666f23feb3e6665a6ce04c7197212a88384
-F src/resolve.c bb070cf5f23611c44ab7e4788803684e385fc3fb
+F src/resolve.c f9bc0de45a30a450da47b3766de00be89bf9be79
 F src/rowset.c 7b7e7e479212e65b723bf40128c7b36dc5afdfac
-F src/select.c dfb6cadc3dcfba1b1bdbfba62ebba2b4b673413e
-F src/shell.c 6095531aa900decdaa765e0f3993fba7153c92c1
-F src/sqlite.h.in e8e2d108d82647f0a812fdb74accf91c1ec08ddc
+F src/select.c 3856db523b942062bca8722ba03b61c324ff94d6
+F src/shell.c 0344f71dc008df2433ae10175f59ad432c428810
+F src/sqlite.h.in e71655293c9bde26939496f3aac9d1821d2c07a2
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
 F src/sqlite3ext.h 8648034aa702469afb553231677306cc6492a1ae
-F src/sqliteInt.h f3450b70cfd99b434304225cf3b95de9cb4a9536
+F src/sqliteInt.h 525c061ae9aafc8d4720a018d82f0936d9eee5ab
 F src/sqliteLimit.h c0373387c287c8d0932510b5547ecde31b5da247
 F src/status.c a9e66593dfb28a9e746cba7153f84d49c1ddc4b1
-F src/table.c 5226df15ab9179b9ed558d89575ea0ce37b03fc9
-F src/tclsqlite.c 205c66b9b81d97978a155caa3ef5be9c4de2b174
+F src/table.c b46ad567748f24a326d9de40e5b9659f96ffff34
+F src/tclsqlite.c 418f5e5e0840425a7e5b33f3600dccd378a57549
 F src/test1.c 8a98191a1da8e100f77cdb5cc716df67d405028d
 F src/test2.c 3efb99ab7f1fc8d154933e02ae1378bac9637da5
 F src/test3.c d03f5b5da9a2410b7a91c64b0d3306ed28ab6fee
@@ -437,31 +439,31 @@ F src/test_quota.h 2a8ad1952d1d2ca9af0ce0465e56e6c023b5e15d
 F src/test_rtree.c 671f3fae50ff116ef2e32a3bf1fe21b5615b4b7b
 F src/test_schema.c f575932cb6274d12147a77e13ea4b49d52408513
 F src/test_server.c a2615049954cbb9cfb4a62e18e2f0616e4dc38fe
-F src/test_sqllog.c 0d138a8180a312bf996b37fa66da5c5799d4d57b
+F src/test_sqllog.c 11e6ce7575f489155c604ac4b439f2ac1d3d5aef
 F src/test_superlock.c 4839644b9201da822f181c5bc406c0b2385f672e
 F src/test_syscall.c 1073306ba2e9bfc886771871a13d3de281ed3939
 F src/test_tclvar.c df9fe1213c2634687a9ca0b0bec0d2119d359ae3
 F src/test_thread.c 911d15fb14e19c0c542bdc8aabf981c2f10a4858
 F src/test_vfs.c f0186261a24de2671d080bcd8050732f0cb64f6e
 F src/test_vfstrace.c bab9594adc976cbe696ff3970728830b4c5ed698
-F src/test_windirent.c 600398db0198ca1c77ca183831bf456746b6f5c4
-F src/test_windirent.h 7edc57e2faa727026dbd5d010dd0e2e665d5aa01
+F src/test_windirent.c 17f91f5f2aa1bb7328abb49414c363b5d2a9d3ff
+F src/test_windirent.h 5d67483a55442e31e1bde0f4a230e6e932ad5906
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/threads.c 4ae07fa022a3dc7c5beb373cf744a85d3c5c6c3c
 F src/tokenize.c 5c2f516876fc27fbd7753913f032f49eb89e83b5
 F src/treeview.c 4e44ade3bfe59d82005039f72e09333ce2b4162c
 F src/trigger.c c9f0810043b265724fdb1bdd466894f984dfc182
-F src/update.c 1da7c462110bffed442a42884cb0d528c1db46d8
+F src/update.c b356b29d04c71f33c779f2cb557cf953819bdd7a
 F src/utf.c 699001c79f28e48e9bcdf8a463da029ea660540c
 F src/util.c a88b0466fddf445ce752226d4698ca3faada620a
 F src/vacuum.c 33c174b28886b2faf26e503b5a49a1c01a9b1c16
-F src/vdbe.c 88bd6c32b333580d2661ac3afe33369757fb1522
-F src/vdbe.h 50ee139f9c68fff91be1d717ed3a6abbd496919c
-F src/vdbeInt.h 281cb70332dc8b593b8c7afe776f3a2ba7d4255e
+F src/vdbe.c 132f552033f72820c27a100861fa83254358cbcd
+F src/vdbe.h b0866e4191f096f1c987a84b042c3599bdf5423b
+F src/vdbeInt.h 4cad10b68ed052104a997454540ea71ceb2888e1
 F src/vdbeapi.c d6ebaa465f070eb1af8ba4e7b34583ece87bdd24
-F src/vdbeaux.c 12919c5aa354296d6b9ba808bca3e9dda836858c
-F src/vdbeblob.c f4f98ea672b242f807c08c92c7faaa79e5091b65
-F src/vdbemem.c d3fd85b7b7ef3eb75de29c6d7e1d10d3ca78b4fd
+F src/vdbeaux.c 35c9a9908174e5a26c96d15e1f98214814a39147
+F src/vdbeblob.c 824f360105b8cd43c2ec8c4611fd3b162a3a3eed
+F src/vdbemem.c 3b5a9a5b375458d3e12a50ae1aaa41eeec2175fd
 F src/vdbesort.c eda25cb2d1727efca6f7862fea32b8aa33c0face
 F src/vdbetrace.c 41963d5376f0349842b5fc4aaaaacd7d9cdc0834
 F src/vtab.c c4bbe0f870f52036553f8098aee0703997f0577a
@@ -469,12 +471,13 @@ F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
 F src/wal.c 40c543f0a2195d1b0dc88ef12142bea690009344
 F src/wal.h 06b2a0b599cc0f53ea97f497cf8c6b758c999f71
 F src/walker.c 91a6df7435827e41cff6bb7df50ea00934ee78b0
-F src/where.c 6bbf9284f4f15a6fa48663d033870cc0d7f5ee66
+F src/where.c bc71775e23d23334e8f449aa31012d692dc09cb2
 F src/whereInt.h 2bcc3d176e6091cb8f50a30b65c006e88a73614d
 F src/wherecode.c e04ac8f24c3ac8621df6c3be3ac8c7d4fa893745
-F src/whereexpr.c 87ecdf24beba4498e4380b31c4131febb0a6ceaa
+F src/whereexpr.c 35ad025389a632a3987a35617c878be3b3d70dc6
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
 F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
+F test/affinity3.test 6a101af2fc945ce2912f6fe54dd646018551710d
 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
 F test/aggnested.test b35b4cd69fc913f90d39a575e171e1116c3a4bb7
 F test/alias.test 4529fbc152f190268a15f9384a5651bbbabc9d87
@@ -626,7 +629,7 @@ F test/cse.test 277350a26264495e86b1785f34d2d0c8600e021c
 F test/csv01.test e0ba3caaa57e4c667a0b45977689fb8082f14348
 F test/ctime.test ff6c38e822459d6ca743c34901caf57740b08b54
 F test/cursorhint.test 7bc346788390475e77a345da2b92270d04d35856
-F test/cursorhint2.test fa41f0d997e67db921d08c31e73111b32811201a
+F test/cursorhint2.test 8457e93d97f665f23f97cdbc8477d16e3480331b
 F test/date.test a6a5a48b90907bca9fbcc79a30be5a715c1ab2fc
 F test/dbfuzz.c 8cc2bdb818b4483a052f9f80f96be74cbd9a6e1d
 F test/dbstatus.test 73149851b3aff14fc6db478e58f9083a66422cf5
@@ -692,7 +695,7 @@ F test/fkey4.test 86446017011273aad8f9a99c1a65019e7bd9ca9d
 F test/fkey5.test 5a373303f201ac03c22ba1ef17a733d3f56e611a
 F test/fkey6.test d078a1e323a740062bed38df32b8a736fd320dc0
 F test/fkey7.test 72e915890ee4a005daaf3002cb208e8fe973ac13
-F test/fkey8.test 7bd1dd0174a0e29a90c62c517b9e2a410a0b345d
+F test/fkey8.test e5372e32cdb4481f121ec3550703eeb7b4e0762c
 F test/fkey_malloc.test 594a7ea1fbab553c036c70813cd8bd9407d63749
 F test/fordelete.test eb93a2f34137bb87bdab88fcab06c0bd92719aff
 F test/format4.test 1f0cac8ff3895e9359ed87e41aaabee982a812eb
@@ -880,7 +883,7 @@ F test/ioerr4.test f130fe9e71008577b342b8874d52984bd04ede2c
 F test/ioerr5.test 2edfa4fb0f896f733071303b42224df8bedd9da4
 F test/ioerr6.test a395a6ab144b26a9e3e21059a1ab6a7149cca65b
 F test/join.test f9d4a28dec81c6e9dc21b73518e024d73b5ebf57
-F test/join2.test f2171c265e57ee298a27e57e7051d22962f9f324
+F test/join2.test a48f723c5692e2cbb23a9297ac2720cb77d51a70
 F test/join3.test 6f0c774ff1ba0489e6c88a3e77b9d3528fb4fda0
 F test/join4.test 1a352e4e267114444c29266ce79e941af5885916
 F test/join5.test bc98ea4b4e5003f5b1453701ebb8cd7d1c01a550
@@ -895,7 +898,7 @@ F test/json101.test c0897616f32d95431f37fd291cb78742181980ac
 F test/json102.test bf3fe7a706d30936a76a0f7a0375e1e8e73aff5a
 F test/json103.test c5f6b85e69de05f6b3195f9f9d5ce9cd179099a0
 F test/keyword1.test 37ef6bba5d2ed5b07ecdd6810571de2956599dff
-F test/kvtest.c 2c66ddefcd03c2caa337f6dd79e6c82368af83df
+F test/kvtest.c 9e428931f0733b5ba65b6b5abd95b27320e875a3
 F test/lastinsert.test 42e948fd6442f07d60acbd15d33fb86473e0ef63
 F test/laststmtchanges.test ae613f53819206b3222771828d024154d51db200
 F test/like.test 0603f4fa0dad50987f70032c05800cbfa8985302
@@ -1010,6 +1013,7 @@ F test/permutations.test cd0b7bc04bf5e50d3a993d24c834d591f7d4f5fe
 F test/pragma.test 1e94755164a3a3264cd39836de4bebcb7809e5f8
 F test/pragma2.test e5d5c176360c321344249354c0c16aec46214c9f
 F test/pragma3.test 14c12bc5352b1e100e0b6b44f371053a81ccf8ed
+F test/pragma4.test 6e85b6eab8e61ffc9c7db59d842276674e8e3264
 F test/printf.test b3ff34e73d59124140eaf89f7672e21bc2ca5fcc
 F test/printf2.test 0b61566dd1c0f0b802f59dffa228c5dc5aa6b054
 F test/progress.test ebab27f670bd0d4eb9d20d49cef96e68141d92fb
@@ -1073,7 +1077,7 @@ F test/select8.test 8c8f5ae43894c891efc5755ed905467d1d67ad5d
 F test/select9.test aebc2bb0c3bc44606125033cbcaac2c8d1f33a95
 F test/selectA.test 101e722370ac6e84978c2958b8931c78b10a1709
 F test/selectB.test 954e4e49cf1f896d61794e440669e03a27ceea25
-F test/selectC.test 871fb55d884d3de5943c4057ebd22c2459e71977
+F test/selectC.test e25243f8ca503e06f252eb0218976d07cfeceac3
 F test/selectD.test b0f02a04ef7737decb24e08be2c39b9664b43394
 F test/selectE.test a8730ca330fcf40ace158f134f4fe0eb00c7edbf
 F test/selectF.test 21c94e6438f76537b72532fa9fd4710cdd455fc3
@@ -1127,7 +1131,7 @@ F test/speed3.test 694affeb9100526007436334cf7d08f3d74b85ef
 F test/speed4.test abc0ad3399dcf9703abed2fff8705e4f8e416715
 F test/speed4p.explain 6b5f104ebeb34a038b2f714150f51d01143e59aa
 F test/speed4p.test 0e51908951677de5a969b723e03a27a1c45db38b
-F test/speedtest1.c 4e8ea6165046f02e1cfe0f4700256e91c981ec10
+F test/speedtest1.c 02fe15bb784c5276a083ffe9969cc51e0bce7644
 F test/spellfix.test f9c1f431e2c096c8775fec032952320c0e4700db
 F test/spellfix2.test dfc8f519a3fc204cb2dfa8b4f29821ae90f6f8c3
 F test/spellfix3.test 0f9efaaa502a0e0a09848028518a6fb096c8ad33
@@ -1336,6 +1340,7 @@ F test/triggerB.test 56780c031b454abac2340dbb3b71ac5c56c3d7fe
 F test/triggerC.test 302d8995f5ffe63bbc15053abb3ef7a39cf5a092
 F test/triggerD.test 8e7f3921a92a5797d472732108109e44575fa650
 F test/triggerE.test 15fa63f1097db1f83dd62d121616006978063d1f
+F test/triggerF.test 55b1eb13433997faac3a4948c1d8252f6c8c636b
 F test/tt3_checkpoint.c 9e75cf7c1c364f52e1c47fd0f14c4340a9db0fe1
 F test/tt3_index.c 39eec10a35f57672225be4d182862152896dee4a
 F test/tt3_lookaside1.c 0377e202c3c2a50d688cb65ba203afeda6fafeb9
@@ -1349,6 +1354,7 @@ F test/unique2.test 3674e9f2a3f1fbbfd4772ac74b7a97090d0f77d2
 F test/unixexcl.test d936ba2b06794018e136418addd59a2354eeae97
 F test/unordered.test ca7adce0419e4ca0c50f039885e76ed2c531eda8
 F test/update.test 6c68446b8a0a33d522a7c72b320934596a2d7d32
+F test/update2.test 7f72ef307d58be09a8ef61db23a7ef60e5af019d
 F test/uri.test 3481026f00ade6dfe8adb7acb6e1e47b04369568
 F test/uri2.test 9d3ba7a53ee167572d53a298ee4a5d38ec4a8fb7
 F test/userauth01.test e740a2697a7b40d7c5003a7d7edaee16acd349a9
@@ -1377,7 +1383,7 @@ F test/vtabC.test 4528f459a13136f982e75614d120aef165f17292
 F test/vtabD.test 05b3f1d77117271671089e48719524b676842e96
 F test/vtabE.test d5024aa42754962f6bb0afd261681686488e7afe
 F test/vtabF.test 1918844c7c902f6a16c8dacf1ec8f84886d6e78b
-F test/vtabH.test 97f61b0253260831af6232163f7852e2653baed6
+F test/vtabH.test a2912cd3ea3386aecc3cb74ebfdfcc4e6d4b7dd3
 F test/vtabI.test 751b07636700dbdea328e4265b6077ccd6811a3f
 F test/vtab_alter.test 9e374885248f69e251bdaacf480b04a197f125e5
 F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8
@@ -1479,7 +1485,7 @@ F tool/mkmsvcmin.tcl 2f12f7fa8858bbe61cf81820a2da96c79ed1ca8d
 F tool/mkopcodec.tcl d1b6362bd3aa80d5520d4d6f3765badf01f6c43c
 F tool/mkopcodeh.tcl a01d2c1d8a6205b03fc635adf3735b4c523befd3
 F tool/mkopts.tcl 66ac10d240cc6e86abd37dc908d50382f84ff46e
-F tool/mkpragmatab.tcl a30ee93515135466fc49ae881f75da07ebcafd19
+F tool/mkpragmatab.tcl ebb4bfcd2f8010e0a3934b6118db4b5f2f5edf5c
 F tool/mkspeedsql.tcl a1a334d288f7adfe6e996f2e712becf076745c97
 F tool/mksqlite3c-noext.tcl fef88397668ae83166735c41af99d79f56afaabb
 F tool/mksqlite3c.tcl 06b2e6a0f21cc0a5d70fbbd136b3e0a96470645e
@@ -1501,7 +1507,7 @@ F tool/showstat4.c b14159aa062f661b394ba37b6b7b94bfb8012ab9
 F tool/showwal.c ec79959834f7b21f1e0a2aa52bb7c056d2203977
 F tool/soak1.tcl 8d407956e1a45b485a8e072470a3e629a27037fe
 F tool/spaceanal.tcl ab7d9bf68062907282a64b3e12ccbfad47193c5a
-F tool/speed-check.sh e6ca0695b047af64201ebe0ef452e423f55d78b1
+F tool/speed-check.sh 65ac2f5b00771b9dcefb95bebae1aab76c537ea3
 F tool/speedtest.tcl 06c76698485ccf597b9e7dbb1ac70706eb873355
 F tool/speedtest16.c ecb6542862151c3e6509bbc00509b234562ae81e
 F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
@@ -1541,10 +1547,7 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P d3ac32a6e7f1823450feb3d1089802542090d164
-R 1c116e0d91d0fafdc790fe63a7695a8d
-T *branch * printf-optimization
-T *sym-printf-optimization *
-T -sym-trunk *
-U drh
-Z 6815c125f61af9819176bed00aaf68bc
+P ffda1d1e1c858abd02f0c07b906cfac5ad075498
+R c37bc6770e2789d7f8851d61fd232055
+U dan
+Z a07b3b8a92ddc391359da9de406f8455
@@ -1 +1 @@
-acdb8f6f10953ed4290aadc9e026edd57d1dd21a
+74ad80eb745c708bdbbbf24cbbbf50971e84182f
@@ -1615,7 +1615,7 @@ static void initAvgEq(Index *pIdx){
        }
      }

-      if( nDist100>nSum100 ){
+      if( nDist100>nSum100 && sumEq<nRow ){
        avgEq = ((i64)100 * (nRow - sumEq))/(nDist100 - nSum100);
      }
      if( avgEq==0 ) avgEq = 1;
@@ -3356,12 +3356,14 @@ static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
      if( eType==PTRMAP_OVERFLOW1 ){
        CellInfo info;
        pPage->xParseCell(pPage, pCell, &info);
-        if( info.nLocal<info.nPayload
-         && pCell+info.nSize-1<=pPage->aData+pPage->maskPage
-         && iFrom==get4byte(pCell+info.nSize-4)
-        ){
-          put4byte(pCell+info.nSize-4, iTo);
-          break;
+        if( info.nLocal<info.nPayload ){
+          if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
+            return SQLITE_CORRUPT_BKPT;
+          }
+          if( iFrom==get4byte(pCell+info.nSize-4) ){
+            put4byte(pCell+info.nSize-4, iTo);
+            break;
+          }
        }
      }else{
        if( get4byte(pCell)==iFrom ){
@@ -4521,16 +4523,14 @@ static int accessPayload(
            pCur->aOverflow, nOvfl*2*sizeof(Pgno)
        );
        if( aNew==0 ){
-          rc = SQLITE_NOMEM_BKPT;
+          return SQLITE_NOMEM_BKPT;
        }else{
          pCur->nOvflAlloc = nOvfl*2;
          pCur->aOverflow = aNew;
        }
      }
-      if( rc==SQLITE_OK ){
-        memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
-        pCur->curFlags |= BTCF_ValidOvfl;
-      }
+      memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
+      pCur->curFlags |= BTCF_ValidOvfl;
    }

    /* If the overflow page-list cache has been allocated and the
@@ -4545,8 +4545,8 @@ static int accessPayload(
      offset = (offset%ovflSize);
    }

-    for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
-
+    assert( rc==SQLITE_OK && amt>0 );
+    while( nextPage ){
      /* If required, populate the overflow page-list cache. */
      if( (pCur->curFlags & BTCF_ValidOvfl)!=0 ){
        assert( pCur->aOverflow[iIdx]==0
@@ -4635,6 +4635,9 @@ static int accessPayload(
        amt -= a;
        pBuf += a;
      }
+      if( amt==0 ) break;
+      if( rc ) break;
+      iIdx++;
    }
  }

@@ -7269,7 +7272,6 @@ static int balance_nonroot(
  for(i=0; i<nOld; i++){
    MemPage *p = apOld[i];
    szNew[i] = usableSpace - p->nFree;
-    if( szNew[i]<0 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; }
    for(j=0; j<p->nOverflow; j++){
      szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);
    }
@@ -7948,7 +7950,7 @@ static int balance(BtCursor *pCur){
 int sqlite3BtreeInsert(
  BtCursor *pCur,                /* Insert data into the table of this cursor */
  const BtreePayload *pX,        /* Content of the row to be inserted */
-  int appendBias,                /* True if this is likely an append */
+  int flags,                     /* True if this is likely an append */
  int seekResult                 /* Result of prior MovetoUnpacked() call */
 ){
  int rc;
@@ -7961,6 +7963,8 @@ int sqlite3BtreeInsert(
  unsigned char *oldCell;
  unsigned char *newCell = 0;

+  assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags );
+
  if( pCur->eState==CURSOR_FAULT ){
    assert( pCur->skipNext!=SQLITE_OK );
    return pCur->skipNext;
@@ -8001,6 +8005,11 @@ int sqlite3BtreeInsert(
    ** cursors open on the row being replaced */
    invalidateIncrblobCursors(p, pX->nKey, 0);

+    /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing 
+    ** to a row with the same key as the new entry being inserted.  */
+    assert( (flags & BTREE_SAVEPOSITION)==0 || 
+            ((pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey) );
+
    /* If the cursor is currently on the last row and we are appending a
    ** new row onto the end, set the "loc" to avoid an unnecessary
    ** btreeMoveto() call */
@@ -8010,10 +8019,10 @@ int sqlite3BtreeInsert(
               && pCur->info.nKey==pX->nKey-1 ){
      loc = -1;
    }else if( loc==0 ){
-      rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, appendBias, &loc);
+      rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
      if( rc ) return rc;
    }
-  }else if( loc==0 ){
+  }else if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){
    if( pX->nMem ){
      UnpackedRecord r;
      r.pKeyInfo = pCur->pKeyInfo;
@@ -8024,9 +8033,9 @@ int sqlite3BtreeInsert(
      r.r1 = 0;
      r.r2 = 0;
      r.eqSeen = 0;
-      rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, appendBias, &loc);
+      rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
    }else{
-      rc = btreeMoveto(pCur, pX->pKey, pX->nKey, appendBias, &loc);
+      rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
    }
    if( rc ) return rc;
  }
@@ -8114,6 +8123,20 @@ int sqlite3BtreeInsert(
    ** from trying to save the current position of the cursor.  */
    pCur->apPage[pCur->iPage]->nOverflow = 0;
    pCur->eState = CURSOR_INVALID;
+    if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){
+      rc = moveToRoot(pCur);
+      if( pCur->pKeyInfo ){
+        assert( pCur->pKey==0 );
+        pCur->pKey = sqlite3Malloc( pX->nKey );
+        if( pCur->pKey==0 ){
+          rc = SQLITE_NOMEM;
+        }else{
+          memcpy(pCur->pKey, pX->pKey, pX->nKey);
+        }
+      }
+      pCur->eState = CURSOR_REQUIRESEEK;
+      pCur->nKey = pX->nKey;
+    }
  }
  assert( pCur->apPage[pCur->iPage]->nOverflow==0 );

@@ -249,9 +249,10 @@ int sqlite3BtreeCursorHasMoved(BtCursor*);
 int sqlite3BtreeCursorRestore(BtCursor*, int*);
 int sqlite3BtreeDelete(BtCursor*, u8 flags);

-/* Allowed flags for the 2nd argument to sqlite3BtreeDelete() */
+/* Allowed flags for sqlite3BtreeDelete() and sqlite3BtreeInsert() */
 #define BTREE_SAVEPOSITION 0x02  /* Leave cursor pointing at NEXT or PREV */
 #define BTREE_AUXDELETE    0x04  /* not the primary delete operation */
+#define BTREE_APPEND       0x08  /* Insert is likely an append */

 /* An instance of the BtreePayload object describes the content of a single
 ** entry in either an index or table btree.
@@ -282,7 +283,7 @@ struct BtreePayload {
 };

 int sqlite3BtreeInsert(BtCursor*, const BtreePayload *pPayload,
-                       int bias, int seekResult);
+                       int flags, int seekResult);
 int sqlite3BtreeFirst(BtCursor*, int *pRes);
 int sqlite3BtreeLast(BtCursor*, int *pRes);
 int sqlite3BtreeNext(BtCursor*, int *pRes);
@@ -519,12 +519,8 @@ void sqlite3DeleteFrom(
 #endif
    {
      int count = (pParse->nested==0);    /* True to count changes */
-      int iIdxNoSeek = -1;
-      if( bComplex==0 && aiCurOnePass[1]!=iDataCur ){
-        iIdxNoSeek = aiCurOnePass[1];
-      }
      sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
-          iKey, nKey, count, OE_Default, eOnePass, iIdxNoSeek);
+          iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]);
    }
  
    /* End of the loop over all rowids/primary-keys. */
@@ -604,15 +600,17 @@ delete_from_cleanup:
 **
 **   If eMode is ONEPASS_MULTI, then this call is being made as part
 **   of a ONEPASS delete that affects multiple rows. In this case, if 
-**   iIdxNoSeek is a valid cursor number (>=0), then its position should
-**   be preserved following the delete operation. Or, if iIdxNoSeek is not
-**   a valid cursor number, the position of iDataCur should be preserved
-**   instead.
+**   iIdxNoSeek is a valid cursor number (>=0) and is not the same as
+**   iDataCur, then its position should be preserved following the delete
+**   operation. Or, if iIdxNoSeek is not a valid cursor number, the
+**   position of iDataCur should be preserved instead.
 **
 ** iIdxNoSeek:
-**   If iIdxNoSeek is a valid cursor number (>=0), then it identifies an
-**   index cursor (from within array of cursors starting at iIdxCur) that
-**   already points to the index entry to be deleted.
+**   If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur,
+**   then it identifies an index cursor (from within array of cursors
+**   starting at iIdxCur) that already points to the index entry to be deleted.
+**   Except, this optimization is disabled if there are BEFORE triggers since
+**   the trigger body might have moved the cursor.
 */
 void sqlite3GenerateRowDelete(
  Parse *pParse,     /* Parsing context */
@@ -683,13 +681,18 @@ void sqlite3GenerateRowDelete(

    /* If any BEFORE triggers were coded, then seek the cursor to the 
    ** row to be deleted again. It may be that the BEFORE triggers moved
-    ** the cursor or of already deleted the row that the cursor was
+    ** the cursor or already deleted the row that the cursor was
    ** pointing to.
+    **
+    ** Also disable the iIdxNoSeek optimization since the BEFORE trigger
+    ** may have moved that cursor.
    */
    if( addrStart<sqlite3VdbeCurrentAddr(v) ){
      sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
      VdbeCoverageIf(v, opSeek==OP_NotExists);
      VdbeCoverageIf(v, opSeek==OP_NotFound);
+      testcase( iIdxNoSeek>=0 );
+      iIdxNoSeek = -1;
    }

    /* Do FK processing. This call checks that any FK constraints that
@@ -716,7 +719,7 @@ void sqlite3GenerateRowDelete(
    if( eMode!=ONEPASS_OFF ){
      sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
    }
-    if( iIdxNoSeek>=0 ){
+    if( iIdxNoSeek>=0 && iIdxNoSeek!=iDataCur ){
      sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
    }
    if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;
@@ -870,6 +873,10 @@ int sqlite3GenerateIndexKey(
  }
  if( regOut ){
    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
+    if( pIdx->pTable->pSelect ){
+      const char *zAff = sqlite3IndexAffinityStr(pParse->db, pIdx);
+      sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
+    }
  }
  sqlite3ReleaseTempRange(pParse, regBase, nCol);
  return regBase;
@@ -3612,6 +3612,11 @@ int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
      u8 enc = ENC(db);      /* The text encoding used by this database */
      CollSeq *pColl = 0;    /* A collating sequence */

+      if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
+        /* SQL functions can be expensive. So try to move constant functions
+        ** out of the inner loop, even if that means an extra OP_Copy. */
+        return sqlite3ExprCodeAtInit(pParse, pExpr, -1);
+      }
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      if( ExprHasProperty(pExpr, EP_TokenOnly) ){
        pFarg = 0;
@@ -3992,24 +3997,40 @@ int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){

 /*
 ** Factor out the code of the given expression to initialization time.
+**
+** If regDest>=0 then the result is always stored in that register and the
+** result is not reusable.  If regDest<0 then this routine is free to 
+** store the value whereever it wants.  The register where the expression 
+** is stored is returned.  When regDest<0, two identical expressions will
+** code to the same register.
 */
-void sqlite3ExprCodeAtInit(
+int sqlite3ExprCodeAtInit(
  Parse *pParse,    /* Parsing context */
  Expr *pExpr,      /* The expression to code when the VDBE initializes */
-  int regDest,      /* Store the value in this register */
-  u8 reusable       /* True if this expression is reusable */
+  int regDest       /* Store the value in this register */
 ){
  ExprList *p;
  assert( ConstFactorOk(pParse) );
  p = pParse->pConstExpr;
+  if( regDest<0 && p ){
+    struct ExprList_item *pItem;
+    int i;
+    for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
+      if( pItem->reusable && sqlite3ExprCompare(pItem->pExpr,pExpr,-1)==0 ){
+        return pItem->u.iConstExprReg;
+      }
+    }
+  }
  pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
  p = sqlite3ExprListAppend(pParse, p, pExpr);
  if( p ){
     struct ExprList_item *pItem = &p->a[p->nExpr-1];
+     pItem->reusable = regDest<0;
+     if( regDest<0 ) regDest = ++pParse->nMem;
     pItem->u.iConstExprReg = regDest;
-     pItem->reusable = reusable;
  }
  pParse->pConstExpr = p;
+  return regDest;
 }

 /*
@@ -4032,19 +4053,8 @@ int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
-    ExprList *p = pParse->pConstExpr;
-    int i;
    *pReg  = 0;
-    if( p ){
-      struct ExprList_item *pItem;
-      for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
-        if( pItem->reusable && sqlite3ExprCompare(pItem->pExpr,pExpr,-1)==0 ){
-          return pItem->u.iConstExprReg;
-        }
-      }
-    }
-    r2 = ++pParse->nMem;
-    sqlite3ExprCodeAtInit(pParse, pExpr, r2, 1);
+    r2 = sqlite3ExprCodeAtInit(pParse, pExpr, -1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
@@ -4098,7 +4108,7 @@ void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
 */
 void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
  if( pParse->okConstFactor && sqlite3ExprIsConstant(pExpr) ){
-    sqlite3ExprCodeAtInit(pParse, pExpr, target, 0);
+    sqlite3ExprCodeAtInit(pParse, pExpr, target);
  }else{
    sqlite3ExprCode(pParse, pExpr, target);
  }
@@ -4170,7 +4180,7 @@ int sqlite3ExprCodeExprList(
        sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
      }
    }else if( (flags & SQLITE_ECEL_FACTOR)!=0 && sqlite3ExprIsConstant(pExpr) ){
-      sqlite3ExprCodeAtInit(pParse, pExpr, target+i, 0);
+      sqlite3ExprCodeAtInit(pParse, pExpr, target+i);
    }else{
      int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
      if( inReg!=target+i ){
@@ -1549,12 +1549,25 @@ void sqlite3GenerateConstraintChecks(
      onError = OE_Abort;
    }

-    if( ix==0 && pPk==pIdx && onError==OE_Replace && pPk->pNext==0 ){
+    /* Collision detection may be omitted if all of the following are true:
+    **   (1) The conflict resolution algorithm is REPLACE
+    **   (2) The table is a WITHOUT ROWID table
+    **   (3) There are no secondary indexes on the table
+    **   (4) No delete triggers need to be fired if there is a conflict
+    **   (5) No FK constraint counters need to be updated if a conflict occurs.
+    */ 
+    if( (ix==0 && pIdx->pNext==0)                   /* Condition 3 */
+     && pPk==pIdx                                   /* Condition 2 */
+     && onError==OE_Replace                         /* Condition 1 */
+     && ( 0==(db->flags&SQLITE_RecTriggers) ||      /* Condition 4 */
+          0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
+     && ( 0==(db->flags&SQLITE_ForeignKeys) ||      /* Condition 5 */
+         (0==pTab->pFKey && 0==sqlite3FkReferences(pTab)))
+    ){
      sqlite3VdbeResolveLabel(v, addrUniqueOk);
      continue;
    }

-    
    /* Check to see if the new index entry will be unique */
    sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                         regIdx, pIdx->nKeyCol); VdbeCoverage(v);
@@ -1638,7 +1651,7 @@ void sqlite3GenerateConstraintChecks(
        }
        sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
            regR, nPkField, 0, OE_Replace,
-            (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), -1);
+            (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
        seenReplace = 1;
        break;
      }
@@ -1671,7 +1684,7 @@ void sqlite3CompleteInsertion(
  int iIdxCur,        /* First index cursor */
  int regNewData,     /* Range of content */
  int *aRegIdx,       /* Register used by each index.  0 for unused indices */
-  int isUpdate,       /* True for UPDATE, False for INSERT */
+  int update_flags,   /* True for UPDATE, False for INSERT */
  int appendBias,     /* True if this is likely to be an append */
  int useSeekResult   /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
 ){
@@ -1683,6 +1696,11 @@ void sqlite3CompleteInsertion(
  int i;              /* Loop counter */
  u8 bAffinityDone = 0; /* True if OP_Affinity has been run already */

+  assert( update_flags==0
+       || update_flags==OPFLAG_ISUPDATE
+       || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION)
+  );
+
  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
@@ -1701,6 +1719,7 @@ void sqlite3CompleteInsertion(
    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
      assert( pParse->nested==0 );
      pik_flags |= OPFLAG_NCHANGE;
+      pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
    }
    sqlite3VdbeChangeP5(v, pik_flags);
  }
@@ -1716,7 +1735,7 @@ void sqlite3CompleteInsertion(
    pik_flags = 0;
  }else{
    pik_flags = OPFLAG_NCHANGE;
-    pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
+    pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID);
  }
  if( appendBias ){
    pik_flags |= OPFLAG_APPEND;
@@ -2125,7 +2144,7 @@ static int xferOptimization(
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
      assert( (pDest->tabFlags & TF_Autoincrement)==0 );
    }
-    sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
+    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
    if( db->flags & SQLITE_Vacuum ){
      sqlite3VdbeAddOp3(v, OP_Last, iDest, 0, -1);
      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|
@@ -2157,7 +2176,7 @@ static int xferOptimization(
    sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
    VdbeComment((v, "%s", pDestIdx->zName));
    addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
-    sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
+    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
    if( db->flags & SQLITE_Vacuum ){
      /* This INSERT command is part of a VACUUM operation, which guarantees
      ** that the destination table is empty. If all indexed columns use
@@ -18,7 +18,6 @@
 #endif
 #include "sqlite3ext.h"
 #include "sqliteInt.h"
-#include <string.h>

 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 /*
@@ -217,14 +217,14 @@ static void sqlite3MallocAlarm(int nByte){
 ** Do a memory allocation with statistics and alarms.  Assume the
 ** lock is already held.
 */
-static int mallocWithAlarm(int n, void **pp){
-  int nFull;
+static void mallocWithAlarm(int n, void **pp){
  void *p;
+  int nFull = 0;
  assert( sqlite3_mutex_held(mem0.mutex) );
-  nFull = sqlite3GlobalConfig.m.xRoundup(n);
  sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
  if( mem0.alarmThreshold>0 ){
    sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
+    nFull = sqlite3GlobalConfig.m.xRoundup(n);
    if( nUsed >= mem0.alarmThreshold - nFull ){
      mem0.nearlyFull = 1;
      sqlite3MallocAlarm(nFull);
@@ -232,11 +232,11 @@ static int mallocWithAlarm(int n, void **pp){
      mem0.nearlyFull = 0;
    }
  }
-  p = sqlite3GlobalConfig.m.xMalloc(nFull);
+  p = sqlite3GlobalConfig.m.xMalloc(n);
 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  if( p==0 && mem0.alarmThreshold>0 ){
    sqlite3MallocAlarm(nFull);
-    p = sqlite3GlobalConfig.m.xMalloc(nFull);
+    p = sqlite3GlobalConfig.m.xMalloc(n);
  }
 #endif
  if( p ){
@@ -245,7 +245,6 @@ static int mallocWithAlarm(int n, void **pp){
    sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);
  }
  *pp = p;
-  return nFull;
 }

 /*
@@ -408,7 +408,9 @@ void sqlite3Pragma(
  }

  /* Register the result column names for pragmas that return results */
-  if( (pPragma->mPragFlg & PragFlg_NoColumns)==0 ){
+  if( (pPragma->mPragFlg & PragFlg_NoColumns)==0 
+   && ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0)
+  ){
    setPragmaResultColumnNames(v, pPragma);
  }

@@ -1953,6 +1955,15 @@ void sqlite3Pragma(

  } /* End of the PRAGMA switch */

+  /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only
+  ** purpose is to execute assert() statements to verify that if the
+  ** PragFlg_NoColumns1 flag is set and the caller specified an argument
+  ** to the PRAGMA, the implementation has not added any OP_ResultRow 
+  ** instructions to the VM.  */
+  if( (pPragma->mPragFlg & PragFlg_NoColumns1) && zRight ){
+    sqlite3VdbeVerifyNoResultRow(v);
+  }
+
 pragma_out:
  sqlite3DbFree(db, zLeft);
  sqlite3DbFree(db, zRight);
@@ -52,11 +52,12 @@
 /* Property flags associated with various pragma. */
 #define PragFlg_NeedSchema 0x01 /* Force schema load before running */
 #define PragFlg_NoColumns  0x02 /* OP_ResultRow called with zero columns */
-#define PragFlg_ReadOnly   0x04 /* Read-only HEADER_VALUE */
-#define PragFlg_Result0    0x08 /* Acts as query when no argument */
-#define PragFlg_Result1    0x10 /* Acts as query when has one argument */
-#define PragFlg_SchemaOpt  0x20 /* Schema restricts name search if present */
-#define PragFlg_SchemaReq  0x40 /* Schema required - "main" is default */
+#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */
+#define PragFlg_ReadOnly   0x08 /* Read-only HEADER_VALUE */
+#define PragFlg_Result0    0x10 /* Acts as query when no argument */
+#define PragFlg_Result1    0x20 /* Acts as query when has one argument */
+#define PragFlg_SchemaOpt  0x40 /* Schema restricts name search if present */
+#define PragFlg_SchemaReq  0x80 /* Schema required - "main" is default */

 /* Names of columns for pragmas that return multi-column result
 ** or that return single-column results where the name of the
@@ -133,14 +134,14 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "application_id",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_APPLICATION_ID },
 #endif
 #if !defined(SQLITE_OMIT_AUTOVACUUM)
 {/* zName:     */ "auto_vacuum",
  /* ePragTyp:  */ PragTyp_AUTO_VACUUM,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -148,7 +149,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_AUTOMATIC_INDEX)
 {/* zName:     */ "automatic_index",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_AutoIndex },
 #endif
@@ -161,31 +162,31 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "cache_size",
  /* ePragTyp:  */ PragTyp_CACHE_SIZE,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "cache_spill",
  /* ePragTyp:  */ PragTyp_CACHE_SPILL,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
 {/* zName:     */ "case_sensitive_like",
  /* ePragTyp:  */ PragTyp_CASE_SENSITIVE_LIKE,
-  /* ePragFlg:  */ 0,
+  /* ePragFlg:  */ PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "cell_size_check",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CellSizeCk },
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "checkpoint_fullfsync",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CkptFullFSync },
 #endif
@@ -206,21 +207,21 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "count_changes",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_CountRows },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN
 {/* zName:     */ "data_store_directory",
  /* ePragTyp:  */ PragTyp_DATA_STORE_DIRECTORY,
-  /* ePragFlg:  */ 0,
+  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "data_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_ReadOnly,
+  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_DATA_VERSION },
 #endif
@@ -234,7 +235,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
 {/* zName:     */ "default_cache_size",
  /* ePragTyp:  */ PragTyp_DEFAULT_CACHE_SIZE,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 1,
  /* iArg:      */ 0 },
 #endif
@@ -242,7 +243,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 {/* zName:     */ "defer_foreign_keys",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_DeferFKs },
 #endif
@@ -250,14 +251,14 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "empty_result_callbacks",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_NullCallback },
 #endif
 #if !defined(SQLITE_OMIT_UTF16)
 {/* zName:     */ "encoding",
  /* ePragTyp:  */ PragTyp_ENCODING,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -279,7 +280,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 {/* zName:     */ "foreign_keys",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ForeignKeys },
 #endif
@@ -287,19 +288,19 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "freelist_count",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_ReadOnly,
+  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_FREE_PAGE_COUNT },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "full_column_names",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_FullColNames },
 {/* zName:     */ "fullfsync",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_FullFSync },
 #endif
@@ -319,7 +320,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_CHECK)
 {/* zName:     */ "ignore_check_constraints",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_IgnoreChecks },
 #endif
@@ -377,14 +378,14 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "legacy_file_format",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_LegacyFileFmt },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE
 {/* zName:     */ "lock_proxy_file",
  /* ePragTyp:  */ PragTyp_LOCK_PROXY_FILE,
-  /* ePragFlg:  */ 0,
+  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -418,7 +419,7 @@ static const PragmaName aPragmaName[] = {
  /* iArg:      */ 0 },
 {/* zName:     */ "page_size",
  /* ePragTyp:  */ PragTyp_PAGE_SIZE,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -432,7 +433,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "query_only",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_QueryOnly },
 #endif
@@ -446,12 +447,12 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "read_uncommitted",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ReadUncommitted },
 {/* zName:     */ "recursive_triggers",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_RecTriggers },
 #endif
@@ -465,14 +466,14 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "reverse_unordered_selects",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ReverseOrder },
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "schema_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_SCHEMA_VERSION },
 #endif
@@ -486,13 +487,13 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "short_column_names",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_ShortColNames },
 #endif
 {/* zName:     */ "shrink_memory",
  /* ePragTyp:  */ PragTyp_SHRINK_MEMORY,
-  /* ePragFlg:  */ 0,
+  /* ePragFlg:  */ PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "soft_heap_limit",
@@ -504,7 +505,7 @@ static const PragmaName aPragmaName[] = {
 #if defined(SQLITE_DEBUG)
 {/* zName:     */ "sql_trace",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_SqlTrace },
 #endif
@@ -519,7 +520,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "synchronous",
  /* ePragTyp:  */ PragTyp_SYNCHRONOUS,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -533,12 +534,12 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "temp_store",
  /* ePragTyp:  */ PragTyp_TEMP_STORE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "temp_store_directory",
  /* ePragTyp:  */ PragTyp_TEMP_STORE_DIRECTORY,
-  /* ePragFlg:  */ 0,
+  /* ePragFlg:  */ PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -550,7 +551,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "user_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_NoColumns1|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ BTREE_USER_VERSION },
 #endif
@@ -558,27 +559,27 @@ static const PragmaName aPragmaName[] = {
 #if defined(SQLITE_DEBUG)
 {/* zName:     */ "vdbe_addoptrace",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeAddopTrace },
 {/* zName:     */ "vdbe_debug",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace },
 {/* zName:     */ "vdbe_eqp",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeEQP },
 {/* zName:     */ "vdbe_listing",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeListing },
 {/* zName:     */ "vdbe_trace",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_VdbeTrace },
 #endif
@@ -598,7 +599,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "writable_schema",
  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns,
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ SQLITE_WriteSchema|SQLITE_RecoveryMode },
 #endif
@@ -15,8 +15,6 @@
 ** table and column.
 */
 #include "sqliteInt.h"
-#include <stdlib.h>
-#include <string.h>

 /*
 ** Walk the expression tree pExpr and increase the aggregate function
@@ -657,6 +657,7 @@ static void codeDistinct(
  sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
  sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
  sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
+  sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
  sqlite3ReleaseTempReg(pParse, r1);
 }

@@ -742,8 +743,7 @@ static void selectInnerLoop(
    }else{
      ecelFlags = 0;
    }
-    assert( eDest!=SRT_Table || pSort==0 );
-    if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab ){
+    if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){
      /* For each expression in pEList that is a copy of an expression in
      ** the ORDER BY clause (pSort->pOrderBy), set the associated 
      ** iOrderByCol value to one more than the index of the ORDER BY 
@@ -1285,6 +1285,7 @@ static void generateSortTail(
    VdbeComment((v, "%s", aOutEx[i].zName ? aOutEx[i].zName : aOutEx[i].zSpan));
  }
  switch( eDest ){
+    case SRT_Table:
    case SRT_EphemTab: {
      sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
      sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
@@ -5651,7 +5652,7 @@ int sqlite3Select(
        ** of output.
        */
        resetAccumulator(pParse, &sAggInfo);
-        pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax,0,flag,0);
+        pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax, 0,flag,0);
        if( pWInfo==0 ){
          sqlite3ExprListDelete(db, pDel);
          goto select_end;
@@ -614,6 +614,7 @@ struct ShellState {
  int autoExplain;       /* Automatically turn on .explain mode */
  int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
  int statsOn;           /* True to display memory stats before each finalize */
+  int vmstepsOn;         /* Display VM steps before each finalize */
  int scanstatsOn;       /* True to display scan stats before each finalize */
  int countChanges;      /* True to display change counts */
  int backslashOn;       /* Resolve C-style \x escapes in SQL input text */
@@ -1997,6 +1998,12 @@ static int shell_exec(
        display_stats(db, pArg, 0);
      }

+      if( pArg && pArg->vmstepsOn && pStmt ){
+        int iCur = sqlite3_stmt_status(pStmt, SQLITE_STMTSTATUS_VM_STEP, 0);
+        FILE *out = pArg->traceOut ? pArg->traceOut : pArg->out;
+        raw_printf(out, "VM steps: %d\n", iCur);
+      }
+
      /* print loop-counters if required */
      if( pArg && pArg->scanstatsOn ){
        display_scanstats(db, pArg);
@@ -5339,6 +5346,16 @@ static int do_meta_command(char *zLine, ShellState *p){
    }
  }else

+  if( c=='v' && strncmp(azArg[0], "vmsteps", n)==0 ){
+    if( nArg==2 ){
+      p->vmstepsOn = booleanValue(azArg[1]);
+    }else{
+      raw_printf(stderr, "Usage: .vmsteps ?on|off?\n");
+      rc = 1;
+    }
+  }else
+
+
 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
  if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
    sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
@@ -259,7 +259,11 @@ typedef struct sqlite3 sqlite3;
 */
 #ifdef SQLITE_INT64_TYPE
  typedef SQLITE_INT64_TYPE sqlite_int64;
-  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
+# ifdef SQLITE_UINT64_TYPE
+    typedef SQLITE_UINT64_TYPE sqlite_uint64;
+# else  
+    typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
+# endif
 #elif defined(_MSC_VER) || defined(__BORLANDC__)
  typedef __int64 sqlite_int64;
  typedef unsigned __int64 sqlite_uint64;
@@ -3896,8 +3900,12 @@ int sqlite3_clear_bindings(sqlite3_stmt*);
 ** METHOD: sqlite3_stmt
 **
 ** ^Return the number of columns in the result set returned by the
-** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
-** statement that does not return data (for example an [UPDATE]).
+** [prepared statement]. ^If this routine returns 0, that means the 
+** [prepared statement] returns no data (for example an [UPDATE]).
+** ^However, just because this routine returns a positive number does not
+** mean that one or more rows of data will be returned.  ^A SELECT statement
+** will always have a positive sqlite3_column_count() but depending on the
+** WHERE clause constraints and the table content, it might return no rows.
 **
 ** See also: [sqlite3_data_count()]
 */
@@ -111,7 +111,7 @@
 #endif

 /* What version of CLANG is being used.  0 means CLANG is not being used */
-#ifdef __clang__
+#if defined(__clang__) && !defined(_WIN32)
 # define CLANG_VERSION \
            (__clang_major__*1000000+__clang_minor__*1000+__clang_patchlevel__)
 #else
@@ -511,6 +511,18 @@
 #include <assert.h>
 #include <stddef.h>

+/*
+** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
+** This allows better measurements of where memcpy() is used when running
+** cachegrind.  But this macro version of memcpy() is very slow so it
+** should not be used in production.  This is a performance measurement
+** hack only.
+*/
+#ifdef SQLITE_INLINE_MEMCPY
+# define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
+                        int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
+#endif
+
 /*
 ** If compiling for a processor that lacks floating point support,
 ** substitute integer for floating-point
@@ -3041,7 +3053,7 @@ struct AuthContext {
 #define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */
                                     /* Also used in P2 (not P5) of OP_Delete */
 #define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */
-#define OPFLAG_LASTROWID     0x02    /* Set to update db->lastRowid */
+#define OPFLAG_LASTROWID     0x20    /* Set to update db->lastRowid */
 #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
 #define OPFLAG_APPEND        0x08    /* This is likely to be an append */
 #define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */
@@ -3055,7 +3067,7 @@ struct AuthContext {
 #define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */
 #define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */
 #define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
-#define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete: keep cursor position */
+#define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete/Insert: save cursor pos */
 #define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */

 /*
@@ -3716,7 +3728,7 @@ void sqlite3ExprCacheAffinityChange(Parse*, int, int);
 void sqlite3ExprCode(Parse*, Expr*, int);
 void sqlite3ExprCodeCopy(Parse*, Expr*, int);
 void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
-void sqlite3ExprCodeAtInit(Parse*, Expr*, int, u8);
+int sqlite3ExprCodeAtInit(Parse*, Expr*, int);
 int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
 int sqlite3ExprCodeTarget(Parse*, Expr*, int);
 void sqlite3ExprCodeAndCache(Parse*, Expr*, int);
@@ -17,8 +17,6 @@
 ** if they are not used.
 */
 #include "sqliteInt.h"
-#include <stdlib.h>
-#include <string.h>

 #ifndef SQLITE_OMIT_GET_TABLE

@@ -2307,7 +2307,7 @@ static int SQLITE_TCLAPI DbObjCmd(
    }
    in = fopen(zFile, "rb");
    if( in==0 ){
-      Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, NULL);
+      Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, (char*)0);
      sqlite3_finalize(pStmt);
      return TCL_ERROR;
    }
@@ -2536,7 +2536,7 @@ static int SQLITE_TCLAPI DbObjCmd(
      int n = strlen30(z);
      if( n>2 && strncmp(z, "-argcount",n)==0 ){
        if( i==(objc-2) ){
-          Tcl_AppendResult(interp, "option requires an argument: ", z, 0);
+          Tcl_AppendResult(interp, "option requires an argument: ", z,(char*)0);
          return TCL_ERROR;
        }
        if( Tcl_GetIntFromObj(interp, objv[i+1], &nArg) ) return TCL_ERROR;
@@ -2551,7 +2551,7 @@ static int SQLITE_TCLAPI DbObjCmd(
        flags |= SQLITE_DETERMINISTIC;
      }else{
        Tcl_AppendResult(interp, "bad option \"", z,
-            "\": must be -argcount or -deterministic", 0
+            "\": must be -argcount or -deterministic", (char*)0
        );
        return TCL_ERROR;
      }
@@ -3208,7 +3208,7 @@ static int SQLITE_TCLAPI DbObjCmd(
          pObj = Tcl_NewStringObj((char*)sqlite3_value_text(pValue), -1);
          Tcl_SetObjResult(interp, pObj);
        }else{
-          Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), 0);
+          Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);
          return TCL_ERROR;
        }
      }
@@ -313,7 +313,7 @@ static void sqllogCopydb(struct SLConn *p, const char *zSearch, int bLog){

      /* Generate a file-name to use for the copy of this database */
      iDb = sqllogglobal.iNextDb++;
-      zInit = sqlite3_mprintf("%s_%d.db", sqllogglobal.zPrefix, iDb);
+      zInit = sqlite3_mprintf("%s_%02d.db", sqllogglobal.zPrefix, iDb);

      /* Create the backup */
      assert( sqllogglobal.bRec==0 );
@@ -376,7 +376,7 @@ static void sqllogOpenlog(struct SLConn *p){
      char *zVar = getenv(ENVIRONMENT_VARIABLE1_NAME);
      if( zVar==0 || strlen(zVar)+10>=(sizeof(sqllogglobal.zPrefix)) ) return;
      sqlite3_snprintf(sizeof(sqllogglobal.zPrefix), sqllogglobal.zPrefix,
-                        "%s/sqllog_%d", zVar, getProcessId());
+                        "%s/sqllog_%05d", zVar, getProcessId());
      sqlite3_snprintf(sizeof(sqllogglobal.zIdx), sqllogglobal.zIdx,
                        "%s.idx", sqllogglobal.zPrefix);
      if( getenv(ENVIRONMENT_VARIABLE2_NAME) ){
@@ -387,7 +387,7 @@ static void sqllogOpenlog(struct SLConn *p){
    }

    /* Open the log file */
-    zLog = sqlite3_mprintf("%s_%d.sql", sqllogglobal.zPrefix, p->iLog);
+    zLog = sqlite3_mprintf("%s_%05d.sql", sqllogglobal.zPrefix, p->iLog);
    p->fd = fopen(zLog, "w");
    sqlite3_free(zLog);
    if( p->fd==0 ){
@@ -63,6 +63,7 @@ LPDIR opendir(
    dirname = windirent_getenv("SystemDrive");
  }

+  memset(&data, 0, sizeof(struct _finddata_t));
  _snprintf(data.name, namesize, "%s\\*", dirname);
  dirp->d_handle = _findfirst(data.name, &data);

@@ -71,12 +72,18 @@ LPDIR opendir(
    return NULL;
  }

-  /* TODO: Remove this block to allow hidden and system files. */
-  if( data.attrib&_A_HIDDEN || data.attrib&_A_SYSTEM ){
+  /* TODO: Remove this block to allow hidden and/or system files. */
+  if( is_filtered(data) ){
+next:
+
+    memset(&data, 0, sizeof(struct _finddata_t));
    if( _findnext(dirp->d_handle, &data)==-1 ){
      closedir(dirp);
      return NULL;
    }
+
+    /* TODO: Remove this block to allow hidden and/or system files. */
+    if( is_filtered(data) ) goto next;
  }

  dirp->d_first.d_attributes = data.attrib;
@@ -105,11 +112,11 @@ LPDIRENT readdir(

 next:

+  memset(&data, 0, sizeof(struct _finddata_t));
  if( _findnext(dirp->d_handle, &data)==-1 ) return NULL;

-  /* TODO: Remove this block to allow hidden and system files. */
-  if( data.attrib&_A_HIDDEN ) goto next;
-  if( data.attrib&_A_SYSTEM ) goto next;
+  /* TODO: Remove this block to allow hidden and/or system files. */
+  if( is_filtered(data) ) goto next;

  dirp->d_next.d_ino++;
  dirp->d_next.d_attributes = data.attrib;
@@ -146,14 +153,14 @@ INT readdir_r(

 next:

+  memset(&data, 0, sizeof(struct _finddata_t));
  if( _findnext(dirp->d_handle, &data)==-1 ){
    *result = NULL;
    return ENOENT;
  }

-  /* TODO: Remove this block to allow hidden and system files. */
-  if( data.attrib&_A_HIDDEN ) goto next;
-  if( data.attrib&_A_SYSTEM ) goto next;
+  /* TODO: Remove this block to allow hidden and/or system files. */
+  if( is_filtered(data) ) goto next;

  entry->d_ino = (ino_t)-1; /* not available */
  entry->d_attributes = data.attrib;
@@ -92,6 +92,17 @@ struct DIR {
  DIRENT d_next;     /* DIRENT constructed based on "_findnext". */
 };

+/*
+** Provide a macro, for use by the implementation, to determine if a
+** particular directory entry should be skipped over when searching for
+** the next directory entry that should be returned by the readdir() or
+** readdir_r() functions.
+*/
+
+#ifndef is_filtered
+#  define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM))
+#endif
+
 /*
 ** Provide the function prototype for the POSIX compatiable getenv()
 ** function.  This function is not thread-safe.
@@ -71,12 +71,12 @@ void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
    if( pValue ){
      sqlite3VdbeAppendP4(v, pValue, P4_MEM);
    }
-#ifndef SQLITE_OMIT_FLOATING_POINT
-    if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
-      sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
-    }
-#endif
  }
+#ifndef SQLITE_OMIT_FLOATING_POINT
+  if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
+    sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
+  }
+#endif
 }

 /*
@@ -105,7 +105,7 @@ void sqlite3Update(
  int iDataCur;          /* Cursor for the canonical data btree */
  int iIdxCur;           /* Cursor for the first index */
  sqlite3 *db;           /* The database structure */
-  int *aRegIdx = 0;      /* One register assigned to each index to be updated */
+  int *aRegIdx = 0;      /* First register in array assigned to each index */
  int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
                         ** an expression for the i-th column of the table.
                         ** aXRef[i]==-1 if the i-th column is not changed. */
@@ -117,10 +117,11 @@ void sqlite3Update(
  AuthContext sContext;  /* The authorization context */
  NameContext sNC;       /* The name-context to resolve expressions in */
  int iDb;               /* Database containing the table being updated */
-  int okOnePass;         /* True for one-pass algorithm without the FIFO */
+  int eOnePass;          /* ONEPASS_XXX value from where.c */
  int hasFK;             /* True if foreign key processing is required */
  int labelBreak;        /* Jump here to break out of UPDATE loop */
  int labelContinue;     /* Jump here to continue next step of UPDATE loop */
+  int flags;             /* Flags for sqlite3WhereBegin() */

 #ifndef SQLITE_OMIT_TRIGGER
  int isView;            /* True when updating a view (INSTEAD OF trigger) */
@@ -131,6 +132,10 @@ void sqlite3Update(
  int iEph = 0;          /* Ephemeral table holding all primary key values */
  int nKey = 0;          /* Number of elements in regKey for WITHOUT ROWID */
  int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
+  int addrOpen = 0;      /* Address of OP_OpenEphemeral */
+  int iPk = 0;           /* First of nPk cells holding PRIMARY KEY value */
+  i16 nPk = 0;           /* Number of components of the PRIMARY KEY */
+  int bReplace = 0;      /* True if REPLACE conflict resolution might happen */

  /* Register Allocations */
  int regRowCount = 0;   /* A count of rows changed */
@@ -290,6 +295,11 @@ void sqlite3Update(
        if( iIdxCol<0 || aXRef[iIdxCol]>=0 ){
          reg = ++pParse->nMem;
          pParse->nMem += pIdx->nColumn;
+          if( (onError==OE_Replace)
+           || (onError==OE_Default && pIdx->onError==OE_Replace) 
+          ){
+            bReplace = 1;
+          }
          break;
        }
      }
@@ -297,6 +307,11 @@ void sqlite3Update(
    if( reg==0 ) aToOpen[j+1] = 0;
    aRegIdx[j] = reg;
  }
+  if( bReplace ){
+    /* If REPLACE conflict resolution might be invoked, open cursors on all 
+    ** indexes in case they are needed to delete records.  */
+    memset(aToOpen, 1, nIdx+1);
+  }

  /* Begin generating code. */
  v = sqlite3GetVdbe(pParse);
@@ -349,51 +364,79 @@ void sqlite3Update(
  }
 #endif

-  /* Begin the database scan
-  */
+  /* Initialize the count of updated rows */
+  if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
+    regRowCount = ++pParse->nMem;
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
+  }
+
  if( HasRowid(pTab) ){
    sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
-    pWInfo = sqlite3WhereBegin(
-        pParse, pTabList, pWhere, 0, 0,
-            WHERE_ONEPASS_DESIRED | WHERE_SEEK_TABLE, iIdxCur
-    );
-    if( pWInfo==0 ) goto update_cleanup;
-    okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
-  
-    /* Remember the rowid of every item to be updated.
-    */
-    sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
-    if( !okOnePass ){
-      sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
-    }
-  
-    /* End the database scan loop.
-    */
-    sqlite3WhereEnd(pWInfo);
  }else{
-    int iPk;         /* First of nPk memory cells holding PRIMARY KEY value */
-    i16 nPk;         /* Number of components of the PRIMARY KEY */
-    int addrOpen;    /* Address of the OpenEphemeral instruction */
-
    assert( pPk!=0 );
    nPk = pPk->nKeyCol;
    iPk = pParse->nMem+1;
    pParse->nMem += nPk;
    regKey = ++pParse->nMem;
    iEph = pParse->nTab++;
+
    sqlite3VdbeAddOp2(v, OP_Null, 0, iPk);
    addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
    sqlite3VdbeSetP4KeyInfo(pParse, pPk);
-    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, 
-                               WHERE_ONEPASS_DESIRED, iIdxCur);
-    if( pWInfo==0 ) goto update_cleanup;
-    okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
+  }
+
+  /* Begin the database scan. 
+  **
+  ** Do not consider a single-pass strategy for a multi-row update if
+  ** there are any triggers or foreign keys to process, or rows may
+  ** be deleted as a result of REPLACE conflict handling. Any of these
+  ** things might disturb a cursor being used to scan through the table
+  ** or index, causing a single-pass approach to malfunction.  */
+  flags = WHERE_ONEPASS_DESIRED | WHERE_SEEK_TABLE;
+  if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
+    flags |= WHERE_ONEPASS_MULTIROW;
+  }
+  pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags, iIdxCur);
+  if( pWInfo==0 ) goto update_cleanup;
+
+  /* A one-pass strategy that might update more than one row may not
+  ** be used if any column of the index used for the scan is being
+  ** updated. Otherwise, if there is an index on "b", statements like
+  ** the following could create an infinite loop:
+  **
+  **   UPDATE t1 SET b=b+1 WHERE b>?
+  **
+  ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
+  ** strategy that uses an index for which one or more columns are being
+  ** updated.  */
+  eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
+  if( eOnePass==ONEPASS_MULTI ){
+    int iCur = aiCurOnePass[1];
+    if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
+      eOnePass = ONEPASS_OFF;
+    }
+    assert( iCur!=iDataCur || !HasRowid(pTab) );
+  }
+  
+  if( HasRowid(pTab) ){
+    /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
+    ** mode, write the rowid into the FIFO. In either of the one-pass modes,
+    ** leave it in register regOldRowid.  */
+    sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
+    if( eOnePass==ONEPASS_OFF ){
+      sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
+    }
+  }else{
+    /* Read the PK of the current row into an array of registers. In
+    ** ONEPASS_OFF mode, serialize the array into a record and store it in
+    ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
+    ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table 
+    ** is not required) and leave the PK fields in the array of registers.  */
    for(i=0; i<nPk; i++){
      assert( pPk->aiColumn[i]>=0 );
-      sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i],
-                                      iPk+i);
+      sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,pPk->aiColumn[i],iPk+i);
    }
-    if( okOnePass ){
+    if( eOnePass ){
      sqlite3VdbeChangeToNoop(v, addrOpen);
      nKey = nPk;
      regKey = iPk;
@@ -402,50 +445,42 @@ void sqlite3Update(
                        sqlite3IndexAffinityStr(db, pPk), nPk);
      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
    }
-    sqlite3WhereEnd(pWInfo);
  }

-  /* Initialize the count of updated rows
-  */
-  if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
-    regRowCount = ++pParse->nMem;
-    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
+  if( eOnePass!=ONEPASS_MULTI ){
+    sqlite3WhereEnd(pWInfo);
  }

  labelBreak = sqlite3VdbeMakeLabel(v);
  if( !isView ){
-    /* 
-    ** Open every index that needs updating.  Note that if any
-    ** index could potentially invoke a REPLACE conflict resolution 
-    ** action, then we need to open all indices because we might need
-    ** to be deleting some records.
-    */
-    if( onError==OE_Replace ){
-      memset(aToOpen, 1, nIdx+1);
-    }else{
-      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-        if( pIdx->onError==OE_Replace ){
-          memset(aToOpen, 1, nIdx+1);
-          break;
-        }
-      }
-    }
-    if( okOnePass ){
+    int addrOnce = 0;
+
+    /* Open every index that needs updating. */
+    if( eOnePass!=ONEPASS_OFF ){
      if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
      if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
    }
+
+    if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
+      addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
+    }
    sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, aToOpen,
                               0, 0);
+    if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
  }

  /* Top of the update loop */
-  if( okOnePass ){
-    if( aToOpen[iDataCur-iBaseCur] && !isView ){
+  if( eOnePass!=ONEPASS_OFF ){
+    if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){
      assert( pPk );
      sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey);
      VdbeCoverageNeverTaken(v);
    }
-    labelContinue = labelBreak;
+    if( eOnePass==ONEPASS_SINGLE ){
+      labelContinue = labelBreak;
+    }else{
+      labelContinue = sqlite3VdbeMakeLabel(v);
+    }
    sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
    VdbeCoverageIf(v, pPk==0);
    VdbeCoverageIf(v, pPk!=0);
@@ -570,7 +605,6 @@ void sqlite3Update(

  if( !isView ){
    int addr1 = 0;        /* Address of jump instruction */
-    int bReplace = 0;     /* True if REPLACE conflict resolution might happen */

    /* Do constraint checks. */
    assert( regOldRowid>0 );
@@ -606,14 +640,18 @@ void sqlite3Update(
    assert( regNew==regNewRowid+1 );
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
-        OPFLAG_ISUPDATE | ((hasFK || chngKey || pPk!=0) ? 0 : OPFLAG_ISNOOP),
+        OPFLAG_ISUPDATE | ((hasFK || chngKey) ? 0 : OPFLAG_ISNOOP),
        regNewRowid
    );
+    if( eOnePass==ONEPASS_MULTI ){
+      assert( hasFK==0 && chngKey==0 );
+      sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
+    }
    if( !pParse->nested ){
      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
    }
 #else
-    if( hasFK || chngKey || pPk!=0 ){
+    if( hasFK || chngKey ){
      sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
    }
 #endif
@@ -626,8 +664,11 @@ void sqlite3Update(
    }
  
    /* Insert the new index entries and the new record. */
-    sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
-                             regNewRowid, aRegIdx, 1, 0, 0);
+    sqlite3CompleteInsertion(
+        pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx, 
+        OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0), 
+        0, 0
+    );

    /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
    ** handle rows (possibly in other tables) that refer via a foreign key
@@ -649,8 +690,11 @@ void sqlite3Update(
  /* Repeat the above with the next record to be updated, until
  ** all record selected by the WHERE clause have been updated.
  */
-  if( okOnePass ){
+  if( eOnePass==ONEPASS_SINGLE ){
    /* Nothing to do at end-of-loop for a single-pass */
+  }else if( eOnePass==ONEPASS_MULTI ){
+    sqlite3VdbeResolveLabel(v, labelContinue);
+    sqlite3WhereEnd(pWInfo);
  }else if( pPk ){
    sqlite3VdbeResolveLabel(v, labelContinue);
    sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
@@ -960,6 +960,25 @@ case OP_Halt: {
    p->nFrame--;
    sqlite3VdbeSetChanges(db, p->nChange);
    pcx = sqlite3VdbeFrameRestore(pFrame);
+#ifdef SQLITE_TRACE_TRIGGER
+    if( (db->mTrace & SQLITE_TRACE_STMT) && aOp[0].p4.z ){
+      int nTotal = nVmStep - pFrame->nVmStep;
+      char *zTrace;
+      assert( nTotal>=0 );
+      assert( db->xTrace );
+      zTrace = sqlite3_mprintf("%.*s%s completed (VM steps: total=%d self=%d)", 
+          p->nFrame, "                                                    :",
+          aOp[0].p4.z, nTotal, nVmStep - pFrame->nVmStepAdj
+      );
+      if( zTrace ){
+        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, 0, zTrace);
+        sqlite3_free(zTrace);
+      }
+      if( p->pFrame ){
+        p->pFrame->nVmStepAdj += nTotal;
+      }
+    }
+#endif
    lastRowid = db->lastRowid;
    if( pOp->p2==OE_Ignore ){
      /* Instruction pcx is the OP_Program that invoked the sub-program 
@@ -1195,7 +1214,7 @@ case OP_Variable: {            /* out2 */
  if( sqlite3VdbeMemTooBig(pVar) ){
    goto too_big;
  }
-  pOut = out2Prerelease(p, pOp);
+  pOut = &aMem[pOp->p2];
  sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static);
  UPDATE_MAX_BLOBSIZE(pOut);
  break;
@@ -4421,7 +4440,7 @@ case OP_InsertInt: {
  }
  x.pKey = 0;
  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
-                          (pOp->p5 & OPFLAG_APPEND)!=0, seekResult
+      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult
  );
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;
@@ -4632,7 +4651,7 @@ case OP_SorterData: {
  break;
 }

-/* Opcode: RowData P1 P2 * * *
+/* Opcode: RowData P1 P2 P3 * *
 ** Synopsis: r[P2]=data
 **
 ** Write into register P2 the complete row content for the row at 
@@ -4646,14 +4665,26 @@ case OP_SorterData: {
 **
 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
 ** of a real table, not a pseudo-table.
+**
+** If P3!=0 then this opcode is allowed to make an ephermeral pointer
+** into the database page.  That means that the content of the output
+** register will be invalidated as soon as the cursor moves - including
+** moves caused by other cursors that "save" the the current cursors
+** position in order that they can write to the same table.  If P3==0
+** then a copy of the data is made into memory.  P3!=0 is faster, but
+** P3==0 is safer.
+**
+** If P3!=0 then the content of the P2 register is unsuitable for use
+** in OP_Result and any OP_Result will invalidate the P2 register content.
+** The P2 register content is invalidated by opcodes like OP_Function or
+** by any use of another cursor pointing to the same table.
 */
 case OP_RowData: {
  VdbeCursor *pC;
  BtCursor *pCrsr;
  u32 n;

-  pOut = &aMem[pOp->p2];
-  memAboutToChange(p, pOut);
+  pOut = out2Prerelease(p, pOp);

  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
@@ -4684,14 +4715,9 @@ case OP_RowData: {
    goto too_big;
  }
  testcase( n==0 );
-  if( sqlite3VdbeMemClearAndResize(pOut, MAX(n,32)) ){
-    goto no_mem;
-  }
-  pOut->n = n;
-  MemSetTypeFlag(pOut, MEM_Blob);
-  rc = sqlite3BtreePayload(pCrsr, 0, n, pOut->z);
+  rc = sqlite3VdbeMemFromBtree(pCrsr, 0, n, pOut);
  if( rc ) goto abort_due_to_error;
-  pOut->enc = SQLITE_UTF8;  /* In case the blob is ever cast to text */
+  if( !pOp->p3 ) Deephemeralize(pOut);
  UPDATE_MAX_BLOBSIZE(pOut);
  REGISTER_TRACE(pOp->p2, pOut);
  break;
@@ -5079,7 +5105,7 @@ case OP_IdxInsert: {        /* in2 */
    x.aMem = aMem + pOp->p3;
    x.nMem = (u16)pOp->p4.i;
    rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
-         (pOp->p5 & OPFLAG_APPEND)!=0, 
+         (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), 
        ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
        );
    assert( pC->deferredMoveto==0 );
@@ -5201,7 +5227,6 @@ case OP_IdxRowid: {              /* out2 */
    }else{
      pOut = out2Prerelease(p, pOp);
      pOut->u.i = rowid;
-      pOut->flags = MEM_Int;
    }
  }else{
    assert( pOp->opcode==OP_IdxRowid );
@@ -5848,6 +5873,10 @@ case OP_Program: {        /* jump */
  pFrame->nDbChange = p->db->nChange;
  assert( pFrame->pAuxData==0 );
  pFrame->pAuxData = p->pAuxData;
+#ifdef SQLITE_TRACE_TRIGGER
+  pFrame->nVmStep = nVmStep;
+  pFrame->nVmStepAdj = nVmStep;
+#endif
  p->pAuxData = 0;
  p->nChange = 0;
  p->pFrame = pFrame;
@@ -6883,6 +6912,17 @@ case OP_Init: {          /* jump */
      x(db->pTraceArg, z);
      sqlite3_free(z);
    }else
+#endif
+#ifdef SQLITE_TRACE_TRIGGER
+    if( p->pFrame ){
+      zTrace = sqlite3_mprintf("%.*s%s", p->nFrame-1, 
+          "                                                    :", zTrace
+      );
+      if( zTrace ){
+        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
+        sqlite3_free(zTrace);
+      }
+    }else
 #endif
    {
      (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
@@ -183,8 +183,10 @@ int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
 void sqlite3VdbeEndCoroutine(Vdbe*,int);
 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
  void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N);
+  void sqlite3VdbeVerifyNoResultRow(Vdbe *p);
 #else
 # define sqlite3VdbeVerifyNoMallocRequired(A,B)
+# define sqlite3VdbeVerifyNoResultRow(A)
 #endif
 VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp, int iLineno);
 void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
@@ -175,6 +175,10 @@ struct VdbeFrame {
  int nChildCsr;          /* Number of cursors for child frame */
  int nChange;            /* Statement changes (Vdbe.nChange)     */
  int nDbChange;          /* Value of db->nChange */
+#ifdef SQLITE_TRACE_TRIGGER
+  int nVmStep;            /* Value of nVmStep at start of program */
+  int nVmStepAdj;         /* Adjusted for nested programs */
+#endif
 };

 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
@@ -648,6 +648,22 @@ void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){
 }
 #endif

+/*
+** Verify that the VM passed as the only argument does not contain
+** an OP_ResultRow opcode. Fail an assert() if it does. This is used
+** by code in pragma.c to ensure that the implementation of certain
+** pragmas comports with the flags specified in the mkpragmatab.tcl
+** script.
+*/
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
+void sqlite3VdbeVerifyNoResultRow(Vdbe *p){
+  int i;
+  for(i=0; i<p->nOp; i++){
+    assert( p->aOp[i].opcode!=OP_ResultRow );
+  }
+}
+#endif
+
 /*
 ** This function returns a pointer to the array of opcodes associated with
 ** the Vdbe passed as the first argument. It is the callers responsibility
@@ -23,10 +23,10 @@
 */
 typedef struct Incrblob Incrblob;
 struct Incrblob {
-  int flags;              /* Copy of "flags" passed to sqlite3_blob_open() */
  int nByte;              /* Size of open blob, in bytes */
  int iOffset;            /* Byte offset of blob in cursor data */
-  int iCol;               /* Table column this handle is open on */
+  u16 iCol;               /* Table column this handle is open on */
+  u8 isPureKV;            /* True if pTab is a pure key/value table */
  BtCursor *pCsr;         /* Cursor pointing at blob row */
  sqlite3_stmt *pStmt;    /* Statement holding cursor open */
  sqlite3 *db;            /* The associated database */
@@ -57,12 +57,17 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){
  char *zErr = 0;                 /* Error message */
  Vdbe *v = (Vdbe *)p->pStmt;

-  /* Set the value of the SQL statements only variable to integer iRow. 
-  ** This is done directly instead of using sqlite3_bind_int64() to avoid 
-  ** triggering asserts related to mutexes.
+  /* Set the value of register r[1] in the SQL statement to integer iRow. 
+  ** This is done directly as a performance optimization
  */
-  assert( v->aVar[0].flags&MEM_Int );
-  v->aVar[0].u.i = iRow;
+  v->aMem[1].flags = MEM_Int;
+  v->aMem[1].u.i = iRow;
+
+  /* If the statement has been run before (and is paused at the OP_ResultRow)
+  ** then back it up to the point where it does the OP_SeekRowid.  This could
+  ** have been down with an extra OP_Goto, but simply setting the program
+  ** counter is faster. */
+  if( v->pc>3 ) v->pc = 3;

  rc = sqlite3_step(p->pStmt);
  if( rc==SQLITE_ROW ){
@@ -112,7 +117,7 @@ int sqlite3_blob_open(
  const char *zTable,     /* The table containing the blob */
  const char *zColumn,    /* The column containing the blob */
  sqlite_int64 iRow,      /* The row containing the glob */
-  int flags,              /* True -> read/write access, false -> read-only */
+  int wrFlag,             /* True -> read/write access, false -> read-only */
  sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
 ){
  int nAttempt = 0;
@@ -134,7 +139,7 @@ int sqlite3_blob_open(
    return SQLITE_MISUSE_BKPT;
  }
 #endif
-  flags = !!flags;                /* flags = (flags ? 1 : 0); */
+  wrFlag = !!wrFlag;                /* wrFlag = (wrFlag ? 1 : 0); */

  sqlite3_mutex_enter(db->mutex);

@@ -194,9 +199,8 @@ int sqlite3_blob_open(

    /* If the value is being opened for writing, check that the
    ** column is not indexed, and that it is not part of a foreign key. 
-    ** It is against the rules to open a column to which either of these
-    ** descriptions applies for writing.  */
-    if( flags ){
+    */
+    if( wrFlag ){
      const char *zFault = 0;
      Index *pIdx;
 #ifndef SQLITE_OMIT_FOREIGN_KEY
@@ -257,18 +261,17 @@ int sqlite3_blob_open(
      static const VdbeOpList openBlob[] = {
        {OP_TableLock,      0, 0, 0},  /* 0: Acquire a read or write lock */
        {OP_OpenRead,       0, 0, 0},  /* 1: Open a cursor */
-        {OP_Variable,       1, 1, 0},  /* 2: Move ?1 into reg[1] */
-        {OP_NotExists,      0, 7, 1},  /* 3: Seek the cursor */
-        {OP_Column,         0, 0, 1},  /* 4  */
-        {OP_ResultRow,      1, 0, 0},  /* 5  */
-        {OP_Goto,           0, 2, 0},  /* 6  */
-        {OP_Halt,           0, 0, 0},  /* 7  */
+        /* blobSeekToRow() will initialize r[1] to the desired rowid */
+        {OP_NotExists,      0, 5, 1},  /* 2: Seek the cursor to rowid=r[1] */
+        {OP_Column,         0, 0, 1},  /* 3  */
+        {OP_ResultRow,      1, 0, 0},  /* 4  */
+        {OP_Halt,           0, 0, 0},  /* 5  */
      };
      Vdbe *v = (Vdbe *)pBlob->pStmt;
      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      VdbeOp *aOp;

-      sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags, 
+      sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag, 
                           pTab->pSchema->schema_cookie,
                           pTab->pSchema->iGeneration);
      sqlite3VdbeChangeP5(v, 1);     
@@ -285,7 +288,7 @@ int sqlite3_blob_open(
 #else
        aOp[0].p1 = iDb;
        aOp[0].p2 = pTab->tnum;
-        aOp[0].p3 = flags;
+        aOp[0].p3 = wrFlag;
        sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
      }
      if( db->mallocFailed==0 ){
@@ -293,7 +296,7 @@ int sqlite3_blob_open(

        /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
        ** parameter of the other to pTab->tnum.  */
-        if( flags ) aOp[1].opcode = OP_OpenWrite;
+        if( wrFlag ) aOp[1].opcode = OP_OpenWrite;
        aOp[1].p2 = pTab->tnum;
        aOp[1].p3 = iDb;   

@@ -306,23 +309,22 @@ int sqlite3_blob_open(
        */
        aOp[1].p4type = P4_INT32;
        aOp[1].p4.i = pTab->nCol+1;
-        aOp[4].p2 = pTab->nCol;
+        aOp[3].p2 = pTab->nCol;

-        pParse->nVar = 1;
+        pParse->nVar = 0;
        pParse->nMem = 1;
        pParse->nTab = 1;
        sqlite3VdbeMakeReady(v, pParse);
      }
    }
   
-    pBlob->flags = flags;
+    pBlob->isPureKV = (pTab->nCol==2 && pTab->iPKey==0);
    pBlob->iCol = iCol;
    pBlob->db = db;
    sqlite3BtreeLeaveAll(db);
    if( db->mallocFailed ){
      goto blob_open_out;
    }
-    sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
    rc = blobSeekToRow(pBlob, iRow, &zErr);
  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );

@@ -1010,6 +1010,7 @@ static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
  assert( (pVal->flags & MEM_RowSet)==0 );
  assert( (pVal->flags & (MEM_Null))==0 );
  if( pVal->flags & (MEM_Blob|MEM_Str) ){
+    if( ExpandBlob(pVal) ) return 0;
    pVal->flags |= MEM_Str;
    if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
      sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
@@ -4949,7 +4949,8 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
            pOp->p2 = x;
            pOp->p1 = pLevel->iIdxCur;
          }
-          assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 );
+          assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 
+              || pWInfo->eOnePass );
        }else if( pOp->opcode==OP_Rowid ){
          pOp->p1 = pLevel->iIdxCur;
          pOp->opcode = OP_IdxRowid;
@@ -913,6 +913,7 @@ static void exprAnalyze(
  Parse *pParse = pWInfo->pParse;  /* Parsing context */
  sqlite3 *db = pParse->db;        /* Database connection */
  unsigned char eOp2;              /* op2 value for LIKE/REGEXP/GLOB */
+  int nLeft;                       /* Number of elements on left side vector */

  if( db->mallocFailed ){
    return;
@@ -942,6 +943,10 @@ static void exprAnalyze(
    prereqAll |= x;
    extraRight = x-1;  /* ON clause terms may not be used with an index
                       ** on left table of a LEFT JOIN.  Ticket #3015 */
+    if( (prereqAll>>1)>=x ){
+      sqlite3ErrorMsg(pParse, "ON clause references tables to its right");
+      return;
+    }
  }
  pTerm->prereqAll = prereqAll;
  pTerm->leftCursor = -1;
@@ -1184,13 +1189,12 @@ static void exprAnalyze(
  ** is not a sub-select.  */
  if( pWC->op==TK_AND 
  && (pExpr->op==TK_EQ || pExpr->op==TK_IS)
-  && sqlite3ExprIsVector(pExpr->pLeft)
+  && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
+  && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
  && ( (pExpr->pLeft->flags & EP_xIsSelect)==0 
-    || (pExpr->pRight->flags & EP_xIsSelect)==0
-  )){
-    int nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
+    || (pExpr->pRight->flags & EP_xIsSelect)==0)
+  ){
    int i;
-    assert( nLeft==sqlite3ExprVectorSize(pExpr->pRight) );
    for(i=0; i<nLeft; i++){
      int idxNew;
      Expr *pNew;
@@ -0,0 +1,91 @@
+# 2017-01-16
+#
+# 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 cases for bugs:
+#
+#    https://www.sqlite.org/src/info/91e2e8ba6ff2e2
+#    https://www.sqlite.org/src/info/7ffd1ca1d2ad4ecf
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Ticket https://www.sqlite.org/src/info/91e2e8ba6ff2e2 (2011-09-19)
+# Automatic index causes undesired type conversions
+#
+do_execsql_test affinity3-100 {
+  CREATE TABLE customer (id INT PRIMARY KEY);
+  CREATE TABLE apr (id INT PRIMARY KEY, apr REAL);
+  
+  CREATE VIEW v1 AS
+  SELECT c.id, i.apr
+  FROM customer c
+  LEFT JOIN apr i ON i.id=c.id;
+  
+  CREATE VIEW v2 AS
+  SELECT c.id, v1.apr
+  FROM customer c
+  LEFT JOIN v1 ON v1.id=c.id;
+  
+  INSERT INTO customer (id) VALUES (1);
+  INSERT INTO apr (id, apr) VALUES (1, 12);
+  INSERT INTO customer (id) VALUES (2);
+  INSERT INTO apr (id, apr) VALUES (2, 12.01);
+}
+do_execsql_test affinity3-110 {
+  PRAGMA automatic_index=ON;
+  SELECT id, (apr / 100), typeof(apr) apr_type  FROM v1;
+} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-120 {
+  SELECT id, (apr / 100), typeof(apr) apr_type  FROM v2;
+} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-130 {
+  PRAGMA automatic_index=OFF;
+  SELECT id, (apr / 100), typeof(apr) apr_type  FROM v1;
+} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-140 {
+  SELECT id, (apr / 100), typeof(apr) apr_type  FROM v2;
+} {1 0.12 real 2 0.1201 real}
+
+# Ticket https://www.sqlite.org/src/info/7ffd1ca1d2ad4ecf  (2017-01-16)
+# Incorrect affinity when using automatic indexes 
+#
+do_execsql_test affinity3-200 {
+  CREATE TABLE map_integer (id INT, name);
+  INSERT INTO map_integer VALUES(1,'a');
+  CREATE TABLE map_text (id TEXT, name);
+  INSERT INTO map_text VALUES('4','e');
+  CREATE TABLE data (id TEXT, name);
+  INSERT INTO data VALUES(1,'abc');
+  INSERT INTO data VALUES('4','xyz');
+  CREATE VIEW idmap as
+      SELECT * FROM map_integer
+      UNION SELECT * FROM map_text;
+  CREATE TABLE mzed AS SELECT * FROM idmap;
+}
+
+do_execsql_test affinity3-210 {
+  PRAGMA automatic_index=ON;
+  SELECT * FROM data JOIN idmap USING(id);
+} {1 abc a 4 xyz e}
+do_execsql_test affinity3-220 {
+  SELECT * FROM data JOIN mzed USING(id);
+} {1 abc a 4 xyz e}
+
+do_execsql_test affinity3-250 {
+  PRAGMA automatic_index=OFF;
+  SELECT * FROM data JOIN idmap USING(id);
+} {1 abc a 4 xyz e}
+do_execsql_test affinity3-260 {
+  SELECT * FROM data JOIN mzed USING(id);
+} {1 abc a 4 xyz e}
+
+finish_test
@@ -91,10 +91,12 @@ do_extract_hints_test 1.6 {
  t2 {EQ(r[2],c0)} t3 {EQ(r[6],c1)}
 }

-do_extract_hints_test 1.7 {
-  SELECT * FROM t1 LEFT JOIN t2 ON (a=c AND d=e) LEFT JOIN t3 ON (d=f);
-} {
-  t2 {EQ(r[2],c0)} t3 {AND(EQ(r[6],c0),EQ(r[7],c1))}
+if 0 {
+  do_extract_hints_test 1.7 {
+    SELECT * FROM t1 LEFT JOIN t2 ON (a=c AND d=e) LEFT JOIN t3 ON (d=f);
+  } {
+    t2 {EQ(r[2],c0)} t3 {AND(EQ(r[6],c0),EQ(r[7],c1))}
+  }
 }

 #-------------------------------------------------------------------------
@@ -101,5 +101,67 @@ foreach {tn use_stmt sql schema} {
  } $use_stmt
 }

+#-------------------------------------------------------------------------
+# The following tests check that foreign key constaint counters are
+# correctly updated for any implicit DELETE operations that occur
+# when a REPLACE command is executed against a WITHOUT ROWID table
+# that has no triggers or auxiliary indexes.
+#
+reset_db
+do_execsql_test 2.1.0 {
+  PRAGMA foreign_keys = on;
+  CREATE TABLE p1(a PRIMARY KEY, b) WITHOUT ROWID;
+  CREATE TABLE c1(x REFERENCES p1 DEFERRABLE INITIALLY DEFERRED);
+
+  INSERT INTO p1 VALUES(1, 'one');
+  INSERT INTO p1 VALUES(2, 'two');
+  INSERT INTO c1 VALUES(1);
+  INSERT INTO c1 VALUES(2);
+}
+
+do_catchsql_test 2.1.2 {
+  BEGIN;
+    DELETE FROM p1 WHERE a=1;
+    INSERT OR REPLACE INTO p1 VALUES(2, 'two');
+  COMMIT;
+} {1 {FOREIGN KEY constraint failed}}
+
+reset_db
+do_execsql_test 2.2.0 {
+  PRAGMA foreign_keys = on;
+  CREATE TABLE p2(a PRIMARY KEY, b);
+  CREATE TABLE c2(
+    x PRIMARY KEY,
+    y REFERENCES p2 DEFERRABLE INITIALLY DEFERRED
+  ) WITHOUT ROWID;
+}
+
+do_catchsql_test 2.2.1 {
+  BEGIN;
+    INSERT INTO c2 VALUES(13, 13);
+    INSERT OR REPLACE INTO c2 VALUES(13, 13);
+    DELETE FROM c2;
+  COMMIT;
+} {0 {}}
+
+reset_db
+do_execsql_test 2.3.0 {
+  PRAGMA foreign_keys = on;
+  CREATE TABLE p3(a PRIMARY KEY, b) WITHOUT ROWID;
+  CREATE TABLE c3(x REFERENCES p3);
+
+  INSERT INTO p3 VALUES(1, 'one');
+  INSERT INTO p3 VALUES(2, 'two');
+  INSERT INTO c3 VALUES(1);
+  INSERT INTO c3 VALUES(2);
+
+  CREATE TRIGGER p3d AFTER DELETE ON p3 WHEN old.a=1 BEGIN
+    INSERT OR REPLACE INTO p3 VALUES(2, 'three');
+  END;
+}
+
+do_catchsql_test 2.3.1 {
+  DELETE FROM p3 WHERE a=1
+} {1 {FOREIGN KEY constraint failed}}

 finish_test
@@ -12,10 +12,10 @@
 #
 # This file implements tests for joins, including outer joins.
 #
-# $Id: join2.test,v 1.2 2005/01/21 03:12:16 danielk1977 Exp $

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set testprefix join2

 do_test join2-1.1 {
  execsql {
@@ -72,4 +72,24 @@ ifcapable subquery {
  } {1 11 111 1111 2 22 {} {} 3 33 {} {}}
 }

+#-------------------------------------------------------------------------
+# Check that ticket [25e335f802ddc] has been resolved. It should be an
+# error for the ON clause of a LEFT JOIN to refer to a table to its right.
+#
+do_execsql_test 2.0 {
+  CREATE TABLE aa(a);
+  CREATE TABLE bb(b);
+  CREATE TABLE cc(c);
+  INSERT INTO aa VALUES('one');
+  INSERT INTO bb VALUES('one');
+  INSERT INTO cc VALUES('one');
+}
+
+do_catchsql_test 2.1 {
+  SELECT * FROM aa LEFT JOIN cc ON (a=b) JOIN bb ON (b=c);
+} {1 {ON clause references tables to its right}}
+do_catchsql_test 2.2 {
+  SELECT * FROM aa JOIN cc ON (a=b) JOIN bb ON (b=c);
+} {0 {one one one}}
+
 finish_test
@@ -61,20 +61,20 @@
 **       ./kvtest run x1 --count 10000 --max-id 1000000
 */
 static const char zHelp[] = 
-"Usage: kvhelp COMMAND ARGS...\n"
+"Usage: kvtest COMMAND ARGS...\n"
 "\n"
-"   kvhelp init DBFILE --count N --size M --pagesize X\n"
+"   kvtest init DBFILE --count N --size M --pagesize X\n"
 "\n"
 "        Generate a new test database file named DBFILE containing N\n"
 "        BLOBs each of size M bytes.  The page size of the new database\n"
 "        file will be X\n"
 "\n"
-"   kvhelp export DBFILE DIRECTORY\n"
+"   kvtest export DBFILE DIRECTORY\n"
 "\n"
 "        Export all the blobs in the kv table of DBFILE into separate\n"
 "        files in DIRECTORY.\n"
 "\n"
-"   kvhelp run DBFILE [options]\n"
+"   kvtest run DBFILE [options]\n"
 "\n"
 "        Run a performance test.  DBFILE can be either the name of a\n"
 "        database or a directory containing sample files.  Options:\n"
@@ -87,6 +87,7 @@ static const char zHelp[] =
 "             --max-id N           Maximum blob key to use\n"
 "             --random             Read blobs in a random order\n"
 "             --start N            Start reading with this blob key\n"
+"             --stats              Output operating stats before exiting\n"
 ;

 /* Reference resources used */
@@ -369,6 +370,122 @@ static sqlite3_int64 timeOfDay(void){
  return t;
 }

+#ifdef __linux__
+/*
+** Attempt to display I/O stats on Linux using /proc/PID/io
+*/
+static void displayLinuxIoStats(FILE *out){
+  FILE *in;
+  char z[200];
+  sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
+  in = fopen(z, "rb");
+  if( in==0 ) return;
+  while( fgets(z, sizeof(z), in)!=0 ){
+    static const struct {
+      const char *zPattern;
+      const char *zDesc;
+    } aTrans[] = {
+      { "rchar: ",                  "Bytes received by read():" },
+      { "wchar: ",                  "Bytes sent to write():"    },
+      { "syscr: ",                  "Read() system calls:"      },
+      { "syscw: ",                  "Write() system calls:"     },
+      { "read_bytes: ",             "Bytes read from storage:"  },
+      { "write_bytes: ",            "Bytes written to storage:" },
+      { "cancelled_write_bytes: ",  "Cancelled write bytes:"    },
+    };
+    int i;
+    for(i=0; i<sizeof(aTrans)/sizeof(aTrans[0]); i++){
+      int n = (int)strlen(aTrans[i].zPattern);
+      if( strncmp(aTrans[i].zPattern, z, n)==0 ){
+        fprintf(out, "%-36s %s", aTrans[i].zDesc, &z[n]);
+        break;
+      }
+    }
+  }
+  fclose(in);
+}
+#endif
+
+/*
+** Display memory stats.
+*/
+static int display_stats(
+  sqlite3 *db,                    /* Database to query */
+  int bReset                      /* True to reset SQLite stats */
+){
+  int iCur;
+  int iHiwtr;
+  FILE *out = stdout;
+
+  fprintf(out, "\n");
+
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
+  fprintf(out,
+          "Memory Used:                         %d (max %d) bytes\n",
+          iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
+  fprintf(out, "Number of Outstanding Allocations:   %d (max %d)\n",
+          iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
+  fprintf(out,
+      "Number of Pcache Pages Used:         %d (max %d) pages\n",
+      iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
+  fprintf(out,
+          "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n",
+          iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
+  fprintf(out,
+      "Number of Scratch Allocations Used:  %d (max %d)\n",
+      iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
+  fprintf(out,
+          "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n",
+          iCur, iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
+  fprintf(out, "Largest Allocation:                  %d bytes\n",
+          iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
+  fprintf(out, "Largest Pcache Allocation:           %d bytes\n",
+          iHiwtr);
+  iHiwtr = iCur = -1;
+  sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
+  fprintf(out, "Largest Scratch Allocation:          %d bytes\n",
+          iHiwtr);
+
+  iHiwtr = iCur = -1;
+  sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
+  fprintf(out, "Pager Heap Usage:                    %d bytes\n",
+      iCur);
+  iHiwtr = iCur = -1;
+  sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
+  fprintf(out, "Page cache hits:                     %d\n", iCur);
+  iHiwtr = iCur = -1;
+  sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
+  fprintf(out, "Page cache misses:                   %d\n", iCur);
+  iHiwtr = iCur = -1;
+  sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
+  fprintf(out, "Page cache writes:                   %d\n", iCur);
+  iHiwtr = iCur = -1;
+
+#ifdef __linux__
+  displayLinuxIoStats(out);
+#endif
+
+  /* Do not remove this machine readable comment: extra-stats-output-here */
+
+  fprintf(out, "\n");
+  return 0;
+}
+
 /* Blob access order */
 #define ORDER_ASC     1
 #define ORDER_DESC    2
@@ -389,6 +506,7 @@ static int runMain(int argc, char **argv){
  int iPagesize = 0;          /* Database page size */
  int iCache = 1000;          /* Database cache size in kibibytes */
  int bBlobApi = 0;           /* Use the incremental blob I/O API */
+  int bStats = 0;             /* Print stats before exiting */
  int eOrder = ORDER_ASC;     /* Access order */
  sqlite3 *db = 0;            /* Database connection */
  sqlite3_stmt *pStmt = 0;    /* Prepared statement for SQL access */
@@ -398,6 +516,7 @@ static int runMain(int argc, char **argv){
  int nData = 0;              /* Bytes of data */
  sqlite3_int64 nTotal = 0;   /* Total data read */
  unsigned char *pData;       /* Content of the blob */
+  int nAlloc = 0;             /* Space allocated for pData[] */
  

  assert( strcmp(argv[1],"run")==0 );
@@ -449,6 +568,10 @@ static int runMain(int argc, char **argv){
      bBlobApi = 1;
      continue;
    }
+    if( strcmp(z, "-stats")==0 ){
+      bStats = 1;
+      continue;
+    }
    fatalError("unknown option: \"%s\"", argv[i]);
  }
  tmStart = timeOfDay();
@@ -499,14 +622,16 @@ static int runMain(int argc, char **argv){
      }
      if( rc==SQLITE_OK ){
        nData = sqlite3_blob_bytes(pBlob);
-        pData = sqlite3_malloc( nData+1 );
+        if( nAlloc<nData+1 ){
+          nAlloc = nData+100;
+          pData = sqlite3_realloc(pData, nAlloc);
+        }
        if( pData==0 ) fatalError("cannot allocate %d bytes", nData+1);
        rc = sqlite3_blob_read(pBlob, pData, nData, 0);
        if( rc!=SQLITE_OK ){
          fatalError("could not read the blob at %d: %s", iKey,
                     sqlite3_errmsg(db));
        }
-        sqlite3_free(pData);
      }
    }else{
      /* CASE 3: Reading from database using SQL */
@@ -540,8 +665,12 @@ static int runMain(int argc, char **argv){
    nTotal += nData;
    if( nData==0 ){ nCount++; nExtra++; }
  }
+  if( nAlloc ) sqlite3_free(pData);
  if( pStmt ) sqlite3_finalize(pStmt);
  if( pBlob ) sqlite3_blob_close(pBlob);
+  if( bStats ){
+    display_stats(db, 0);
+  }
  if( db ) sqlite3_close(db);
  tmElapsed = timeOfDay() - tmStart;
  if( nExtra ){
@@ -0,0 +1,84 @@
+# 2017 Jan 4
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix pragma4
+
+proc do_pragma_ncol_test {tn sql nCol} {
+  set ::stmt 0
+  set ::stmt [sqlite3_prepare_v2 db $sql -1 dummy]
+  uplevel [list do_test $tn { sqlite3_column_count $::stmt } $nCol]
+  sqlite3_finalize $::stmt
+}
+
+# If there is no RHS argument, the following PRAGMA statements operate as
+# queries, returning a single row containing a single column.
+#
+# Or, if there is RHS argument, they return zero rows of zero columns.
+#
+foreach {tn sql} {
+  1 "PRAGMA application_id = 10"
+  2 "PRAGMA automatic_index = 1"
+  3 "PRAGMA auto_vacuum = 1"
+  4 "PRAGMA cache_size = -100"
+  5 "PRAGMA cache_spill = 1"
+  6 "PRAGMA cell_size_check = 1"
+  7 "PRAGMA checkpoint_fullfsync = 1"
+  8 "PRAGMA count_changes = 1"
+  9 "PRAGMA default_cache_size = 100"
+ 10 "PRAGMA defer_foreign_keys = 1"
+ 11 "PRAGMA empty_result_callbacks = 1"
+ 12 "PRAGMA encoding = 'utf-8'"
+ 13 "PRAGMA foreign_keys = 1"
+ 14 "PRAGMA full_column_names = 1"
+ 15 "PRAGMA fullfsync = 1"
+ 16 "PRAGMA ignore_check_constraints = 1"
+ 17 "PRAGMA legacy_file_format = 1"
+ 18 "PRAGMA page_size = 511"
+ 19 "PRAGMA page_size = 512"
+ 20 "PRAGMA query_only = false"
+ 21 "PRAGMA read_uncommitted = true"
+ 22 "PRAGMA recursive_triggers = false"
+ 23 "PRAGMA reverse_unordered_selects = false"
+ 24 "PRAGMA schema_version = 211"
+ 25 "PRAGMA short_column_names = 1"
+ 26 "PRAGMA synchronous = full"
+ 29 "PRAGMA temp_store = memory"
+ 30 "PRAGMA user_version = 405"
+ 31 "PRAGMA writable_schema = 1"
+} {
+  reset_db
+
+  # Without RHS:
+  do_pragma_ncol_test 1.$tn.1 [lindex [split $sql =] 0] 1
+
+  # With RHS:
+  do_pragma_ncol_test 1.$tn.2 $sql  0
+}
+
+# These pragmas should never return any values.
+#
+foreach {tn sql} {
+  1 "PRAGMA shrink_memory"
+  2 "PRAGMA shrink_memory = 10"
+  3 "PRAGMA case_sensitive_like = 0"
+  4 "PRAGMA case_sensitive_like = 1"
+  5 "PRAGMA case_sensitive_like"
+} {
+
+  do_pragma_ncol_test 1.$tn.1 $sql 0
+}
+
+
+finish_test
@@ -14,6 +14,7 @@

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set testprefix selectC

 # Ticket #
 do_test selectC-1.1 {
@@ -233,4 +234,37 @@ do_execsql_test selectC-4.3 {
  select a, udf() from (select distinct a, b from t_distinct_bug)
 } {1 1 1 2 1 3}

+#-------------------------------------------------------------------------
+# Test that the problem in ticket #190c2507 has been fixed.
+#
+do_execsql_test 5.0 {
+  CREATE TABLE x1(a);
+  CREATE TABLE x2(b);
+  CREATE TABLE x3(c);
+  CREATE VIEW vvv AS SELECT b FROM x2 ORDER BY 1;
+
+  INSERT INTO x1 VALUES('a'), ('b');
+  INSERT INTO x2 VALUES(22), (23), (25), (24), (21);
+  INSERT INTO x3 VALUES(302), (303), (301);
+}
+
+do_execsql_test 5.1 {
+  CREATE TABLE x4 AS SELECT b FROM vvv UNION ALL SELECT c from x3;
+  SELECT * FROM x4;
+} {21 22 23 24 25 302 303 301}
+
+do_execsql_test 5.2 {
+  SELECT * FROM x1, x4
+} {
+  a 21 a 22 a 23 a 24 a 25 a 302 a 303 a 301
+  b 21 b 22 b 23 b 24 b 25 b 302 b 303 b 301
+}
+
+do_execsql_test 5.3 {
+  SELECT * FROM x1, (SELECT b FROM vvv UNION ALL SELECT c from x3);
+} {
+  a 21 a 22 a 23 a 24 a 25 a 302 a 303 a 301
+  b 21 b 22 b 23 b 24 b 25 b 302 b 303 b 301
+}
+
 finish_test
@@ -61,9 +61,6 @@ static const char zHelp[] =
 #if SQLITE_VERSION_NUMBER<3005000
 # define sqlite3_int64 sqlite_int64
 #endif
-#ifdef SQLITE_ENABLE_RBU
-# include "sqlite3rbu.h"
-#endif

 /* All global state is held in this structure */
 static struct Global {
@@ -1181,10 +1178,10 @@ void testset_rtree(int p1, int p2){
  unsigned mxCoord;
  unsigned x0, x1, y0, y1, z0, z1;
  unsigned iStep;
-  int *aCheck = sqlite3_malloc( sizeof(int)*g.szTest*100 );
+  int *aCheck = sqlite3_malloc( sizeof(int)*g.szTest*500 );

  mxCoord = 15000;
-  n = g.szTest*100;
+  n = g.szTest*500;
  speedtest1_begin_test(100, "%d INSERTs into an r-tree", n);
  speedtest1_exec("BEGIN");
  speedtest1_exec("CREATE VIRTUAL TABLE rt1 USING rtree(id,x0,x1,y0,y1,z0,z1)");
@@ -1207,11 +1204,11 @@ void testset_rtree(int p1, int p2){
  speedtest1_end_test();

  speedtest1_begin_test(101, "Copy from rtree to a regular table");
-  speedtest1_exec(" TABLE t1(id INTEGER PRIMARY KEY,x0,x1,y0,y1,z0,z1)");
+  speedtest1_exec("CREATE TABLE t1(id INTEGER PRIMARY KEY,x0,x1,y0,y1,z0,z1)");
  speedtest1_exec("INSERT INTO t1 SELECT * FROM rt1");
  speedtest1_end_test();

-  n = g.szTest*20;
+  n = g.szTest*100;
  speedtest1_begin_test(110, "%d one-dimensional intersect slice queries", n);
  speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x0>=?1 AND x1<=?2");
  iStep = mxCoord/n;
@@ -1224,7 +1221,7 @@ void testset_rtree(int p1, int p2){
  speedtest1_end_test();

  if( g.bVerify ){
-    n = g.szTest*20;
+    n = g.szTest*100;
    speedtest1_begin_test(111, "Verify result from 1-D intersect slice queries");
    speedtest1_prepare("SELECT count(*) FROM t1 WHERE x0>=?1 AND x1<=?2");
    iStep = mxCoord/n;
@@ -1240,7 +1237,7 @@ void testset_rtree(int p1, int p2){
    speedtest1_end_test();
  }
  
-  n = g.szTest*20;
+  n = g.szTest*100;
  speedtest1_begin_test(120, "%d one-dimensional overlap slice queries", n);
  speedtest1_prepare("SELECT count(*) FROM rt1 WHERE y1>=?1 AND y0<=?2");
  iStep = mxCoord/n;
@@ -1253,7 +1250,7 @@ void testset_rtree(int p1, int p2){
  speedtest1_end_test();

  if( g.bVerify ){
-    n = g.szTest*20;
+    n = g.szTest*100;
    speedtest1_begin_test(121, "Verify result from 1-D overlap slice queries");
    speedtest1_prepare("SELECT count(*) FROM t1 WHERE y1>=?1 AND y0<=?2");
    iStep = mxCoord/n;
@@ -1270,7 +1267,7 @@ void testset_rtree(int p1, int p2){
  }
  

-  n = g.szTest*20;
+  n = g.szTest*100;
  speedtest1_begin_test(125, "%d custom geometry callback queries", n);
  sqlite3_rtree_geometry_callback(g.db, "xslice", xsliceGeometryCallback, 0);
  speedtest1_prepare("SELECT count(*) FROM rt1 WHERE id MATCH xslice(?1,?2)");
@@ -1286,7 +1283,7 @@ void testset_rtree(int p1, int p2){
  }
  speedtest1_end_test();

-  n = g.szTest*80;
+  n = g.szTest*400;
  speedtest1_begin_test(130, "%d three-dimensional intersect box queries", n);
  speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x1>=?1 AND x0<=?2"
                     " AND y1>=?1 AND y0<=?2 AND z1>=?1 AND z0<=?2");
@@ -1299,7 +1296,7 @@ void testset_rtree(int p1, int p2){
  }
  speedtest1_end_test();

-  n = g.szTest*100;
+  n = g.szTest*500;
  speedtest1_begin_test(140, "%d rowid queries", n);
  speedtest1_prepare("SELECT * FROM rt1 WHERE id=?1");
  for(i=1; i<=n; i++){
@@ -1458,11 +1455,6 @@ int main(int argc, char **argv){
        noSync = 1;
      }else if( strcmp(z,"notnull")==0 ){
        g.zNN = "NOT NULL";
-#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]);
        pageSize = integerValue(argv[++i]);
@@ -0,0 +1,72 @@
+# 2017 January 4
+#
+# 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.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix triggerF
+ifcapable {!trigger} {
+  finish_test
+  return
+}
+
+
+foreach {tn sql log} {
+  1 { } { }
+
+  2 { 
+    CREATE TRIGGER trd AFTER DELETE ON t1 BEGIN
+      INSERT INTO log VALUES(old.a || old.b || (SELECT count(*) FROM t1));
+    END;
+  } {1one2 2two1 3three1}
+
+  3 { 
+    CREATE TRIGGER trd BEFORE DELETE ON t1 BEGIN
+      INSERT INTO log VALUES(old.a || old.b || (SELECT count(*) FROM t1));
+    END;
+  } {1one3 2two2 3three2}
+
+  4 { 
+    CREATE TRIGGER tr1 AFTER DELETE ON t1 BEGIN
+      INSERT INTO log VALUES(old.a || old.b || (SELECT count(*) FROM t1));
+    END;
+    CREATE TRIGGER tr2 BEFORE DELETE ON t1 BEGIN
+      INSERT INTO log VALUES(old.a || old.b || (SELECT count(*) FROM t1));
+    END;
+  } {1one3 1one2 2two2 2two1 3three2 3three1}
+
+} {
+  reset_db
+  do_execsql_test 1.$tn.0 {
+    PRAGMA recursive_triggers = on;
+    CREATE TABLE t1(a INT PRIMARY KEY, b) WITHOUT ROWID;
+    CREATE TABLE log(t);
+  }
+  
+  execsql $sql
+
+  do_execsql_test 1.$tn.1 {
+    INSERT INTO t1 VALUES(1, 'one');
+    INSERT INTO t1 VALUES(2, 'two');
+    INSERT INTO t1 VALUES(3, 'three');
+
+    DELETE FROM t1 WHERE a=1;
+    INSERT OR REPLACE INTO t1 VALUES(2, 'three');
+    UPDATE OR REPLACE t1 SET a=3 WHERE a=2;
+  }
+
+  do_execsql_test 1.$tn.2 {
+    SELECT * FROM log ORDER BY rowid;
+  } $log
+}
+
+finish_test
+
@@ -0,0 +1,180 @@
+# 2017 January 9
+#
+# 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.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix update2
+
+db func repeat [list string repeat]
+
+#-------------------------------------------------------------------------
+# 1.1.* A one-pass UPDATE that does balance() operations on the IPK index
+#       that it is scanning.
+#
+# 1.2.* Same again, but with a WITHOUT ROWID table.
+#
+set nrow [expr 10]
+do_execsql_test 1.1.0 {
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
+  WITH s(i) AS ( SELECT 0 UNION ALL SELECT i+1 FROM s WHERE i<$nrow )
+  INSERT INTO t1(b) SELECT char((i % 26) + 65) FROM s;
+  INSERT INTO t2 SELECT * FROM t1;
+}
+
+do_execsql_test 1.1.1 {
+  UPDATE t1 SET b = repeat(b, 100)
+}
+
+do_execsql_test 1.1.2 {
+  SELECT * FROM t1;
+} [db eval { SELECT a, repeat(b, 100) FROM t2 }]
+
+do_execsql_test 1.2.0 {
+  DROP TABLE t1;
+  CREATE TABLE t1(a INT PRIMARY KEY, b) WITHOUT ROWID;
+  WITH s(i) AS ( SELECT 0 UNION ALL SELECT i+1 FROM s WHERE i<$nrow )
+  INSERT INTO t1(a, b) SELECT i+1, char((i % 26) + 65) FROM s;
+}
+
+#explain_i { UPDATE t1 SET b = repeat(b, 100) }
+do_execsql_test 1.2.1 {
+  UPDATE t1 SET b = repeat(b, 100)
+}
+
+do_execsql_test 1.2.2 {
+  SELECT * FROM t1;
+} [db eval { SELECT a, repeat(b, 100) FROM t2 }]
+
+
+#-------------------------------------------------------------------------
+# A one-pass UPDATE that does balance() operations on the IPK index
+# that it is scanning.
+#
+do_execsql_test 2.1 {
+  CREATE TABLE t3(a PRIMARY KEY, b, c);
+  CREATE INDEX t3i ON t3(b);
+} {}
+do_execsql_test 2.2 { UPDATE t3 SET c=1 WHERE b=?      } {}
+do_execsql_test 2.3 { UPDATE t3 SET c=1 WHERE rowid=?  } {}
+
+#-------------------------------------------------------------------------
+#
+do_execsql_test 3.0 {
+  CREATE TABLE t4(a PRIMARY KEY, b, c) WITHOUT ROWID;
+  CREATE INDEX t4c ON t4(c);
+  INSERT INTO t4 VALUES(1, 2, 3);
+  INSERT INTO t4 VALUES(2, 3, 4);
+}
+
+do_execsql_test 3.1 {
+  UPDATE t4 SET c=c+2 WHERE c>2;
+  SELECT a, c FROM t4 ORDER BY a;
+} {1 5 2 6}
+
+#-------------------------------------------------------------------------
+#
+foreach {tn sql} {
+  1 { 
+    CREATE TABLE b1(a INTEGER PRIMARY KEY, b, c);
+    CREATE TABLE c1(a INTEGER PRIMARY KEY, b, c, d)
+  }
+  2 { 
+    CREATE TABLE b1(a INT PRIMARY KEY, b, c) WITHOUT ROWID;
+    CREATE TABLE c1(a INT PRIMARY KEY, b, c, d) WITHOUT ROWID;
+  }
+} {
+  execsql { DROP TABLE IF EXISTS b1; DROP TABLE IF EXISTS c1; }
+  execsql $sql
+
+  do_execsql_test 4.$tn.0 {
+    CREATE UNIQUE INDEX b1c ON b1(c);
+    INSERT INTO b1 VALUES(1, 'a', 1);
+    INSERT INTO b1 VALUES(2, 'b', 15);
+    INSERT INTO b1 VALUES(3, 'c', 3);
+    INSERT INTO b1 VALUES(4, 'd', 4);
+    INSERT INTO b1 VALUES(5, 'e', 5);
+    INSERT INTO b1 VALUES(6, 'f', 6);
+    INSERT INTO b1 VALUES(7, 'g', 7);
+  }
+
+  do_execsql_test 4.$tn.1 {
+    UPDATE OR REPLACE b1 SET c=c+10 WHERE a BETWEEN 4 AND 7;
+    SELECT * FROM b1 ORDER BY a;
+  } {
+    1 a 1
+    3 c 3
+    4 d 14
+    5 e 15
+    6 f 16
+    7 g 17
+  }
+
+  do_execsql_test 4.$tn.2 {
+    CREATE INDEX c1d ON c1(d, b);
+    CREATE UNIQUE INDEX c1c ON c1(c, b);
+
+    INSERT INTO c1 VALUES(1, 'a', 1,  1);
+    INSERT INTO c1 VALUES(2, 'a', 15, 2);
+    INSERT INTO c1 VALUES(3, 'a', 3,  3);
+    INSERT INTO c1 VALUES(4, 'a', 4,  4);
+    INSERT INTO c1 VALUES(5, 'a', 5,  5);
+    INSERT INTO c1 VALUES(6, 'a', 6,  6);
+    INSERT INTO c1 VALUES(7, 'a', 7,  7);
+  }
+
+  do_execsql_test 4.$tn.3 {
+    UPDATE OR REPLACE c1 SET c=c+10 WHERE d BETWEEN 4 AND 7;
+    SELECT * FROM c1 ORDER BY a;
+  } {
+    1 a 1 1
+    3 a 3 3
+    4 a 14 4
+    5 a 15 5
+    6 a 16 6
+    7 a 17 7
+  }
+
+  do_execsql_test 4.$tn.4 { PRAGMA integrity_check } ok
+
+  do_execsql_test 4.$tn.5 {
+    DROP INDEX c1d;
+    DROP INDEX c1c;
+    DELETE FROM c1;
+
+    INSERT INTO c1 VALUES(1, 'a', 1,  1);
+    INSERT INTO c1 VALUES(2, 'a', 15, 2);
+    INSERT INTO c1 VALUES(3, 'a', 3,  3);
+    INSERT INTO c1 VALUES(4, 'a', 4,  4);
+    INSERT INTO c1 VALUES(5, 'a', 5,  5);
+    INSERT INTO c1 VALUES(6, 'a', 6,  6);
+    INSERT INTO c1 VALUES(7, 'a', 7,  7);
+
+    CREATE INDEX c1d ON c1(d);
+    CREATE UNIQUE INDEX c1c ON c1(c);
+  }
+
+  do_execsql_test 4.$tn.6 {
+    UPDATE OR REPLACE c1 SET c=c+10 WHERE d BETWEEN 4 AND 7;
+    SELECT * FROM c1 ORDER BY a;
+  } {
+    1 a 1 1
+    3 a 3 3
+    4 a 14 4
+    5 a 15 5
+    6 a 16 6
+    7 a 17 7
+  }
+}
+
+finish_test
+
@@ -121,29 +121,43 @@ if {$tcl_platform(platform)!="windows" || \
    SELECT name FROM fsdir WHERE dir = '.' AND name = '.'
  } {test.db .}

+  proc sort_files { names {nocase false} } {
+    if {$nocase && $::tcl_platform(platform) eq "windows"} {
+      return [lsort -nocase $names]
+    } else {
+      return [lsort $names]
+    }
+  }
+
  proc list_root_files {} {
    if {$::tcl_platform(platform) eq "windows"} {
-      set res [list]
-      foreach name [glob -directory $::env(fstreeDrive)/ -- *] {
+      set res [list]; set dir $::env(fstreeDrive)/; set names [list]
+      eval lappend names [glob -nocomplain -directory $dir -- *]
+      foreach name $names {
        if {[string index [file tail $name] 0] eq "."} continue
+        if {[file attributes $name -hidden]} continue
+        if {[file attributes $name -system]} continue
        lappend res $name
      }
-      return $res
+      return [sort_files $res true]
    } else {
-      return [string map {/ {}} [glob /*]]
+      return [sort_files [string map {/ {}} [glob -nocomplain -- /*]]]
    }
  }

  proc list_files { pattern } {
    if {$::tcl_platform(platform) eq "windows"} {
-      set res [list]
-      foreach name [glob -nocomplain $pattern] {
+      set res [list]; set names [list]
+      eval lappend names [glob -nocomplain -- $pattern]
+      foreach name $names {
        if {[string index [file tail $name] 0] eq "."} continue
+        if {[file attributes $name -hidden]} continue
+        if {[file attributes $name -system]} continue
        lappend res $name
      }
-      return $res
+      return [sort_files $res]
    } else {
-      return [glob -nocomplain $pattern]
+      return [sort_files [glob -nocomplain -- $pattern]]
    }
  }

@@ -153,18 +167,19 @@ if {$tcl_platform(platform)!="windows" || \
  #
  set res [list]
  set root_files [list_root_files]
-  set num_root_files [llength $root_files]
-  set lim_root_files [expr {$num_root_files > 5 ? 5 : $num_root_files}]
-  foreach p [lrange $root_files 0 [expr {$lim_root_files - 1}]] {
+  foreach p $root_files {
    if {$::tcl_platform(platform) eq "windows"} {
-      if {[regexp {\$} $p]} {incr lim_root_files -1} else {lappend res $p}
+      if {![regexp {\$} $p]} {lappend res $p}
    } else {
      lappend res "/$p"
    }
  }
-  do_execsql_test 3.1 [subst {
-    SELECT path FROM fstree WHERE path NOT GLOB '*\$*' LIMIT $lim_root_files;
-  }] $res
+  set num_root_files [llength $root_files]
+  do_test 3.1 {
+    sort_files [execsql {
+      SELECT path FROM fstree WHERE path NOT GLOB '*\$*' LIMIT $num_root_files;
+    }] true
+  } [sort_files $res true]

  # Read all entries in the current directory.
  #
@@ -182,7 +197,7 @@ if {$tcl_platform(platform)!="windows" || \
  set res [contents $pwd]
  do_execsql_test 3.2 {
    SELECT path FROM fstree WHERE path GLOB $pwd ORDER BY 1
-  } [lsort $res]
+  } [sort_files $res]

  # Add some sub-directories and files to the current directory.
  #
@@ -18,6 +18,7 @@ set flagMeaning(Result1)    {Acts as query when has one argument}
 set flagMeaning(SchemaReq)  {Schema required - "main" is default}
 set flagMeaning(SchemaOpt)  {Schema restricts name search if present}
 set flagMeaning(NoColumns)  {OP_ResultRow called with zero columns}
+set flagMeaning(NoColumns1) {zero columns if RHS argument is present}

 set pragma_def {
  NAME: full_column_names
@@ -56,7 +57,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_FLAG_PRAGMAS)

  NAME: cache_spill
-  FLAG: Result0 SchemaReq
+  FLAG: Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_FLAG_PRAGMAS)

  NAME: reverse_unordered_selects
@@ -149,12 +150,12 @@ set pragma_def {
  ARG:  SQLITE_CellSizeCk

  NAME: default_cache_size
-  FLAG: NeedSchema Result0 SchemaReq
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  COLS: cache_size
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)

  NAME: page_size
-  FLAG: Result0 SchemaReq
+  FLAG: Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: secure_delete
@@ -183,14 +184,14 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: cache_size
-  FLAG: NeedSchema Result0 SchemaReq
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: mmap_size
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: auto_vacuum
-  FLAG: NeedSchema Result0 SchemaReq
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_AUTOVACUUM)

  NAME: incremental_vacuum
@@ -198,20 +199,23 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_AUTOVACUUM)

  NAME: temp_store
-  FLAG: Result0
+  FLAG: Result0 NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: temp_store_directory
+  FLAG: NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: data_store_directory
+  FLAG: NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN

  NAME: lock_proxy_file
+  FLAG: NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE

  NAME: synchronous
-  FLAG: NeedSchema Result0 SchemaReq
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: table_info
@@ -267,6 +271,7 @@ set pragma_def {
  IF:   defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_PARSER_TRACE)

  NAME: case_sensitive_like
+  FLAG: NoColumns

  NAME: integrity_check
  FLAG: NeedSchema
@@ -278,34 +283,37 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_INTEGRITY_CHECK)

  NAME: encoding
-  FLAG: Result0
+  FLAG: Result0 NoColumns1
  IF:   !defined(SQLITE_OMIT_UTF16)

  NAME: schema_version
  TYPE: HEADER_VALUE
  ARG:  BTREE_SCHEMA_VERSION
+  FLAG: NoColumns1 Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: user_version
  TYPE: HEADER_VALUE
  ARG:  BTREE_USER_VERSION
+  FLAG: NoColumns1 Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: data_version
  TYPE: HEADER_VALUE
  ARG:  BTREE_DATA_VERSION
-  FLAG: ReadOnly
+  FLAG: ReadOnly Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: freelist_count
  TYPE: HEADER_VALUE
  ARG:  BTREE_FREE_PAGE_COUNT
-  FLAG: ReadOnly
+  FLAG: ReadOnly Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: application_id
  TYPE: HEADER_VALUE
  ARG:  BTREE_APPLICATION_ID
+  FLAG: NoColumns1 Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: compile_options
@@ -321,6 +329,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_WAL)

  NAME: shrink_memory
+  FLAG: NoColumns

  NAME: busy_timeout
  FLAG: Result0
@@ -408,10 +417,7 @@ foreach line [split $pragma_def \n] {
  } elseif {$id=="TYPE"} {
    set type $val
    if {$type=="FLAG"} {
-      lappend flags Result0 NoColumns
-    }
-    if {$type=="HEADER_VALUE"} {
-      lappend flags Result0
+      lappend flags Result0 NoColumns1
    }
  } elseif {$id=="ARG"} {
    set arg $val
@@ -23,6 +23,7 @@ NAME=$1
 shift
 #CC_OPTS="-DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_MEMSYS5"
 CC_OPTS="-DSQLITE_ENABLE_MEMSYS5"
+CC=gcc
 SPEEDTEST_OPTS="--shrink-memory --reprepare --stats --heap 10000000 64"
 SIZE=5
 LEAN_OPTS="-DSQLITE_THREADSAFE=0"
@@ -80,11 +81,19 @@ while test "$1" != ""; do
    --lean)
        CC_OPTS="$CC_OPTS $LEAN_OPTS"
        ;;
+    --clang)
+        CC=clang
+        ;;
    --heap)
        CC_OPTS="$CC_OPTS -DSQLITE_ENABLE_MEMSYS5"
        shift;
        SPEEDTEST_OPTS="$SPEEDTEST_OPTS --heap $1 64"
        ;;
+    --lookaside)
+        shift;
+        SPEEDTEST_OPTS="$SPEEDTEST_OPTS --lookaside $1 $2"
+        shift;
+        ;;
    --repeat)
        CC_OPTS="$CC_OPTS -DSQLITE_ENABLE_RCACHE"
        shift;
@@ -94,6 +103,10 @@ while test "$1" != ""; do
        shift;
        SPEEDTEST_OPTS="$SPEEDTEST_OPTS --mmap $1"
        ;;
+    --rtree)
+        SPEEDTEST_OPTS="$SPEEDTEST_OPTS --testset rtree"
+        CC_OPTS="$CC_OPTS -DSQLITE_ENABLE_RTREE"
+        ;;
    *)
        CC_OPTS="$CC_OPTS $1"
        ;;
@@ -105,15 +118,15 @@ echo "NAME           = $NAME" | tee summary-$NAME.txt
 echo "SPEEDTEST_OPTS = $SPEEDTEST_OPTS" | tee -a summary-$NAME.txt
 echo "CC_OPTS        = $CC_OPTS" | tee -a summary-$NAME.txt
 rm -f cachegrind.out.* speedtest1 speedtest1.db sqlite3.o
-gcc -g -Os -Wall -I. $CC_OPTS -c sqlite3.c
+$CC -g -Os -Wall -I. $CC_OPTS -c sqlite3.c
 size sqlite3.o | tee -a summary-$NAME.txt
 if test $doExplain -eq 1; then
-  gcc -g -Os -Wall -I. $CC_OPTS \
+  $CC -g -Os -Wall -I. $CC_OPTS \
     -DSQLITE_ENABLE_EXPLAIN_COMMENTS \
    ./shell.c ./sqlite3.c -o sqlite3 -ldl -lpthread
 fi
 SRC=./speedtest1.c
-gcc -g -Os -Wall -I. $CC_OPTS $SRC ./sqlite3.o -o speedtest1 -ldl -lpthread
+$CC -g -Os -Wall -I. $CC_OPTS $SRC ./sqlite3.o -o speedtest1 -ldl -lpthread
 ls -l speedtest1 | tee -a summary-$NAME.txt
 if test $doCachegrind -eq 1; then
  valgrind --tool=cachegrind ./speedtest1 speedtest1.db \
Author	SHA1	Message	Date
dan	e8814cc83c	Fix problems in the previous commit. FossilOrigin-Name: 74ad80eb745c708bdbbbf24cbbbf50971e84182f	2017-01-21 16:21:24 +00:00
dan	0fbee29700	Add extra (somewhat inefficient) trace callbacks for triggers if SQLITE_TRACE_TRIGGER is defined. FossilOrigin-Name: ffda1d1e1c858abd02f0c07b906cfac5ad075498	2017-01-21 15:58:42 +00:00
drh	184d902db1	In the kvtest.c test utility, reuse the buffer into which blobs are read, rather than reallocating it for each row. This is a closer match to how other test programs work, and thus provides a better comparison. FossilOrigin-Name: 0d1ad13a296b22d6fe36879b56f99bd6af1acd3a	2017-01-21 15:55:41 +00:00
drh	36cae856ee	Remove an unnecessary sqlite3_bind_int64() call from sqlite3_blob_open(). Also other minor refactoring of the sqlite3_blob implementation. FossilOrigin-Name: 9d197a532349f4b1caf66bbed70ca46df86cb86f	2017-01-21 14:11:28 +00:00
drh	cd64553015	Minor performance optimization and size reduction to the accessPayload() routine in btree.c. FossilOrigin-Name: 264e5c10d7144910b3223b64546567fa20e4bc65	2017-01-20 20:43:14 +00:00
dan	dfd0de82f1	Fix a typo in the help message for kvtest. FossilOrigin-Name: 8971d98f25a4f5fb060db8ed6a4b06f083122a50	2017-01-20 16:47:34 +00:00
dan	befcd8ad84	Add option "--stats" to test program kvtest. Specifying --stats causes kvtest to output information similar to the shell tool option of the same name. FossilOrigin-Name: 90291327fc127671d9847a4a2ce1ed47a408cfc6	2017-01-20 16:46:20 +00:00
drh	508286701a	Get the "--testset rtree" option working on speedtest1. Add the --rtree, --lookaside, and --clang options to the speed-check.sh script. FossilOrigin-Name: 87b640c8d07a76b2bc7e896e01965cc09e06f77b	2017-01-20 16:09:12 +00:00
drh	4df65fc20f	Minor performance optimizations to sqlite3_blob_open() and sqlite3_blob_reopen(). FossilOrigin-Name: 52a61967d920047ea0b4409b79793e05c0128964	2017-01-20 00:40:26 +00:00
drh	8674e49214	If compiled with SQLITE_INLINE_MEMCPY, all memcpy() calls are replaced with in-line code. With that change, cachegrind shows which memcpy() calls are taking the most time. This is a performance-measurement hack only and is not for production use. FossilOrigin-Name: 9ed38521617136223a667988aed40e25797faf84	2017-01-19 21:20:11 +00:00
mistachkin	2f31d02049	In the 'vtshim' extension, avoid accessing freed memory when handling errors from xCreate/xConnect. FossilOrigin-Name: ffd559afd32dcdce9c733ebccdee88fda9b689cf	2017-01-19 18:20:36 +00:00
mistachkin	aac853bae8	In the 'windirent' test module, use a macro for the hidden/system attribute checking. FossilOrigin-Name: a84a08d0716656dc0b26eafb1841c48d83c67ef2	2017-01-18 22:47:42 +00:00
mistachkin	d3e73d6c1c	Remove superfluous option to Tcl 'lsort' in the vtabH test file. FossilOrigin-Name: b92cc6e58ae31cbe6600a522beb5485f7add04b2	2017-01-18 22:19:01 +00:00
mistachkin	7059138a08	Make the vtabH-3.1 test more portable and robust. FossilOrigin-Name: d3c91c1fb345fbcbfc60a897bebf771c795430c9	2017-01-18 22:16:34 +00:00
mistachkin	8a9e83583b	Fix handling of initial hidden and/or system files in the opendir() implementation for Windows. No changes to non-test code. FossilOrigin-Name: 26dd42b462dc621b8b0a2295fc91d3e61ac732b6	2017-01-18 22:16:20 +00:00
dan	25fd2e247b	Fix a problem that could cause a spurious SQLITE_NOMEM error when attempting to resume an RBU operation if the previous client failed right after completing the incremental checkpoint. Also a "cannot vacuum wal db" error that could occur when resuming an RBU vacuum if an error (OOM or IO error) occurs during the incremental checkpoint. FossilOrigin-Name: 681d96eb822e606da53700867191d4738bda20c8	2017-01-17 10:41:42 +00:00
drh	c711f53f30	Disable intrinsic functions for Windows using Clang, due to reports of linkage errors. This causes a 0.6% performance reduction. We will want to revisit this change in the future. FossilOrigin-Name: 7fd560c6d2ff470b755ad118287a0a8825b3009e	2017-01-17 00:10:58 +00:00
drh	de48a3f98a	Back out check-in [0b3174e0b1364c] and replace it with a better fix for \ticket [91e2e8ba6ff2e2] - a fix that does not cause the problem identified by ticket [7ffd1ca1d2ad4ec]. Add new test cases for both tickets. FossilOrigin-Name: 9b64af7b5201a8700ae9e384b04714ca18df7449	2017-01-16 18:10:17 +00:00
drh	da060052e3	Back out check-in [0b3174e0b1364c] and replace it with a better fix for ticket [91e2e8ba6ff2e2] - a fix that does not cause the problem identified by ticket [7ffd1ca1d2ad4ec]. FossilOrigin-Name: 0613665274346917f5482f9210bf0c60a0fed7d9	2017-01-16 16:43:02 +00:00
drh	ce31643fd9	Add test cases for tickets [91e2e8ba6ff2e2] and [7ffd1ca1d2ad4ec]. FossilOrigin-Name: 9d0dfe0b088a5917afa06207ca3ac5618e3da82f	2017-01-16 16:01:50 +00:00
dan	ef2f5925d8	Fix a problem preventing resumption of RBU operations after recovering from a process or system failure that occurs during the incremental-checkpoint phase. FossilOrigin-Name: 97914266cb4ec63b0c9185ab139673139bd2f0ed	2017-01-13 18:24:37 +00:00
drh	be7a0cee4e	Fix the build for SQLITE_ENABLE_MEMORY_MANAGEMENT. FossilOrigin-Name: 8c85b8fdd7f0ba65fba83361d361a567b797a184	2017-01-13 12:53:35 +00:00
drh	7b20a15d13	Remove a branch that is probably unreachable, and which adds no value. FossilOrigin-Name: 9acc72381ccd5e36f3ffdf7e7fbefc5a15701eb4	2017-01-12 19:10:55 +00:00
drh	ae051a8970	Fix harmless compiler warnings in the UPDATE code generator. FossilOrigin-Name: 385db266673abaf7013ffad09b28014c246547ef	2017-01-12 16:21:54 +00:00
drh	70d90a2c37	Remove an unnecessary corruption test from the btree balancer. If corruption is present, it will be found harmlessly by later tests. FossilOrigin-Name: bddf39562d08e259c43dd59b82afb62fe0eb2eef	2017-01-12 16:14:33 +00:00
drh	b701c9a6c3	Improved detection of cells that extend into the reserved space at the end of the page while adjusting overflow page pointers during autovacuum. FossilOrigin-Name: 8097712c9c1f4ea16bc5dd462da248ef98896061	2017-01-12 15:11:03 +00:00
drh	24be549329	Remove invalid test case from cursorhints2.test FossilOrigin-Name: 163cc1b2f7100827d5803b81dcd97a1417744f66	2017-01-12 11:52:47 +00:00
drh	ea8f0a155e	Make sure Tcl_AppendResult() always has a NULL-pointer argument at the end. FossilOrigin-Name: c07aef6f909fe35de110f0b180dbf5aa4c226af3	2017-01-12 11:50:08 +00:00
dan	ba47020b63	Changes to allow some multi-row UPDATE statements to avoid the two-pass approach. FossilOrigin-Name: 7ae6104a3e0d1d2cacfe2be732f0220a53908132	2017-01-11 21:03:53 +00:00
dan	e206ea7f48	Fix a problem causing the pre-update hook to be passed an incorrect rowid value in some single-pass multi-row updates. FossilOrigin-Name: 62257eb53c13d4c7ed128d5d89f6f10d4aff945c	2017-01-11 20:10:30 +00:00
dan	2c6fec21dc	Fix a problem with single-pass multi-row UPDATE statements that invoke REPLACE conflict handling. FossilOrigin-Name: 0a2b8e1b9dc600b5a93622e8eea6218649df5e0f	2017-01-11 19:03:08 +00:00
dan	372f942f17	Fix a problem preventing UPDATE statements that use a range-scan on the PK index of a WITHOUT ROWID table from using a one-pass strategy. FossilOrigin-Name: cab86c90945126c24c40cf2dedd053a8c46d00d6	2017-01-11 15:42:14 +00:00
drh	785d8ed0d4	In the STAT4 computations, ensure that the aAvgEq values do not go negative. FossilOrigin-Name: f58f75b5a06f88ba97bd1a02bee621c64691c6f8	2017-01-11 14:15:29 +00:00
dan	f91c1318f4	Changes to allow some multi-row UPDATE statements to avoid the two-pass approach. FossilOrigin-Name: 46db23ccd116ce5b9d949f9293be8a2818411b46	2017-01-10 20:04:38 +00:00
dan	f112f0b3de	Add a test case for ticket [25e335f802dd]. FossilOrigin-Name: e500c15a9f55aed1601f7c14169dd56fd76f1fdd	2017-01-10 17:37:49 +00:00
drh	8e36ddd37e	Throw an error if the ON clause of a LEFT JOIN references tables to the right of the ON clause. Fix for ticket [25e335f802dd]. FossilOrigin-Name: c92ecff2ec5f178433d21f25c653d0fdd9128d7c	2017-01-10 17:33:43 +00:00
drh	1d21bac8aa	Avoid unnecessary calls to the xRoundup() method of the memory allocator when the soft heap limit is not set. FossilOrigin-Name: 4209b89eab01814228a178963238e0dffffad2a4	2017-01-10 16:09:46 +00:00
drh	d9bcb32ebb	Fix a potential assertion fault discovered by OSS-Fuzz. FossilOrigin-Name: 71c03b59b645884ebd6b9e18713cd2eb8c949870	2017-01-10 15:08:06 +00:00
drh	e4a8b8769e	Remove a redundant assignment statement. FossilOrigin-Name: a5fa09657bd6c4ea5fe6712b0f8af2170cbe0381	2017-01-09 19:55:19 +00:00
drh	7441df72be	Performance optimization and size reduction in the OP_Variable opcode. FossilOrigin-Name: 237aa97452e20c312f256a8fd62531e3d447f84b	2017-01-09 19:27:04 +00:00
mistachkin	ab61cf7d93	Fix typo in a comment. No changes to code. FossilOrigin-Name: d38fd22935b1572f4481b39c2f9274329b18ea99	2017-01-09 18:22:54 +00:00
drh	e7b554d615	Modify the OP_RowData opcode so that when P3!=0 it is allowed to hold an ephemeral copy of the content. This avoids unnecessary memcpy() operations in the xfer-optimization and VACUUM. FossilOrigin-Name: 6e106acd74da3baa5c308a76443d2f0a7c904e5e	2017-01-09 15:44:25 +00:00
drh	f4e994b23a	Add the SQLITE_UINT64_TYPE compile-time option. FossilOrigin-Name: a5fe03bc419d9c7e6068ed38810e3f183de179b5	2017-01-09 13:43:09 +00:00
drh	68116939eb	Improvements to the iIdxNoSeek optimization of sqlite3GenerateRowDelete() so that it is automatically disabled for BEFORE triggers but works in all other cases. FossilOrigin-Name: 3178ec4c27efc4ff84bcd17ddb17ec50a6ac96b3	2017-01-07 14:47:03 +00:00
drh	4cef5b1c81	Critical fix to the previous check-in so that it works when there are BEFORE triggers that move the cursor before the OP_Delete has a chance to be applied. FossilOrigin-Name: db2c0960ffb3b396b20e0441d3edb812254c82bc	2017-01-07 14:26:28 +00:00
drh	ad1d9a8707	Avoid an unnecessary btree seek while deleting an index entry due to a conflict on a REPLACE operation. FossilOrigin-Name: f0495c5133d0dc04d63521136d6b9ca440792cdf	2017-01-07 03:26:50 +00:00
drh	a67b5cb6b3	Avoid duplicate b-tree searches in the duplicate row detector used to implement DISTINCT. FossilOrigin-Name: d577dda0a7fbfacda57e8cad2bc4651d2a05d813	2017-01-07 00:56:01 +00:00
dan	e1ff3f5e11	Ensure that "PRAGMA case_sensitive_like" and "PRAGMA shrink_memory" set the number of output columns to 0 (as they are statements that return no data). FossilOrigin-Name: 6696cd1878be4bd44a24841b04163e52d847711e	2017-01-06 13:49:40 +00:00
dan	1439a1e80f	Improve handling of corrupt data in fts5. FossilOrigin-Name: 609ac1c73f7c2b48a571c178a72383996a9538fe	2017-01-06 11:55:03 +00:00
drh	3d775e7586	Clarify the documentation on sqlite3_column_count(). FossilOrigin-Name: 9ea0baddd893e54ec79399ae83033ae139650535	2017-01-06 01:09:43 +00:00
mistachkin	817be73bfc	Remove several non-portable tests for the deprecated temp_store_directory PRAGMA. FossilOrigin-Name: 28d87789141d816e0bce6d3965ce84c79b803218	2017-01-06 00:02:51 +00:00
dan	2b64313b8d	Ensure that sqlite3_column_count() returns 0 for the "set" mode of "get/set" PRAGMA statements that do not return a value in that case (e.g. page_size, cache_size, auto_vacuum). FossilOrigin-Name: 2f57939a5583ae420b525c7e0f0dcda8626fe992	2017-01-05 20:00:08 +00:00
dan	9e1ab1a8a4	Ensure that sqlite3_column_count() returns 0 for the "set" mode of "get/set" PRAGMA statements that do not return a value in that case (e.g. page_size, cache_size, auto_vacuum). FossilOrigin-Name: 5c05d8ec5e895661dae2de30c73dfdeaff93511e	2017-01-05 19:32:48 +00:00
dan	ac56ab7e48	Fix handling the case where a sub-query in a FROM clause is itself a UNION ALL, and one side of that UNION ALL is a query on a view that includes an ORDER BY. Fix for ticket [190c2507]. FossilOrigin-Name: 590ca83b8e8cdd5d24ed7f10f43e540aa0627f22	2017-01-05 17:23:11 +00:00
drh	5f40cebf43	Fix problems in trigger and foreign key handling when doing REPLACE on a WITHOUT ROWID table that has no secondary indexes. FossilOrigin-Name: 571f166ea8721e2322965b6f23e758b78d13baca	2017-01-05 13:50:12 +00:00
drh	34d04d64f0	Ensure that the sqlite3_value_text() interface returns a buffer that is long enough to hold the complete string plus the zero terminator even when the input is a zeroblob. Fix for a problem detected by OSS-Fuzz. FossilOrigin-Name: 2dc7eeb5b4d2eaf1d843eda56f339fd4cc80d78e	2017-01-05 07:58:29 +00:00
dan	f9a12a106b	Fix some problems with foreign key processing within REPLACE ops on WITHOUT ROWID tables with no triggers or auxiliary indexes. FossilOrigin-Name: c1220b1af62629d7fc2178512786d613cd7ea711	2017-01-05 06:57:42 +00:00
drh	801f55d837	Improved the comment on the block of code the provides the performance optimization originally added by check-in [925840cfdb]. The original check-in omitted condition 4, which was the cause of bug [30027b613b]. FossilOrigin-Name: c6506b82aa6583ccde5f673c79526d5f3920b67a	2017-01-04 22:02:56 +00:00
dan	4e1f0efb4d	Possible fix for 30027b61. There may still be problems surrounding foreign key processing. FossilOrigin-Name: 71ccb1f4c490fdebc7008e884384e7809b849742	2017-01-04 20:13:51 +00:00
drh	87e1e56b5b	Adjust filename creation in test_sqllog.c so that it uses leading zeros on counters, so that files appear in order when sorted lexicographically. FossilOrigin-Name: 8d670973595bd01ffc9b2ab53b965e6d6d22c573	2017-01-04 14:53:53 +00:00
drh	b005f9e620	Performance enhancements in the printf implementation. FossilOrigin-Name: 82e4001b8caef7b31967f3edcbc1a545c081bdbc	2017-01-04 13:09:05 +00:00
drh	49c5ab243b	Factor constant functions out of the inner loop since they are more expensive than the extra OP_Copy needed to move the result into place. FossilOrigin-Name: 80ad317f89c46db0d0d252aefdc036a34a61183d	2017-01-04 04:18:00 +00:00
drh	ad879ffdb5	Clean up the implementation of constant function factorization. FossilOrigin-Name: 2ab997e47998d261bd6190bbce5c09f3fbd4cfd3	2017-01-04 04:10:02 +00:00
drh	1e9b53f9bc	Attempt to factor out constant functions from the interior of table scans, since functions can often be expensive to compute. FossilOrigin-Name: 62e9270a8057d758621da33adb27fad14225f95d	2017-01-04 01:07:24 +00:00