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

third_party/sqlite/sqlite-src-3080704/test/shared_err.test

+# 2005 December 30
+#
+# 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 the tests in this file are IO errors that occur in a shared
+# cache context. What happens to connection B if one connection A encounters
+# an IO-error whilst reading or writing the file-system?
+#
+# $Id: shared_err.test,v 1.24 2008/10/12 00:27:54 shane Exp $
+
+proc skip {args} {}
+
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+db close
+
+ifcapable !shared_cache||!subquery {
+  finish_test
+  return
+}
+
+set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
+
+do_ioerr_test shared_ioerr-1 -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    CREATE TABLE t1(a,b,c);
+    BEGIN;
+    SELECT * FROM sqlite_master;
+  } db2
+} -sqlbody {
+  SELECT * FROM sqlite_master;
+  INSERT INTO t1 VALUES(1,2,3);
+  BEGIN TRANSACTION;
+  INSERT INTO t1 VALUES(1,2,3);
+  INSERT INTO t1 VALUES(4,5,6);
+  ROLLBACK;
+  SELECT * FROM t1;
+  BEGIN TRANSACTION;
+  INSERT INTO t1 VALUES(1,2,3);
+  INSERT INTO t1 VALUES(4,5,6);
+  COMMIT;
+  SELECT * FROM t1;
+  DELETE FROM t1 WHERE a<100;
+} -cleanup {
+  do_test shared_ioerr-1.$n.cleanup.1 {
+    set res [catchsql {
+      SELECT * FROM t1;
+    } db2]
+    set possible_results [list               \
+      "1 {disk I/O error}"                   \
+      "0 {1 2 3}"                            \
+      "0 {1 2 3 1 2 3 4 5 6}"                \
+      "0 {1 2 3 1 2 3 4 5 6 1 2 3 4 5 6}"    \
+      "0 {}"                                 \
+      "1 {database disk image is malformed}" \
+    ]
+    set rc [expr [lsearch -exact $possible_results $res] >= 0]
+    if {$rc != 1} {
+      puts ""
+      puts "Result: $res"
+    }
+    set rc
+  } {1}
+
+  # The "database disk image is malformed" is a special case that can
+  # occur if an IO error occurs during a rollback in the {SELECT * FROM t1}
+  # statement above. This test is to make sure there is no real database
+  # corruption.
+  db2 close
+  do_test shared_ioerr-1.$n.cleanup.2 {
+    execsql {pragma integrity_check} db
+  } {ok}
+}
+
+do_ioerr_test shared_ioerr-2 -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    BEGIN;
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1(oid) VALUES(NULL);
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    INSERT INTO t1(oid) SELECT NULL FROM t1;
+    UPDATE t1 set a = oid, b = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    CREATE INDEX i1 ON t1(a);
+    COMMIT;
+    BEGIN;
+    SELECT * FROM sqlite_master;
+  } db2
+} -tclbody {
+  set ::residx 0
+  execsql {DELETE FROM t1 WHERE 0 = (a % 2);}
+  incr ::residx
+
+  # When this transaction begins the table contains 512 entries. The
+  # two statements together add 512+146 more if it succeeds. 
+  # (1024/7==146)
+  execsql {BEGIN;}
+  execsql {INSERT INTO t1 SELECT a+1, b FROM t1;}
+  execsql {INSERT INTO t1 SELECT 'string' || a, b FROM t1 WHERE 0 = (a%7);}
+  execsql {COMMIT;}
+
+  incr ::residx
+} -cleanup {
+  catchsql ROLLBACK
+  do_test shared_ioerr-2.$n.cleanup.1 {
+    set res [catchsql {
+      SELECT max(a), min(a), count(*) FROM (SELECT a FROM t1 order by a);
+    } db2]
+    set possible_results [list \
+      {0 {1024 1 1024}}        \
+      {0 {1023 1 512}}         \
+      {0 {string994 1 1170}}   \
+    ]
+    set idx [lsearch -exact $possible_results $res]
+    set success [expr {$idx==$::residx || $res=="1 {disk I/O error}"}]
+    if {!$success} {
+      puts ""
+      puts "Result: \"$res\" ($::residx)"
+    }
+    set success
+  } {1}
+  db2 close
+}
+
+# This test is designed to provoke an IO error when a cursor position is
+# "saved" (because another cursor is going to modify the underlying table). 
+# 
+do_ioerr_test shared_ioerr-3 -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    PRAGMA cache_size = 10;
+    BEGIN;
+    CREATE TABLE t1(a, b, UNIQUE(a, b));
+  } db2
+  for {set i 0} {$i < 200} {incr i} {
+    set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]
+
+    set b [string repeat $i 2000]
+    execsql {INSERT INTO t1 VALUES($a, $b)} db2
+  }
+  execsql {COMMIT} db2
+  set ::DB2 [sqlite3_connection_pointer db2]
+  set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
+  sqlite3_step $::STMT       ;# Cursor points at 000.000.000.000
+  sqlite3_step $::STMT       ;# Cursor points at 001.001.001.001
+
+} -tclbody {
+  execsql {
+    BEGIN;
+    INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
+    UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
+    COMMIT;
+  }
+} -cleanup {
+  set ::steprc  [sqlite3_step $::STMT]
+  set ::column  [sqlite3_column_text $::STMT 0]
+  set ::finalrc [sqlite3_finalize $::STMT]
+
+  # There are three possible outcomes here (assuming persistent IO errors):
+  #
+  # 1. If the [sqlite3_step] did not require any IO (required pages in
+  #    the cache), then the next row ("002...") may be retrieved 
+  #    successfully.
+  #
+  # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
+  #    SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
+  #
+  # 3. If, after the initial IO error, SQLite tried to rollback the
+  #    active transaction and a second IO error was encountered, then
+  #    statement $::STMT will have been aborted. This means [sqlite3_stmt]
+  #    returns SQLITE_ABORT, and the statement cursor does not move. i.e.
+  #    [sqlite3_column] still returns the current row ("001...") and
+  #    [sqlite3_finalize] returns SQLITE_OK.
+  #
+
+  do_test shared_ioerr-3.$n.cleanup.1 {
+    expr {
+      $::steprc eq "SQLITE_ROW" || 
+      $::steprc eq "SQLITE_ERROR" ||
+      $::steprc eq "SQLITE_ABORT" 
+    }
+  } {1}
+  do_test shared_ioerr-3.$n.cleanup.2 {
+    expr {
+      ($::steprc eq "SQLITE_ROW" && $::column eq "002.002.002.002.002") ||
+      ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
+      ($::steprc eq "SQLITE_ABORT" && $::column eq "001.001.001.001.001") 
+    }
+  } {1}
+  do_test shared_ioerr-3.$n.cleanup.3 {
+    expr {
+      ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
+      ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
+      ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
+    }
+  } {1}
+
+# db2 eval {select * from sqlite_master}
+  db2 close
+}
+
+# This is a repeat of the previous test except that this time we
+# are doing a reverse-order scan of the table when the cursor is
+# "saved".
+# 
+do_ioerr_test shared_ioerr-3rev -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    PRAGMA cache_size = 10;
+    BEGIN;
+    CREATE TABLE t1(a, b, UNIQUE(a, b));
+  } db2
+  for {set i 0} {$i < 200} {incr i} {
+    set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]
+
+    set b [string repeat $i 2000]
+    execsql {INSERT INTO t1 VALUES($a, $b)} db2
+  }
+  execsql {COMMIT} db2
+  set ::DB2 [sqlite3_connection_pointer db2]
+  set ::STMT [sqlite3_prepare $::DB2 \
+           "SELECT a FROM t1 ORDER BY a DESC" -1 DUMMY]
+  sqlite3_step $::STMT       ;# Cursor points at 199.199.199.199.199
+  sqlite3_step $::STMT       ;# Cursor points at 198.198.198.198.198
+
+} -tclbody {
+  execsql {
+    BEGIN;
+    INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
+    UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
+    COMMIT;
+  }
+} -cleanup {
+  set ::steprc  [sqlite3_step $::STMT]
+  set ::column  [sqlite3_column_text $::STMT 0]
+  set ::finalrc [sqlite3_finalize $::STMT]
+
+  # There are three possible outcomes here (assuming persistent IO errors):
+  #
+  # 1. If the [sqlite3_step] did not require any IO (required pages in
+  #    the cache), then the next row ("002...") may be retrieved 
+  #    successfully.
+  #
+  # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
+  #    SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
+  #
+  # 3. If, after the initial IO error, SQLite tried to rollback the
+  #    active transaction and a second IO error was encountered, then
+  #    statement $::STMT will have been aborted. This means [sqlite3_stmt]
+  #    returns SQLITE_ABORT, and the statement cursor does not move. i.e.
+  #    [sqlite3_column] still returns the current row ("001...") and
+  #    [sqlite3_finalize] returns SQLITE_OK.
+  #
+
+  do_test shared_ioerr-3rev.$n.cleanup.1 {
+    expr {
+      $::steprc eq "SQLITE_ROW" || 
+      $::steprc eq "SQLITE_ERROR" ||
+      $::steprc eq "SQLITE_ABORT" 
+    }
+  } {1}
+  do_test shared_ioerr-3rev.$n.cleanup.2 {
+    expr {
+      ($::steprc eq "SQLITE_ROW" && $::column eq "197.197.197.197.197") ||
+      ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
+      ($::steprc eq "SQLITE_ABORT" && $::column eq "198.198.198.198.198") 
+    }
+  } {1}
+  do_test shared_ioerr-3rev.$n.cleanup.3 {
+    expr {
+      ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
+      ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
+      ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
+    }
+  } {1}
+
+# db2 eval {select * from sqlite_master}
+  db2 close
+}
+
+# Provoke a malloc() failure when a cursor position is being saved. This
+# only happens with index cursors (because they malloc() space to save the
+# current key value). It does not happen with tables, because an integer
+# key does not require a malloc() to store. 
+#
+# The library should return an SQLITE_NOMEM to the caller. The query that
+# owns the cursor (the one for which the position is not saved) should
+# continue unaffected.
+# 
+do_malloc_test shared_err-4 -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    BEGIN;
+    CREATE TABLE t1(a, b, UNIQUE(a, b));
+  } db2
+  for {set i 0} {$i < 5} {incr i} {
+    set a [string repeat $i 10]
+    set b [string repeat $i 2000]
+    execsql {INSERT INTO t1 VALUES($a, $b)} db2
+  }
+  execsql {COMMIT} db2
+  set ::DB2 [sqlite3_connection_pointer db2]
+  set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
+  sqlite3_step $::STMT       ;# Cursor points at 0000000000
+  sqlite3_step $::STMT       ;# Cursor points at 1111111111
+} -tclbody {
+  execsql {
+    INSERT INTO t1 VALUES(6, NULL);
+  }
+} -cleanup {
+  do_test shared_malloc-4.$::n.cleanup.1 {
+    set ::rc [sqlite3_step $::STMT]
+    expr {$::rc=="SQLITE_ROW" || $::rc=="SQLITE_ERROR"}
+  } {1}
+  if {$::rc=="SQLITE_ROW"} {
+    do_test shared_malloc-4.$::n.cleanup.2 {
+      sqlite3_column_text $::STMT 0
+    } {2222222222}
+  }
+  do_test shared_malloc-4.$::n.cleanup.3 {
+   set rc [sqlite3_finalize $::STMT]
+   expr {$rc=="SQLITE_OK" || $rc=="SQLITE_ABORT" ||
+         $rc=="SQLITE_NOMEM" || $rc=="SQLITE_IOERR"}
+  } {1}
+# db2 eval {select * from sqlite_master}
+  db2 close
+}
+
+do_malloc_test shared_err-5 -tclbody {
+  db close
+  sqlite3 dbX test.db
+  sqlite3 dbY test.db
+  dbX close
+  dbY close
+} -cleanup {
+  catch {dbX close}
+  catch {dbY close}
+}
+
+do_malloc_test shared_err-6 -tclbody {
+  catch {db close}
+  ifcapable deprecated {
+    sqlite3_thread_cleanup
+  }
+  sqlite3_enable_shared_cache 0
+} -cleanup {
+  sqlite3_enable_shared_cache 1
+}
+
+# As of 3.5.0, sqlite3_enable_shared_cache can be called at
+# any time and from any thread
+#do_test shared_err-misuse-7.1 {
+#  sqlite3 db test.db
+#  catch {
+#    sqlite3_enable_shared_cache 0
+#  } msg
+#  set msg
+#} {library routine called out of sequence}
+
+# Again provoke a malloc() failure when a cursor position is being saved, 
+# this time during a ROLLBACK operation by some other handle. 
+#
+# The library should return an SQLITE_NOMEM to the caller. The query that
+# owns the cursor (the one for which the position is not saved) should
+# be aborted.
+# 
+set ::aborted 0
+do_malloc_test shared_err-8 -tclprep {
+  sqlite3 db2 test.db
+  execsql {
+    PRAGMA read_uncommitted = 1;
+    BEGIN;
+    CREATE TABLE t1(a, b, UNIQUE(a, b));
+  } db2
+  for {set i 0} {$i < 2} {incr i} {
+    set a [string repeat $i 10]
+    set b [string repeat $i 2000]
+    execsql {INSERT INTO t1 VALUES($a, $b)} db2
+  }
+  execsql {COMMIT} db2
+  execsql BEGIN
+  execsql ROLLBACK
+  set ::DB2 [sqlite3_connection_pointer db2]
+  set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
+  sqlite3_step $::STMT       ;# Cursor points at 0000000000
+  sqlite3_step $::STMT       ;# Cursor points at 1111111111
+} -tclbody {
+  execsql {
+    BEGIN;
+    INSERT INTO t1 VALUES(6, NULL);
+    ROLLBACK}
+} -cleanup {
+  # UPDATE: As of [5668], if the rollback fails SQLITE_CORRUPT is returned. 
+  # So these tests have been updated to expect SQLITE_CORRUPT and its
+  # associated English language error message.
+  #
+  do_test shared_malloc-8.$::n.cleanup.1 {
+    set res [catchsql {SELECT a FROM t1} db2]
+    set ans [lindex $res 1]
+    if {[lindex $res 0]} {
+       set r [expr {
+         $ans=="disk I/O error" ||
+         $ans=="out of memory" ||
+         $ans=="database disk image is malformed"
+       }]
+    } else {
+       set r [expr {[lrange $ans 0 1]=="0000000000 1111111111"}]
+    }
+  } {1}
+  do_test shared_malloc-8.$::n.cleanup.2 {
+    set rc1 [sqlite3_step $::STMT]
+    set rc2 [sqlite3_finalize $::STMT]
+    if {$rc2=="SQLITE_ABORT"} {
+      incr ::aborted
+    }
+    expr {
+      ($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") || 
+      ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_ABORT") ||
+      ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_NOMEM") ||
+      ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_IOERR") ||
+      ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_CORRUPT")
+    }
+  } {1}
+  db2 close
+}
+
+# When this test case was written, OOM errors in write statements would 
+# cause transaction rollback, which would trip cursors in other statements,
+# aborting them. This no longer happens.
+#
+do_test shared_malloc-8.X {
+  # Test that one or more queries were aborted due to the malloc() failure.
+  # expr $::aborted>=1
+  expr $::aborted==0
+} {1}
+
+# This test is designed to catch a specific bug that was present during
+# development of 3.5.0. If a malloc() failed while setting the page-size,
+# a buffer (Pager.pTmpSpace) was being freed. This could cause a seg-fault
+# later if another connection tried to use the pager.
+#
+# This test will crash 3.4.2.
+#
+do_malloc_test shared_err-9 -tclprep {
+  sqlite3 db2 test.db
+} -sqlbody {
+  PRAGMA page_size = 4096;
+  PRAGMA page_size = 1024;
+} -cleanup {
+  db2 eval {
+    CREATE TABLE abc(a, b, c);
+    BEGIN;
+    INSERT INTO abc VALUES(1, 2, 3);
+    ROLLBACK;
+  }     
+  db2 close
+}     
+
+catch {db close}
+catch {db2 close}
+do_malloc_test shared_err-10 -tclprep {
+  sqlite3 db test.db
+  sqlite3 db2 test.db
+  
+  db eval { SELECT * FROM sqlite_master }
+  db2 eval { 
+    BEGIN;
+    CREATE TABLE abc(a, b, c);
+  }
+} -tclbody {
+  catch {db eval {SELECT * FROM sqlite_master}}
+  error 1
+} -cleanup {
+  execsql { SELECT * FROM sqlite_master }
+}
+
+do_malloc_test shared_err-11 -tclprep {
+  sqlite3 db test.db
+  sqlite3 db2 test.db
+  
+  db eval { SELECT * FROM sqlite_master }
+  db2 eval { 
+    BEGIN;
+    CREATE TABLE abc(a, b, c);
+  }
+} -tclbody {
+  catch {db eval {SELECT * FROM sqlite_master}}
+  catch {sqlite3_errmsg16 db}
+  error 1
+} -cleanup {
+  execsql { SELECT * FROM sqlite_master }
+}
+
+catch {db close}
+catch {db2 close}
+
+do_malloc_test shared_err-12 -sqlbody {
+  CREATE TABLE abc(a, b, c);
+  INSERT INTO abc VALUES(1, 2, 3);
+}
+
+catch {db close}
+catch {db2 close}
+sqlite3_enable_shared_cache $::enable_shared_cache
+finish_test