[sql] Import SQLite 3.17.0.

third_party/sqlite/src/test/wal3.test

 # 2010 April 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.
 #
 #***********************************************************************
@@ skipping 43 matching lines @@
       INSERT INTO t1 SELECT a_string(800) FROM t1;             /*  128*/
       INSERT INTO t1 SELECT a_string(800) FROM t1;             /*  256 */
       INSERT INTO t1 SELECT a_string(800) FROM t1;             /*  512 */
       INSERT INTO t1 SELECT a_string(800) FROM t1;             /* 1024 */
       INSERT INTO t1 SELECT a_string(800) FROM t1;             /* 2048 */
       INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 1970;  /* 4018 */
     COMMIT;
     PRAGMA cache_size = 10;
   }
   set x [wal_frame_count test.db-wal 1024]
-  if {$::G(perm:name)=="memsubsys1"} {
+  if {[permutation]=="memsubsys1"} {
     if {$x==4251 || $x==4290} {set x 4056}
   }
   set x
 } 4056
 
 for {set i 1} {$i < 50} {incr i} {
 
   do_test wal3-1.$i.1 {
     set str [a_string 800]
     execsql { UPDATE t1 SET x = $str WHERE rowid = $i }
@@ skipping 138 matching lines @@
   }
   do_test wal3-3.$tn {
     forcedelete test.db test.db-wal test.db-journal
   
     testvfs T
     T filter {} 
     T script sync_counter
     sqlite3 db test.db -vfs T
   
     execsql "PRAGMA synchronous = $syncmode"
+    execsql "PRAGMA checkpoint_fullfsync = 0"
     execsql { PRAGMA journal_mode = WAL }
     execsql { CREATE TABLE filler(a,b,c); }
 
     set ::syncs [list]
     T filter xSync
     execsql {
       CREATE TABLE x(y);
       INSERT INTO x VALUES('z');
       PRAGMA wal_checkpoint;
     }
     T filter {}
     set ::syncs
   } $synccount
 
   db close
   T delete
 }
 
-#-------------------------------------------------------------------------
-# When recovering the contents of a WAL file, a process obtains the WRITER
-# lock, then locks all other bytes before commencing recovery. If it fails
-# to lock all other bytes (because some other process is holding a read
-# lock) it should retry up to 100 times. Then return SQLITE_PROTOCOL to the 
-# caller. Test this (test case wal3-4.3).
-#
-# Also test the effect of hitting an SQLITE_BUSY while attempting to obtain
-# the WRITER lock (should be the same). Test case wal3-4.4.
-# 
-proc lock_callback {method filename handle lock} {
-  lappend ::locks $lock
-}
-do_test wal3-4.1 {
-  testvfs T
-  T filter xShmLock 
-  T script lock_callback
-  set ::locks [list]
-  sqlite3 db test.db -vfs T
-  execsql { SELECT * FROM x }
-  lrange $::locks 0 3
-} [list {0 1 lock exclusive} {1 7 lock exclusive}      \
-        {1 7 unlock exclusive} {0 1 unlock exclusive}  \
-]
-do_test wal3-4.2 {
-  db close
-  set ::locks [list]
-  sqlite3 db test.db -vfs T
-  execsql { SELECT * FROM x }
-  lrange $::locks 0 3
-} [list {0 1 lock exclusive} {1 7 lock exclusive}      \
-        {1 7 unlock exclusive} {0 1 unlock exclusive}  \
-]
-proc lock_callback {method filename handle lock} {
-  if {$lock == "1 7 lock exclusive"} { return SQLITE_BUSY }
-  return SQLITE_OK
-}
-puts "# Warning: This next test case causes SQLite to call xSleep(1) 100 times."
-puts "# Normally this equates to a 100ms delay, but if SQLite is built on unix"
-puts "# without HAVE_USLEEP defined, it may be 100 seconds."
-do_test wal3-4.3 {
-  db close
-  set ::locks [list]
-  sqlite3 db test.db -vfs T
-  catchsql { SELECT * FROM x }
-} {1 {locking protocol}}
-
-puts "# Warning: Same again!"
-proc lock_callback {method filename handle lock} {
-  if {$lock == "0 1 lock exclusive"} { return SQLITE_BUSY }
-  return SQLITE_OK
-}
-do_test wal3-4.4 {
-  db close
-  set ::locks [list]
-  sqlite3 db test.db -vfs T
-  catchsql { SELECT * FROM x }
-} {1 {locking protocol}}
-db close
-T delete
-
 
 #-------------------------------------------------------------------------
 # Only one client may run recovery at a time. Test this mechanism.
 #
 # When client-2 tries to open a read transaction while client-1 is 
 # running recovery, it fails to obtain a lock on an aReadMark[] slot
 # (because they are all locked by recovery). It then tries to obtain
 # a shared lock on the RECOVER lock to see if there really is a
 # recovery running or not.
 #
