[sql] Import SQLite 3.17.0.

third_party/sqlite/src/test/pager1.test

 # 2010 June 15
 #
 # 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 511 matching lines @@
 
 # Set up a VFS that snapshots the file-system just before a master journal
 # file is deleted to commit a multi-file transaction. Specifically, the
 # file-system is saved just before the xDelete() call to remove the 
 # master journal file from the file-system.
 #
 set pwd [get_pwd]
 testvfs tv -default 1
 tv script copy_on_mj_delete
 set ::mj_filename_length 0
+set ::mj_delete_cnt 0
 proc copy_on_mj_delete {method filename args} {
   if {[string match *mj* [file tail $filename]]} { 
     #
     # NOTE: Is the file name relative?  If so, add the length of the current
     #       directory.
     #
     if {[is_relative_file $filename]} {
       set ::mj_filename_length \
         [expr {[string length $filename] + [string length $::pwd]}]
     } else {
       set ::mj_filename_length [string length $filename]
     }
     faultsim_save 
+    incr ::mj_delete_cnt
   }
   return SQLITE_OK
 }
 
 foreach {tn1 tcl} {
   1 { set prefix "test.db" }
   2 { 
     # This test depends on the underlying VFS being able to open paths
     # 512 bytes in length. The idea is to create a hot-journal file that
     # contains a master-journal pointer so large that it could contain
@@ skipping 17 matching lines @@
       set p [string repeat $dirname $nDir]
       file mkdir $p
       cd $p
     }
 
     set padding [string repeat x [expr $nPadding %32]]
     set prefix "test.db${padding}"
   }
 } {
   eval $tcl
-  foreach {tn2 sql} {
+  foreach {tn2 sql usesMJ} {
     o { 
       PRAGMA main.synchronous=OFF;
       PRAGMA aux.synchronous=OFF;
       PRAGMA journal_mode = DELETE;
-    }
+    } 0
     o512 { 
       PRAGMA main.synchronous=OFF;
       PRAGMA aux.synchronous=OFF;
       PRAGMA main.page_size = 512;
       PRAGMA aux.page_size = 512;
       PRAGMA journal_mode = DELETE;
-    }
+    } 0
     n { 
       PRAGMA main.synchronous=NORMAL;
       PRAGMA aux.synchronous=NORMAL;
       PRAGMA journal_mode = DELETE;
-    }
+    } 1
     f { 
       PRAGMA main.synchronous=FULL;
       PRAGMA aux.synchronous=FULL;
       PRAGMA journal_mode = DELETE;
-    }
+    } 1
+    w1 { 
+      PRAGMA main.synchronous=NORMAL;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA journal_mode = WAL;
+    } 0
+    w2 { 
+      PRAGMA main.synchronous=NORMAL;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA main.journal_mode=DELETE;
+      PRAGMA aux.journal_mode=WAL;
+    } 0
+    o1a { 
+      PRAGMA main.synchronous=FULL;
+      PRAGMA aux.synchronous=OFF;
+      PRAGMA journal_mode=DELETE;
+    } 0
+    o1b { 
+      PRAGMA main.synchronous=OFF;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA journal_mode=DELETE;
+    } 0
+    m1 { 
+      PRAGMA main.synchronous=NORMAL;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA main.journal_mode=DELETE;
+      PRAGMA aux.journal_mode = MEMORY;
+    } 0
+    t1 { 
+      PRAGMA main.synchronous=NORMAL;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA main.journal_mode=DELETE;
+      PRAGMA aux.journal_mode = TRUNCATE;
+    } 1
+    p1 { 
+      PRAGMA main.synchronous=NORMAL;
+      PRAGMA aux.synchronous=NORMAL;
+      PRAGMA main.journal_mode=DELETE;
+      PRAGMA aux.journal_mode = PERSIST;
+    } 1
   } {
 
     set tn "${tn1}.${tn2}"
   
     # Set up a connection to have two databases, test.db (main) and 
     # test.db2 (aux). Then run a multi-file transaction on them. The
     # VFS will snapshot the file-system just before the master-journal
     # file is deleted to commit the transaction.
     #
     tv filter xDelete
     do_test pager1-4.4.$tn.1 {
+      set ::mj_delete_cnt 0
       faultsim_delete_and_reopen $prefix
       execsql "
         ATTACH '${prefix}2' AS aux;
         $sql
         CREATE TABLE a(x);
         CREATE TABLE aux.b(x);
         INSERT INTO a VALUES('double-you');
         INSERT INTO a VALUES('why');
         INSERT INTO a VALUES('zed');
         INSERT INTO b VALUES('won');
         INSERT INTO b VALUES('too');
         INSERT INTO b VALUES('free');
       "
       execsql {
         BEGIN;
           INSERT INTO a SELECT * FROM b WHERE rowid<=3;
           INSERT INTO b SELECT * FROM a WHERE rowid<=3;
         COMMIT;
       }
     } {}
     tv filter {}
+
+    # Verify that a master journal was deleted only for those cases where
+    # master journals really ought to be used
+    #
+    do_test pager1-4.4.$tn.1b {
+      set ::mj_delete_cnt
+    } $usesMJ
     
     # Check that the transaction was committed successfully.
     #
     do_execsql_test pager1-4.4.$tn.2 {
       SELECT * FROM a
     } {double-you why zed won too free}
     do_execsql_test pager1-4.4.$tn.3 {
       SELECT * FROM b
     } {won too free double-you why zed}
     
-    # Restore the file-system and reopen the databases. Check that it now
-    # appears that the transaction was not committed (because the file-system
-    # was restored to the state where it had not been).
-    #
-    do_test pager1-4.4.$tn.4 {
-      faultsim_restore_and_reopen $prefix
-      execsql "ATTACH '${prefix}2' AS aux"
-    } {}
-    do_execsql_test pager1-4.4.$tn.5 {SELECT * FROM a} {double-you why zed}
-    do_execsql_test pager1-4.4.$tn.6 {SELECT * FROM b} {won too free}
+    if {$usesMJ} {
+      # Restore the file-system and reopen the databases. Check that it now
+      # appears that the transaction was not committed (because the file-system
+      # was restored to the state where it had not been).
+      #
+      do_test pager1-4.4.$tn.4 {
+        faultsim_restore_and_reopen $prefix
+        execsql "ATTACH '${prefix}2' AS aux"
+      } {}
+      do_execsql_test pager1-4.4.$tn.5 {SELECT * FROM a} {double-you why zed}
+      do_execsql_test pager1-4.4.$tn.6 {SELECT * FROM b} {won too free}
+    }
     
     # Restore the file-system again. This time, before reopening the databases,
     # delete the master-journal file from the file-system. It now appears that
     # the transaction was committed (no master-journal file == no rollback).
     #
     do_test pager1-4.4.$tn.7 {
-      faultsim_restore_and_reopen $prefix
-      foreach f [glob ${prefix}-mj*] { forcedelete $f }
+      if {$::mj_delete_cnt>0} {
+        faultsim_restore_and_reopen $prefix
+        foreach f [glob ${prefix}-mj*] { forcedelete $f }
+      } else {
+        db close
+        sqlite3 db $prefix
+      }
       execsql "ATTACH '${prefix}2' AS aux"
+      glob -nocomplain ${prefix}-mj*
     } {}
     do_execsql_test pager1-4.4.$tn.8 {
       SELECT * FROM a
     } {double-you why zed won too free}
     do_execsql_test pager1-4.4.$tn.9 {
       SELECT * FROM b
     } {won too free double-you why zed}
   }
 
   cd $pwd
 }
 db close
 tv delete
 forcedelete $dirname
 
