Add //third_party/sqlite to dirs_to_snapshot, remove net_sql.patch

third_party/sqlite/src/test/io.test

 # 2007 August 21
 #
 # 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.
 #
 #***********************************************************************
 #
 # The focus of this file is testing some specific characteristics of the 
 # IO traffic generated by SQLite (making sure SQLite is not writing out
 # more database pages than it has to, stuff like that).
 #
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set ::testprefix io
 
 db close
 sqlite3_simulate_device
 sqlite3 db test.db -vfs devsym
 
 # Test summary:
 #
 # io-1.* -  Test that quick-balance does not journal pages unnecessarily.
 #
 # io-2.* -  Test the "atomic-write optimization".
 #
 # io-3.* -  Test the IO traffic enhancements triggered when the 
 #           IOCAP_SEQUENTIAL device capability flag is set (no 
 #           fsync() calls on the journal file).
 #
 # io-4.* -  Test the IO traffic enhancements triggered when the 
 #           IOCAP_SAFE_APPEND device capability flag is set (fewer 
 #           fsync() calls on the journal file, no need to set nRec
 #           field in the single journal header).
 #
 # io-5.* -  Test that the default page size is selected and used 
 #           correctly.
+#
+# io-6.* -  Test that the pager-cache is not being flushed unnecessarily 
+#           after a transaction that uses the special atomic-write path
+#           is committed.
 #           
 
 set ::nWrite 0
 proc nWrite {db} {
   set bt [btree_from_db $db]
   db_enter $db
   array set stats [btree_pager_stats $bt]
   db_leave $db
   set res [expr $stats(write) - $::nWrite]
   set ::nWrite $stats(write)
@@ skipping 88 matching lines @@
 } {2 4}
 
 # Set the device-characteristic mask to include the SQLITE_IOCAP_ATOMIC,
 # then do another INSERT similar to the one in io-2.2. This should
 # only write 1 page and require a single fsync().
 # 
 # The single fsync() is the database file. Only one page is reported as
 # written because page 1 - the change-counter page - is written using
 # an out-of-band method that bypasses the write counter.
 #