@@ skipping 298 matching lines @@
   execsql { SELECT * FROM blue } db2
 } {1 2 3 4 5 6}
 do_test wal3-7.2.2 {
   set ::locks
 } {{5 1 lock shared} {5 1 unlock shared} {4 1 lock shared} {4 1 unlock shared}}
 
 db close
 db2 close
 T delete
 
-#-------------------------------------------------------------------------
-# 
-do_test wal3-8.1 {
-  forcedelete test.db test.db-journal test.db wal
-  sqlite3 db test.db
-  sqlite3 db2 test.db
-  execsql {
-    PRAGMA auto_vacuum = off;
-    PRAGMA journal_mode = WAL;
-    CREATE TABLE b(c);
-    INSERT INTO b VALUES('Tehran');
-    INSERT INTO b VALUES('Qom');
-    INSERT INTO b VALUES('Markazi');
-    PRAGMA wal_checkpoint;
-  }
-} {wal 0 5 5}
-do_test wal3-8.2 {
-  execsql { SELECT * FROM b }
-} {Tehran Qom Markazi}
-do_test wal3-8.3 {
-  db eval { SELECT * FROM b } {
-    db eval { INSERT INTO b VALUES('Qazvin') }
-    set r [db2 eval { SELECT * FROM b }]
-    break
-  }
-  set r
-} {Tehran Qom Markazi Qazvin}
-do_test wal3-8.4 {
-  execsql {
-    INSERT INTO b VALUES('Gilan');
-    INSERT INTO b VALUES('Ardabil');
-  }
-} {}
-db2 close
-
-faultsim_save_and_close
-testvfs T -default 1
-faultsim_restore_and_reopen
-T filter xShmLock
-T script lock_callback
-
-proc lock_callback {method file handle spec} {
-  if {$spec == "1 7 unlock exclusive"} {
-    T filter {}
-    set ::r [catchsql { SELECT * FROM b } db2]
-  }
-}
-sqlite3 db test.db
-sqlite3 db2 test.db
-do_test wal3-8.5 {
-  execsql { SELECT * FROM b }
-} {Tehran Qom Markazi Qazvin Gilan Ardabil}
-do_test wal3-8.6 {
-  set ::r
-} {1 {locking protocol}}
-
-db close
-db2 close
-
-faultsim_restore_and_reopen
-sqlite3 db2 test.db
-T filter xShmLock
-T script lock_callback
-proc lock_callback {method file handle spec} {
-  if {$spec == "1 7 unlock exclusive"} {
-    T filter {}
-    set ::r [catchsql { SELECT * FROM b } db2]
-  }
-}
-unset ::r
-do_test wal3-8.5 {
-  execsql { SELECT * FROM b }
-} {Tehran Qom Markazi Qazvin Gilan Ardabil}
-do_test wal3-8.6 {
-  set ::r
-} {1 {locking protocol}}
-
-db close
-db2 close
-T delete
 
 #-------------------------------------------------------------------------
 # When a connection opens a read-lock on the database, it searches for
 # an aReadMark[] slot that is already set to the mxFrame value for the
 # new transaction. If it cannot find one, it attempts to obtain an 
 # exclusive lock on an aReadMark[] slot for the purposes of modifying
 # the value, then drops back to a shared-lock for the duration of the
 # transaction.
 #
 # This test case verifies that if an exclusive lock cannot be obtained
@@ skipping 72 matching lines @@
 
     expr {[file size test.db-wal] > [expr 1032*9000]}
   } 1
 
   do_test wal3-10.$tn.2 {
     sql2 {PRAGMA integrity_check}
   } {ok}
 }
 
 finish_test