-
 # Set up a VFS to make a copy of the file-system just before deleting a
 # journal file to commit a transaction. The transaction modifies exactly
 # two database pages (and page 1 - the change counter).
 #
 testvfs tv -default 1
 tv sectorsize 512
 tv script copy_on_journal_delete
 tv filter xDelete
 proc copy_on_journal_delete {method filename args} {
   if {[string match *journal $filename]} faultsim_save 
@@ skipping 641 matching lines @@
 db2 close
 
 do_test pager1-9.3.1 {
   testvfs tv -default 1
   tv sectorsize 4096
   faultsim_delete_and_reopen
 
   execsql { PRAGMA page_size = 1024 }
   for {set ii 0} {$ii < 4} {incr ii} { execsql "CREATE TABLE t${ii}(a, b)" }
 } {}
-do_test pager1-9.3.2 {
-  sqlite3 db2 test.db2
-
-  execsql {
-    PRAGMA page_size = 4096;
-    PRAGMA synchronous = OFF;
-    CREATE TABLE t1(a, b);
-    CREATE TABLE t2(a, b);
-  } db2
-
-  sqlite3_backup B db2 main db main
-  B step 30
-  list [B step 10000] [B finish]
-} {SQLITE_DONE SQLITE_OK}
-do_test pager1-9.3.3 {
-  db2 close
-  db close
-  tv delete
-  file size test.db2
-} [file size test.db]
+if {[nonzero_reserved_bytes]} {
+  # backup with a page size changes is not possible with the codec
+  #
+  do_test pager1-9.3.2codec {
+    sqlite3 db2 test.db2
+    execsql {
+      PRAGMA page_size = 4096;
+      PRAGMA synchronous = OFF;
+      CREATE TABLE t1(a, b);
+      CREATE TABLE t2(a, b);
+    } db2
+    sqlite3_backup B db2 main db main
+    B step 30
+    list [B step 10000] [B finish]
+  } {SQLITE_READONLY SQLITE_READONLY}
+  do_test pager1-9.3.3codec {
+    db2 close
+    db close
+    tv delete
+    file size test.db2
+  } [file size test.db2]
+} else {
+  do_test pager1-9.3.2 {
+    sqlite3 db2 test.db2
+    execsql {
+      PRAGMA page_size = 4096;
+      PRAGMA synchronous = OFF;
+      CREATE TABLE t1(a, b);
+      CREATE TABLE t2(a, b);
+    } db2
+    sqlite3_backup B db2 main db main
+    B step 30
+    list [B step 10000] [B finish]
+  } {SQLITE_DONE SQLITE_OK}
+  do_test pager1-9.3.3 {
+    db2 close
+    db close
+    tv delete
+    file size test.db2
+  } [file size test.db]
+}
 
 do_test pager1-9.4.1 {
   faultsim_delete_and_reopen
   sqlite3 db2 test.db2
   execsql {
     PRAGMA page_size = 4096;
     CREATE TABLE t1(a, b);
     CREATE TABLE t2(a, b);
   } db2
   sqlite3_backup B db2 main db main
@@ skipping 1011 matching lines @@
   faultsim_delete_and_reopen
   execsql {
     PRAGMA page_size = 1024;
     PRAGMA auto_vacuum = full;
     PRAGMA locking_mode=exclusive;
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES(1, 2);
   }
   file size test.db
 } [expr 1024*3]
-do_test pager1-29.2 {
-  execsql {
-    PRAGMA page_size = 4096;
-    VACUUM;
-  }
-  file size test.db
-} [expr 4096*3]
+if {[nonzero_reserved_bytes]} {
+  # VACUUM with size changes is not possible with the codec.
+  do_test pager1-29.2 {
+    catchsql {
+      PRAGMA page_size = 4096;
+      VACUUM;
+    }
+  } {1 {attempt to write a readonly database}}
+} else {
+  do_test pager1-29.2 {
+    execsql {
+      PRAGMA page_size = 4096;
+      VACUUM;
+    }
+    file size test.db
+  } [expr 4096*3]
+}
 
 #-------------------------------------------------------------------------
 # Test that if an empty database file (size 0 bytes) is opened in 
 # exclusive-locking mode, any journal file is deleted from the file-system
 # without being rolled back. And that the RESERVED lock obtained while
 # doing this is not released.
 #
 do_test pager1-30.1 {
   db close
   delete_file test.db
@@ skipping 397 matching lines @@
   db eval { SELECT * FROM t2 }
   sqlite3_db_status db CACHE_MISS 1
 } {0 3 0}
 
 do_test 43.3 {
   db eval { SELECT * FROM t3 }
   sqlite3_db_status db CACHE_MISS 0
 } {0 1 0}
 
 finish_test