+# UPDATE: As of [05f98d4eec] (adding SQLITE_DBSTATUS_CACHE_WRITE), the
+# second write is also counted. So this now reports two writes and a
+# single fsync.
+#
 sqlite3_simulate_device -char atomic
 do_test io-2.3 {
   execsql { INSERT INTO abc VALUES(3, 4) }
   list [nWrite db] [nSync]
-} {1 1}
+} {2 1}
 
 # Test that the journal file is not created and the change-counter is
 # updated when the atomic-write optimization is used.
 #
 do_test io-2.4.1 {
   execsql {
     BEGIN;
     INSERT INTO abc VALUES(5, 6);
   }
   sqlite3 db2 test.db -vfs devsym
@@ skipping 32 matching lines @@
 
 # Test that the journal file is created and sync()d if the transaction
 # modifies a single database page and also appends a page to the file.
 # Internally, this case is handled differently to the one above. The
 # journal file is not actually created until the 'COMMIT' statement
 # is executed.
 #
 # Changed 2010-03-27:  The size of the database is now stored in 
 # bytes 28..31 and so when a page is added to the database, page 1
 # is immediately modified and the journal file immediately comes into
-# existance.  To fix this test, the BEGIN is changed into a a
+# existence.  To fix this test, the BEGIN is changed into a a
 # BEGIN IMMEDIATE and the INSERT is omitted.
 #
 do_test io-2.6.1 {
   execsql {
     BEGIN IMMEDIATE;
     -- INSERT INTO abc VALUES(9, randstr(1000,1000));
   }
   file exists test.db-journal
 } {0}
 do_test io-2.6.2 {
   # Create a file at "test.db-journal". This will prevent SQLite from
   # opening the journal for exclusive access. As a result, the COMMIT
   # should fail with SQLITE_CANTOPEN and the transaction rolled back.
   #
   file mkdir test.db-journal
   catchsql {
     INSERT INTO abc VALUES(9, randstr(1000,1000));
     COMMIT
   }
 } {1 {unable to open database file}}
 do_test io-2.6.3 {
-  file delete -force test.db-journal
+  forcedelete test.db-journal
   catchsql { COMMIT }
 } {0 {}}
 do_test io-2.6.4 {
   execsql { SELECT * FROM abc }
 } {1 2 3 4 5 6 7 8}
 
 # Test that if the database modification is part of multi-file commit,
 # the journal file is always created. In this case, the journal file
 # is created during execution of the COMMIT statement, so we have to
 # use the same technique to check that it is created as in the above 
 # block.
-file delete -force test2.db test2.db-journal
+forcedelete test2.db test2.db-journal
 ifcapable attach {
   do_test io-2.7.1 {
     execsql {
       ATTACH 'test2.db' AS aux;
       PRAGMA aux.page_size = 1024;
       CREATE TABLE aux.abc2(a, b);
       BEGIN;
       INSERT INTO abc VALUES(9, 10);
     }
     file exists test.db-journal
   } {0}
   do_test io-2.7.2 {
     execsql { INSERT INTO abc2 SELECT * FROM abc }
     file exists test2.db-journal
   } {0}
   do_test io-2.7.3 {
     execsql { SELECT * FROM abc UNION ALL SELECT * FROM abc2 }
   } {1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10}
   do_test io-2.7.4 {
     file mkdir test2.db-journal
     catchsql { COMMIT }
   } {1 {unable to open database file}}
   do_test io-2.7.5 {
-    file delete -force test2.db-journal
+    forcedelete test2.db-journal
     catchsql { COMMIT }
   } {1 {cannot commit - no transaction is active}}
   do_test io-2.7.6 {
     execsql { SELECT * FROM abc UNION ALL SELECT * FROM abc2 }
   } {1 2 3 4 5 6 7 8}
 }
 
 # Try an explicit ROLLBACK before the journal file is created.
 #
 do_test io-2.8.1 {
@@ skipping 22 matching lines @@
   sqlite3_simulate_device -char atomic -sectorsize 2048
   execsql {
     BEGIN;
     INSERT INTO abc VALUES(9, 10);
   }
   file exists test.db-journal
 } {1}
 do_test io-2.9.2 {
   execsql { ROLLBACK; }
   db close
-  file delete -force test.db test.db-journal
+  forcedelete test.db test.db-journal
   sqlite3 db test.db -vfs devsym
   execsql {
     PRAGMA auto_vacuum = OFF;
     PRAGMA page_size = 2048;
     CREATE TABLE abc(a, b);
   }
   execsql {
     BEGIN;
     INSERT INTO abc VALUES(9, 10);
   }
@@ skipping 50 matching lines @@
 
 } ;# /* ifcapable atomicwrite */
 
 #----------------------------------------------------------------------
 # Test cases io-3.* test the IOCAP_SEQUENTIAL optimization.
 #
 sqlite3_simulate_device -char sequential -sectorsize 0
 ifcapable pager_pragmas {
   do_test io-3.1 {
     db close
-    file delete -force test.db test.db-journal
+    forcedelete test.db test.db-journal
     sqlite3 db test.db -vfs devsym
     db eval {
       PRAGMA auto_vacuum=OFF;
     }
     # File size might be 1 due to the hack to work around ticket #3260.
     # Search for #3260 in os_unix.c for additional information.
     expr {[file size test.db]>1}
   } {0}
   do_test io-3.2 {
     execsql { CREATE TABLE abc(a, b) }
@@ skipping 148 matching lines @@
          {atomic}               512      8192
          {atomic512}            512      1024
          {atomic2K}             512      2048
          {atomic2K}            4096      4096
          {atomic2K atomic}      512      8192
          {atomic64K}            512      1024
 } {
   incr tn
   if {$pgsize>$::SQLITE_MAX_PAGE_SIZE} continue
   db close
-  file delete -force test.db test.db-journal
+  forcedelete test.db test.db-journal
   sqlite3_simulate_device -char $char -sectorsize $sectorsize
   sqlite3 db test.db -vfs devsym
   db eval {
     PRAGMA auto_vacuum=OFF;
   }
   ifcapable !atomicwrite {
     if {[regexp {^atomic} $char]} continue
   }
   do_test io-5.$tn {
     execsql {
       CREATE TABLE abc(a, b, c);
     }
     expr {[file size test.db]/2}
   } $pgsize
 }
 
+#----------------------------------------------------------------------
+#
+do_test io-6.1 {
+  db close
+  sqlite3_simulate_device -char atomic
+  forcedelete test.db
+  sqlite3 db test.db -vfs devsym
+  execsql {
+    PRAGMA mmap_size = 0;
+    PRAGMA page_size = 1024;
+    PRAGMA cache_size = 2000;
+    CREATE TABLE t1(x);
+    CREATE TABLE t2(x);
+    CREATE TABLE t3(x);
+    CREATE INDEX i3 ON t3(x);
+    INSERT INTO t3 VALUES(randomblob(100));
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+    INSERT INTO t3 SELECT randomblob(100) FROM t3;
+  }
+
+  db_save_and_close
+} {}
+
+foreach {tn sql} {
+  1 { BEGIN;
+        INSERT INTO t1 VALUES('123');
+        INSERT INTO t2 VALUES('456');
+      COMMIT;
+  }
+  2 { BEGIN;
+        INSERT INTO t1 VALUES('123');
+      COMMIT;
+  }
+} {
+
+  # These tests don't work with memsubsys1, as it causes the effective page
+  # cache size to become too small to hold the entire db in memory.
+  if {[permutation] == "memsubsys1"} continue
+
+  db_restore
+  sqlite3 db test.db -vfs devsym
+  execsql {
+    PRAGMA cache_size = 2000;
+    PRAGMA mmap_size = 0;
+    SELECT x FROM t3 ORDER BY rowid;
+    SELECT x FROM t3 ORDER BY x;
+  }
+  do_execsql_test 6.2.$tn.1 { PRAGMA integrity_check } {ok}
+  do_execsql_test 6.2.$tn.2 $sql
+
+  # Corrupt the database file on disk. This should not matter for the
+  # purposes of the following "PRAGMA integrity_check", as the entire
+  # database should be cached in the pager-cache. If corruption is
+  # reported, it indicates that executing $sql caused the pager cache
+  # to be flushed. Which is a bug.
+  hexio_write test.db [expr 1024 * 5] [string repeat 00 2048]
+  do_execsql_test 6.2.$tn.3 { PRAGMA integrity_check } {ok}
+  db close
+}
+
 sqlite3_simulate_device -char {} -sectorsize 0
 finish_test