Index: src/backup.c
==================================================================
--- src/backup.c
+++ src/backup.c
@@ -605,11 +605,11 @@
     }
     *pp = p->pNext;
   }
 
   /* If a transaction is still open on the Btree, roll it back. */
-  sqlite3BtreeRollback(p->pDest, SQLITE_OK);
+  sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
 
   /* Set the error code of the destination database handle. */
   rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
   if( p->pDestDb ){
     sqlite3Error(p->pDestDb, rc);

Index: src/btree.c
==================================================================
--- src/btree.c
+++ src/btree.c
@@ -2211,11 +2211,11 @@
 
   /* Rollback any active transaction and free the handle structure.
   ** The call to sqlite3BtreeRollback() drops any table-locks held by
   ** this handle.
   */
-  sqlite3BtreeRollback(p, SQLITE_OK);
+  sqlite3BtreeRollback(p, SQLITE_OK, 0);
   sqlite3BtreeLeave(p);
 
   /* If there are still other outstanding references to the shared-btree
   ** structure, return now. The remainder of this procedure cleans 
   ** up the shared-btree.
@@ -3504,31 +3504,32 @@
   return rc;
 }
 
 /*
 ** This routine sets the state to CURSOR_FAULT and the error
-** code to errCode for every cursor on BtShared that pBtree
-** references.
-**
-** Every cursor is tripped, including cursors that belong
-** to other database connections that happen to be sharing
-** the cache with pBtree.
-**
-** This routine gets called when a rollback occurs.
-** All cursors using the same cache must be tripped
-** to prevent them from trying to use the btree after
-** the rollback.  The rollback may have deleted tables
-** or moved root pages, so it is not sufficient to
-** save the state of the cursor.  The cursor must be
-** invalidated.
-*/
-void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
+** code to errCode for every cursor on any BtShared that pBtree
+** references.  Or if the writeOnly flag is set to 1, then only
+** trip write cursors and leave read cursors unchanged.
+**
+** Every cursor is a candidate to be tripped, including cursors
+** that belong to other database connections that happen to be
+** sharing the cache with pBtree.
+**
+** This routine gets called when a rollback occurs.  The writeOnly
+** flag is set to 1 if the transaction did not make any schema
+** changes, in which case the read cursors can continue operating.
+** If schema changes did occur in the transaction, then both read
+** and write cursors must both be tripped.
+*/
+void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){
   BtCursor *p;
+  assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
   if( pBtree==0 ) return;
   sqlite3BtreeEnter(pBtree);
   for(p=pBtree->pBt->pCursor; p; p=p->pNext){
     int i;
+    if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ) continue;
     sqlite3BtreeClearCursor(p);
     p->eState = CURSOR_FAULT;
     p->skipNext = errCode;
     for(i=0; i<=p->iPage; i++){
       releasePage(p->apPage[i]);
@@ -3537,31 +3538,36 @@
   }
   sqlite3BtreeLeave(pBtree);
 }
 
 /*
-** Rollback the transaction in progress.  All cursors will be
-** invalided by this operation.  Any attempt to use a cursor
-** that was open at the beginning of this operation will result
-** in an error.
+** Rollback the transaction in progress.
+**
+** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
+** Only write cursors are tripped if writeOnly is true but all cursors are
+** tripped if writeOnly is false.  Any attempt to use
+** a tripped cursor will result in an error.
 **
 ** This will release the write lock on the database file.  If there
 ** are no active cursors, it also releases the read lock.
 */
-int sqlite3BtreeRollback(Btree *p, int tripCode){
+int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){
   int rc;
   BtShared *pBt = p->pBt;
   MemPage *pPage1;
 
+  assert( writeOnly==1 || writeOnly==0 );
+  assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
   sqlite3BtreeEnter(p);
   if( tripCode==SQLITE_OK ){
     rc = tripCode = saveAllCursors(pBt, 0, 0);
+    if( rc ) writeOnly = 0;
   }else{
     rc = SQLITE_OK;
   }
   if( tripCode ){
-    sqlite3BtreeTripAllCursors(p, tripCode);
+    sqlite3BtreeTripAllCursors(p, tripCode, writeOnly);
   }
   btreeIntegrity(p);
 
   if( p->inTrans==TRANS_WRITE ){
     int rc2;

Index: src/btree.h
==================================================================
--- src/btree.h
+++ src/btree.h
@@ -81,11 +81,11 @@
 int sqlite3BtreeGetAutoVacuum(Btree *);
 int sqlite3BtreeBeginTrans(Btree*,int);
 int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);
 int sqlite3BtreeCommitPhaseTwo(Btree*, int);
 int sqlite3BtreeCommit(Btree*);
-int sqlite3BtreeRollback(Btree*,int);
+int sqlite3BtreeRollback(Btree*,int,int);
 int sqlite3BtreeBeginStmt(Btree*,int);
 int sqlite3BtreeCreateTable(Btree*, int*, int flags);
 int sqlite3BtreeIsInTrans(Btree*);
 int sqlite3BtreeIsInReadTrans(Btree*);
 int sqlite3BtreeIsInBackup(Btree*);
@@ -114,11 +114,11 @@
 #define BTREE_BLOBKEY    2    /* Table has keys only - no data */
 
 int sqlite3BtreeDropTable(Btree*, int, int*);
 int sqlite3BtreeClearTable(Btree*, int, int*);
 int sqlite3BtreeClearTableOfCursor(BtCursor*);
-void sqlite3BtreeTripAllCursors(Btree*, int);
+void sqlite3BtreeTripAllCursors(Btree*, int, int);
 
 void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
 int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
 
 int sqlite3BtreeNewDb(Btree *p);

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -1109,17 +1109,19 @@
   sqlite3_free(db);
 }
 
 /*
 ** Rollback all database files.  If tripCode is not SQLITE_OK, then
-** any open cursors are invalidated ("tripped" - as in "tripping a circuit
+** any write cursors are invalidated ("tripped" - as in "tripping a circuit
 ** breaker") and made to return tripCode if there are any further
-** attempts to use that cursor.
+** attempts to use that cursor.  Read cursors remain open and valid
+** but are "saved" in case the table pages are moved around.
 */
 void sqlite3RollbackAll(sqlite3 *db, int tripCode){
   int i;
   int inTrans = 0;
+  int schemaChange;
   assert( sqlite3_mutex_held(db->mutex) );
   sqlite3BeginBenignMalloc();
 
   /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). 
   ** This is important in case the transaction being rolled back has
@@ -1126,18 +1128,19 @@
   ** modified the database schema. If the b-tree mutexes are not taken
   ** here, then another shared-cache connection might sneak in between
   ** the database rollback and schema reset, which can cause false
   ** corruption reports in some cases.  */
   sqlite3BtreeEnterAll(db);
+  schemaChange = (db->flags & SQLITE_InternChanges)!=0 && db->init.busy==0;
 
   for(i=0; i<db->nDb; i++){
     Btree *p = db->aDb[i].pBt;
     if( p ){
       if( sqlite3BtreeIsInTrans(p) ){
         inTrans = 1;
       }
-      sqlite3BtreeRollback(p, tripCode);
+      sqlite3BtreeRollback(p, tripCode, !schemaChange);
     }
   }
   sqlite3VtabRollback(db);
   sqlite3EndBenignMalloc();
 

Index: src/vdbe.c
==================================================================
--- src/vdbe.c
+++ src/vdbe.c
@@ -2823,23 +2823,28 @@
           goto vdbe_return;
         }
         db->isTransactionSavepoint = 0;
         rc = p->rc;
       }else{
+        int isSchemaChange;
         iSavepoint = db->nSavepoint - iSavepoint - 1;
         if( p1==SAVEPOINT_ROLLBACK ){
+          isSchemaChange = (db->flags & SQLITE_InternChanges)!=0;
           for(ii=0; ii<db->nDb; ii++){
-            sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, SQLITE_ABORT);
+            sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, SQLITE_ABORT,
+                                       isSchemaChange==0);
           }
+        }else{
+          isSchemaChange = 0;
         }
         for(ii=0; ii<db->nDb; ii++){
           rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
           if( rc!=SQLITE_OK ){
             goto abort_due_to_error;
           }
         }
-        if( p1==SAVEPOINT_ROLLBACK && (db->flags&SQLITE_InternChanges)!=0 ){
+        if( isSchemaChange ){
           sqlite3ExpirePreparedStatements(db);
           sqlite3ResetAllSchemasOfConnection(db);
           db->flags = (db->flags | SQLITE_InternChanges);
         }
       }
@@ -3232,11 +3237,11 @@
   assert( p->bIsReader );
   assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
           || p->readOnly==0 );
 
   if( p->expired ){
-    rc = SQLITE_ABORT;
+    rc = SQLITE_ABORT_ROLLBACK;
     break;
   }
 
   nField = 0;
   pKeyInfo = 0;

Index: src/wal.c
==================================================================
--- src/wal.c
+++ src/wal.c
@@ -2504,11 +2504,11 @@
     ** was in before the client began writing to the database. 
     */
     memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
 
     for(iFrame=pWal->hdr.mxFrame+1; 
-        ALWAYS(rc==SQLITE_OK) && iFrame<=iMax; 
+        rc==SQLITE_OK && iFrame<=iMax; 
         iFrame++
     ){
       /* This call cannot fail. Unless the page for which the page number
       ** is passed as the second argument is (a) in the cache and 
       ** (b) has an outstanding reference, then xUndo is either a no-op
@@ -2523,11 +2523,10 @@
       assert( walFramePgno(pWal, iFrame)!=1 );
       rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
     }
     if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);
   }
-  assert( rc==SQLITE_OK );
   return rc;
 }
 
 /* 
 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 

Index: test/capi3.test
==================================================================
--- test/capi3.test
+++ test/capi3.test
@@ -910,24 +910,24 @@
 do_test capi3-11.9.3 {
   sqlite3_get_autocommit $DB
 } 1
 do_test capi3-11.10 {
   sqlite3_step $STMT
-} {SQLITE_ERROR}
+} {SQLITE_ROW}
 ifcapable !autoreset {
   # If SQLITE_OMIT_AUTORESET is defined, then the statement must be
   # reset() before it can be passed to step() again.
   do_test capi3-11.11a { sqlite3_step $STMT } {SQLITE_MISUSE}
   do_test capi3-11.11b { sqlite3_reset $STMT } {SQLITE_ABORT}
 }
 do_test capi3-11.11 {
   sqlite3_step $STMT
-} {SQLITE_ROW}
+} {SQLITE_DONE}
 do_test capi3-11.12 {
   sqlite3_step $STMT
   sqlite3_step $STMT
-} {SQLITE_DONE}
+} {SQLITE_ROW}
 do_test capi3-11.13 {
   sqlite3_finalize $STMT
 } {SQLITE_OK}
 do_test capi3-11.14 {
   execsql {

Index: test/capi3c.test
==================================================================
--- test/capi3c.test
+++ test/capi3c.test
@@ -861,24 +861,24 @@
 do_test capi3c-11.9.3 {
   sqlite3_get_autocommit $DB
 } 1
 do_test capi3c-11.10 {
   sqlite3_step $STMT
-} {SQLITE_ABORT}
+} {SQLITE_ROW}
 ifcapable !autoreset {
   # If SQLITE_OMIT_AUTORESET is defined, then the statement must be
   # reset() before it can be passed to step() again.
   do_test capi3-11.11a { sqlite3_step $STMT } {SQLITE_MISUSE}
   do_test capi3-11.11b { sqlite3_reset $STMT } {SQLITE_ABORT}
 }
 do_test capi3c-11.11 {
   sqlite3_step $STMT
-} {SQLITE_ROW}
+} {SQLITE_DONE}
 do_test capi3c-11.12 {
   sqlite3_step $STMT
   sqlite3_step $STMT
-} {SQLITE_DONE}
+} {SQLITE_ROW}
 do_test capi3c-11.13 {
   sqlite3_finalize $STMT
 } {SQLITE_OK}
 do_test capi3c-11.14 {
   execsql {

Index: test/misc8.test
==================================================================
--- test/misc8.test
+++ test/misc8.test
@@ -32,12 +32,13 @@
   SELECT eval('SELECT * FROM t1 ORDER BY a',',');
 } {1,2,3,4,5,6,7,,9}
 do_catchsql_test misc8-1.4 {
   BEGIN;
   INSERT INTO t1 VALUES(10,11,12);
-  SELECT coalesce(b, eval('ROLLBACK')) FROM t1 ORDER BY a;
-} {1 {abort due to ROLLBACK}}
+  SELECT a, coalesce(b, eval('ROLLBACK; SELECT ''bam'';')), c
+   FROM t1 ORDER BY a;
+} {0 {1 2 3 4 5 6 7 bam 9}}
 do_catchsql_test misc8-1.5 {
   INSERT INTO t1 VALUES(10,11,12);
   SELECT a, coalesce(b, eval('SELECT ''bam''')), c
     FROM t1
    ORDER BY rowid;
@@ -45,8 +46,16 @@
 do_catchsql_test misc8-1.6 {
   SELECT a, coalesce(b, eval('DELETE FROM t1; SELECT ''bam''')), c
     FROM t1
    ORDER BY rowid;
 } {0 {1 2 3 4 5 6 7 bam {}}}
+do_catchsql_test misc8-1.7 {
+  INSERT INTO t1 VALUES(1,2,3),(4,5,6),(7,null,9);
+  BEGIN;
+  CREATE TABLE t2(x);
+  SELECT a, coalesce(b, eval('ROLLBACK; SELECT ''bam''')), c
+    FROM t1
+   ORDER BY rowid;
+} {1 {abort due to ROLLBACK}}
 
 
 finish_test

Index: test/rollback.test
==================================================================
--- test/rollback.test
+++ test/rollback.test
@@ -58,15 +58,15 @@
   
   # Try to continue with the SELECT statement
   #
   do_test rollback-1.5 {
     sqlite3_step $STMT
-  } {SQLITE_ERROR}
+  } {SQLITE_ROW}
 
   # Restart the SELECT statement
   #
-  do_test rollback-1.6 { sqlite3_reset $STMT } {SQLITE_ABORT}
+  do_test rollback-1.6 { sqlite3_reset $STMT } {SQLITE_OK}
 } else {
   do_test rollback-1.6 { sqlite3_reset $STMT } {SQLITE_OK}
 }
 
 do_test rollback-1.7 {

Index: test/savepoint.test
==================================================================
--- test/savepoint.test
+++ test/savepoint.test
@@ -313,11 +313,11 @@
     catchsql {ROLLBACK TO def}
   } {0 {}}
   do_test savepoint-5.3.2.3 {
     set rc [catch {seek $fd 0; read $fd} res]
     set rc
-  } {1}
+  } {0}
   do_test savepoint-5.3.3 {
     catchsql  {RELEASE def}
   } {0 {}}
   do_test savepoint-5.3.4 {
     close $fd

Index: test/savepoint7.test
==================================================================
--- test/savepoint7.test
+++ test/savepoint7.test
@@ -28,10 +28,11 @@
     SAVEPOINT x1;
   }
   db eval {SELECT * FROM t1} {
     db eval {
       SAVEPOINT x2;
+      CREATE TABLE IF NOT EXISTS t3(xyz);
       INSERT INTO t2 VALUES($a,$b,$c);
       RELEASE x2;
     }
   }
   db eval {SELECT * FROM t2; RELEASE x1}
@@ -44,11 +45,11 @@
       SAVEPOINT x2;
       INSERT INTO t2 VALUES($a,$b,$c);
       RELEASE x2;
     }
   }
-  db eval {SELECT * FROM t2}
+  db eval {SELECT * FROM t2;}
 } {1 2 3 4 5 6 7 8 9}
 
 do_test savepoint7-1.3 {
   db eval {DELETE FROM t2; BEGIN;}
   db eval {SELECT * FROM t1} {
@@ -63,11 +64,11 @@
 
 # However, a ROLLBACK of an inner savepoint will abort all queries, including
 # queries in outer contexts.
 #
 do_test savepoint7-2.1 {
-  db eval {DELETE FROM t2; SAVEPOINT x1;}
+  db eval {DELETE FROM t2; SAVEPOINT x1; CREATE TABLE t4(abc);}
   set rc [catch {
     db eval {SELECT * FROM t1} {
       db eval {
         SAVEPOINT x2;
         INSERT INTO t2 VALUES($a,$b,$c);
@@ -83,14 +84,15 @@
   db eval {DELETE FROM t2;}
   set rc [catch {
     db eval {SELECT * FROM t1} {
       db eval {
         SAVEPOINT x2;
+        CREATE TABLE t5(pqr);
         INSERT INTO t2 VALUES($a,$b,$c);
         ROLLBACK TO x2;
       }
     }
   } msg]
   list $rc $msg [db eval {SELECT * FROM t2}]
 } {1 {callback requested query abort} {}}
 
 finish_test

Index: test/tkt-f777251dc7a.test
==================================================================
--- test/tkt-f777251dc7a.test
+++ test/tkt-f777251dc7a.test
@@ -36,12 +36,14 @@
   catch {db eval {INSERT OR ROLLBACK INTO t1 VALUES(1)}}
 }
 db function force_rollback force_rollback
 
 do_test tkt-f7772-1.2 {
+breakpoint
   catchsql {
     BEGIN IMMEDIATE;
+    CREATE TABLE xyzzy(abc);
     SELECT x, force_rollback(), EXISTS(SELECT 1 FROM t3 WHERE w=x) FROM t2;
   }
 } {1 {abort due to ROLLBACK}}
 do_test tkt-f7772-1.3 {
   sqlite3_get_autocommit db
@@ -65,11 +67,11 @@
     CREATE TEMP TABLE t3(w, z);
   }
   catchsql {
     SELECT x, force_rollback(), EXISTS(SELECT 1 FROM t3 WHERE w=x) FROM t2
   }
-} {1 {callback requested query abort}}
+} {1 {abort due to ROLLBACK}}
 do_test tkt-f7772-2.3 {
   sqlite3_get_autocommit db
 } {1}
 
 do_test tkt-f7772-3.1 {

Index: test/trans3.test
==================================================================
--- test/trans3.test
+++ test/trans3.test
@@ -50,11 +50,11 @@
 } 1
 do_test trans3-1.4 {
   db eval {SELECT * FROM t1}
 } {1 2 3 4}
 do_test trans3-1.5 {
-  db eval BEGIN
+  db eval {BEGIN; CREATE TABLE xyzzy(abc);}
   db eval {INSERT INTO t1 VALUES(5);}
   set ::ecode {}
   set x [catch {
      db eval {SELECT * FROM t1} {
         if {[catch {db eval ROLLBACK} errmsg]} {