-C Remove\sunnecessary\ssets\sof\sdb->mallocFailed.
-D 2016-02-04T11:48:00.219
+C Avoid\srunning\ssome\sparticularly\stime-consuming\stests\sas\spart\sof\sveryquick.test.
+D 2016-02-04T17:31:03.368
F Makefile.in 027c1603f255390c43a426671055a31c0a65fdb4
F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
F Makefile.msc 72b7858f02017611c3ac1ddc965251017fed0845
F test/fuzzdata2.db f03a420d3b822cc82e4f894ca957618fbe9c4973
F test/fuzzdata3.db c6586d3e3cef0fbc18108f9bb649aa77bfc38aba
F test/fuzzdata4.db 1882f0055fb63214d8407ddc7aca9b0b1c59af21
-F test/fuzzer1.test d4c52aaf3ef923da293a2653cfab33d02f718a36
+F test/fuzzer1.test 3d4c4b7e547aba5e5511a2991e3e3d07166cfbb8
+F test/fuzzer2.test a85ef814ce071293bce1ad8dffa217cbbaad4c14
F test/fuzzerfault.test 8792cd77fd5bce765b05d0c8e01b9edcf8af8536
F test/genesis.tcl 1e2e2e8e5cc4058549a154ff1892fe5c9de19f98
F test/hexlit.test d7b0a5f41123df1e43985b91b8b2e70f95282d21
F test/misc7.test edd0b63e2ee29a256900b0514f6fff27e19e9bb2
F test/misc8.test fc2754d38892f7dac30c22db3616c2764f117d66
F test/misuse.test 3c34719944ba045cc6c188a4852ba04680728912
-F test/mmap1.test 1bfd611b9841eafb44f7d83c0788e146d84a33c9
+F test/mmap1.test 44a5ff1c1bcc7dcf2de50227d1f997e75a8ef1ae
F test/mmap2.test 9d6dd9ddb4ad2379f29cc78f38ce1e63ed418022
F test/mmap3.test c92273e16eb8d23c1d55c9815b446bb72ef0512e
+F test/mmap4.test 2e2b4e32555b58da15176e6fe750f17c9dcf7f93
F test/mmapfault.test d4c9eff9cd8c2dc14bc43e71e042f175b0a26fe3
F test/multiplex.test efd015ca0b5b4a57dc9535b8feb1273eebeadb60
F test/multiplex2.test 580ca5817c7edbe4cc68fa150609c9473393003a
F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
F test/pcache2.test af7f3deb1a819f77a6d0d81534e97d1cf62cd442
F test/percentile.test 4243af26b8f3f4555abe166f723715a1f74c77ff
-F test/permutations.test 4ea119731c62d2f7d0aa86dd5b184cbb61ca411b
+F test/permutations.test 382a43c49f49bafe6fddffe904ea33d6bb3ff33e
F test/pragma.test 507ac7ef2ea5682241ea0ef041799ca70bb5e0bf
F test/pragma2.test a9400a7289605280576098b97f5cde3f204075c0
F test/pragma3.test 6f849ccffeee7e496d2f2b5e74152306c0b8757c
F test/run-wordcount.sh 891e89c4c2d16e629cd45951d4ed899ad12afc09
F test/savepoint.test c671fdbd34cd3bfe1518a777526ada595180cf8d
F test/savepoint2.test 9b8543940572a2f01a18298c3135ad0c9f4f67d7
-F test/savepoint3.test e328085853b14898d78ceea00dfe7db18bb6a9ec
F test/savepoint4.test c8f8159ade6d2acd9128be61e1230f1c1edc6cc0
F test/savepoint5.test 0735db177e0ebbaedc39812c8d065075d563c4fd
F test/savepoint6.test f41279c5e137139fa5c21485773332c7adb98cd7
F test/savepoint7.test db3db281486c925095f305aad09fe806e5188ff3
+F test/savepointfault.test f044eac64b59f09746c7020ee261734de82bf9b2 w test/savepoint3.test
F test/scanstatus.test 5253c219e331318a437f436268e0e82345700285
F test/schema.test 8f7999be894260f151adf15c2c7540f1c6d6a481
F test/schema2.test 906408621ea881fdb496d878b1822572a34e32c5
F test/snapshot_fault.test 25973aeb1b86a280800e0bcf1eb5ce70e9ef57ab
F test/soak.test 0b5b6375c9f4110c828070b826b3b4b0bb65cd5f
F test/softheap1.test 843cd84db9891b2d01b9ab64cef3e9020f98d087
-F test/sort.test 3f492e5b7be1d3f756728d2ff6edf4f6091e84cb
-F test/sort2.test 37afbc03f5559f2eb0f18940b55d38dfbb5172ac
-F test/sort3.test 6178ade30810ac9166fcdf14b7065e49c0f534e2
+F test/sort.test c2adc635c2564241fefec0b3a68391ef6868fd3b
+F test/sort2.test cc23b7c19d684657559e8a55b02f7fcee03851d0
+F test/sort3.test 1d831e95076b92985754a122e92ebc23bdf6f712
F test/sort4.test 5c34d9623a4ae5921d956dfa2b70e77ed0fc6e5c
F test/sort5.test a448240a42b49239edc00f85d6d7ac7a1b261e1f
F test/sortfault.test d4ccf606a0c77498e2beb542764fd9394acb4d66
F test/tempdb.test 19d0f66e2e3eeffd68661a11c83ba5e6ace9128c
F test/temptable.test d2c9b87a54147161bcd1822e30c1d1cd891e5b30
F test/temptrigger.test 8ec228b0db5d7ebc4ee9b458fc28cb9e7873f5e1
-F test/tester.tcl af4749cf4abf04291710c5e73f40bc8f411bae86
+F test/tester.tcl 462376b478c1429030911b4cb7c8c517ef1fbd9b
F test/thread001.test 9f22fd3525a307ff42a326b6bc7b0465be1745a5
F test/thread002.test e630504f8a06c00bf8bbe68528774dd96aeb2e58
F test/thread003.test ee4c9efc3b86a6a2767516a37bd64251272560a7
F test/vtab_alter.test 9e374885248f69e251bdaacf480b04a197f125e5
F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8
F test/vtab_shared.test ea8778d5b0df200adef2ca7c00c3c37d4375f772
-F test/wal.test 65bfc68f3f09dcbc62cee9f794e560428d96cec7
+F test/wal.test 0148c8b3421a25fdb4d9c160e84a681d0646371b
F test/wal2.test 1f841d2048080d32f552942e333fd99ce541dada
-F test/wal3.test b1d425f68a1f61d12563f0fa1ee6fca7d5afabf4
+F test/wal3.test 5dd734147f1f8f958c5261a1f2775d346d7013ce
F test/wal4.test 4744e155cd6299c6bd99d3eab1c82f77db9cdb3c
F test/wal5.test 88b5d9a6a3d1532497ee9f4296f010d66f07e33c
F test/wal6.test 4421cd5a2fa99d29cc91ef12fb23bed171ed3a4c
F test/walbak.test b9f68e39646375c2b877be906babcc15d38b4877
F test/walbig.test f437473a16cfb314867c6b5d1dbcd519e73e3434
F test/walblock.test be48f3a75eff0b4456209f26b3ce186c2015497d
-F test/walcksum.test 9afeb96240296c08c72fc524d199c912cfe34daa
+F test/walcksum.test bb234a1bb42248b3515d992b719708015c384278
F test/walcrash.test 21038858cc552077b0522f50b0fa87e38139306a
F test/walcrash2.test a0edab4e5390f03b99a790de89aad15d6ec70b36
F test/walcrash3.test e426aa58122d20f2b9fbe9a507f9eb8cab85b8af
F test/walnoshm.test 84ca10c544632a756467336b7c3b864d493ee496
F test/waloverwrite.test a0d2ae0783187374c1e6a9571e0916152977cb81
F test/walpersist.test 8c6b7e3ec1ba91b5e4dc4e0921d6d3f87cd356a6
+F test/walprotocol.test 059cb75484a1ecf6357a2c1b3324b8156749221e
F test/walro.test 34422d1d95aaff0388f0791ec20edb34e2a3ed57
F test/walshared.test 0befc811dcf0b287efae21612304d15576e35417
-F test/walslow.test e7be6d9888f83aa5d3d3c7c08aa9b5c28b93609a
+F test/walslow.test c05c68d4dc2700a982f89133ce103a1a84cc285f
F test/walthread.test de8dbaf6d9e41481c460ba31ca61e163d7348f8e
F test/where.test 9902a3d84e9bc80357a2c54ed0e76c0d6d04a867
F test/where2.test af78c55589cbc82d793449493adba0dc3d659f23
F test/where6.test 5da5a98cec820d488e82708301b96cb8c18a258b
F test/where7.test f520bcec2c3d12dc4615623b06b2aec7c2d67e94
F test/where8.test 98eedca0d375fb400b8377269c4b4686582dfb45
-F test/where8m.test da346596e19d54f0aba35ebade032a7c47d79739
F test/where9.test 729c3ba9b47e8f9f1aab96bae7dad2a524f1d1a2
F test/whereA.test 4d253178d135ec46d1671e440cd8f2b916aa6e6b
F test/whereB.test 0def95db3bdec220a731c7e4bec5930327c1d8c5
F test/whereI.test 1d89199697919d4930be05a71e7fe620f114e622
F test/whereJ.test 55a3221706a7ab706293f17cc8f96da563bf0767
F test/whereK.test f8e3cf26a8513ecc7f514f54df9f0572c046c42b
+F test/wherefault.test 1374c3aa198388925246475f84ad4cd5f9528864 w test/where8m.test
F test/wherelimit.test 5e9fd41e79bb2b2d588ed999d641d9c965619b31
F test/wild001.test bca33f499866f04c24510d74baf1e578d4e44b1c
F test/win32heap.test ea19770974795cff26e11575e12d422dbd16893c
F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
F tool/warnings.sh 48bd54594752d5be3337f12c72f28d2080cb630b
F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
-P 634d008c34bd237fc9cfb88dc291394fc5d31efa
-R 0723d194047e6276e554e1a515e620e8
-U drh
-Z 4a87610dafa418a613875dd84903b4d5
+P b787165b25a240fd5b4a5c7f73b395f30213a1d7
+R 2d9511ba502b30b0a28170783af34756
+U dan
+Z 9311e6c3b97d9e579dd5eb1512f82842
-b787165b25a240fd5b4a5c7f73b395f30213a1d7
\ No newline at end of file
+f465944b75a800ddc6920229ad32c2f39ff91e19
\ No newline at end of file
}
set ::testprefix fuzzer1
-
load_static_extension db fuzzer
# Check configuration errors.
CREATE VIRTUAL TABLE x USING fuzzer('fuzzer [x] rules table');
} {1 {fuzzer: ruleset must be between 0 and 2147483647}}
-#-------------------------------------------------------------------------
-# This test uses a fuzzer table with many rules. There is one rule to
-# map each possible two character string, where characters are lower-case
-# letters used in the English language, to all other possible two character
-# strings. In total, (26^4)-(26^2) mappings (the subtracted term represents
-# the no-op mappings discarded automatically by the fuzzer).
-#
-#
-do_execsql_test 6.1.1 {
- DROP TABLE IF EXISTS x1;
- DROP TABLE IF EXISTS x1_rules;
- CREATE TABLE x1_rules(ruleset, cFrom, cTo, cost);
-}
-puts "This test is slow - perhaps around 7 seconds on an average pc"
-do_test 6.1.2 {
- set LETTERS {a b c d e f g h i j k l m n o p q r s t u v w x y z}
- set cost 1
- db transaction {
- foreach c1 $LETTERS {
- foreach c2 $LETTERS {
- foreach c3 $LETTERS {
- foreach c4 $LETTERS {
- db eval {INSERT INTO x1_rules VALUES(0, $c1||$c2, $c3||$c4, $cost)}
- set cost [expr ($cost%1000) + 1]
- }
- }
- }
- }
- db eval {UPDATE x1_rules SET cost = 20 WHERE cost<20 AND cFrom!='xx'}
- }
-} {}
-
-do_execsql_test 6.2 {
- SELECT count(*) FROM x1_rules WHERE cTo!=cFrom;
-} [expr 26*26*26*26 - 26*26]
-
-do_execsql_test 6.2.1 {
- CREATE VIRTUAL TABLE x1 USING fuzzer(x1_rules);
- SELECT word FROM x1 WHERE word MATCH 'xx' LIMIT 10;
-} {xx hw hx hy hz ia ib ic id ie}
-do_execsql_test 6.2.2 {
- SELECT cTo FROM x1_rules WHERE cFrom='xx'
- ORDER BY cost asc, rowid asc LIMIT 9;
-} {hw hx hy hz ia ib ic id ie}
-
#-------------------------------------------------------------------------
# Test using different types of quotes with CREATE VIRTUAL TABLE
# arguments.
--- /dev/null
+# 2016 February 4
+#
+# 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 is the word-fuzzer virtual table. The tests
+# in this file are slower than those in fuzzer1.test. So this file does
+# not run as part of veryquick.test etc.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !vtab {
+ finish_test
+ return
+}
+
+set ::testprefix fuzzer2
+load_static_extension db fuzzer
+
+#-------------------------------------------------------------------------
+# This test uses a fuzzer table with many rules. There is one rule to
+# map each possible two character string, where characters are lower-case
+# letters used in the English language, to all other possible two character
+# strings. In total, (26^4)-(26^2) mappings (the subtracted term represents
+# the no-op mappings discarded automatically by the fuzzer).
+#
+#
+do_execsql_test 1.1.1 {
+ DROP TABLE IF EXISTS x1;
+ DROP TABLE IF EXISTS x1_rules;
+ CREATE TABLE x1_rules(ruleset, cFrom, cTo, cost);
+}
+puts "This test is slow - perhaps around 7 seconds on an average pc"
+do_test 1.1.2 {
+ set LETTERS {a b c d e f g h i j k l m n o p q r s t u v w x y z}
+ set cost 1
+ db transaction {
+ foreach c1 $LETTERS {
+ foreach c2 $LETTERS {
+ foreach c3 $LETTERS {
+ foreach c4 $LETTERS {
+ db eval {INSERT INTO x1_rules VALUES(0, $c1||$c2, $c3||$c4, $cost)}
+ set cost [expr ($cost%1000) + 1]
+ }
+ }
+ }
+ }
+ db eval {UPDATE x1_rules SET cost = 20 WHERE cost<20 AND cFrom!='xx'}
+ }
+} {}
+
+do_execsql_test 1.2 {
+ SELECT count(*) FROM x1_rules WHERE cTo!=cFrom;
+} [expr 26*26*26*26 - 26*26]
+
+do_execsql_test 1.2.1 {
+ CREATE VIRTUAL TABLE x1 USING fuzzer(x1_rules);
+ SELECT word FROM x1 WHERE word MATCH 'xx' LIMIT 10;
+} {xx hw hx hy hz ia ib ic id ie}
+do_execsql_test 1.2.2 {
+ SELECT cTo FROM x1_rules WHERE cFrom='xx'
+ ORDER BY cost asc, rowid asc LIMIT 9;
+} {hw hx hy hz ia ib ic id ie}
+
+finish_test
return $stats(read)
}
+# Return a Tcl script that registers a user-defined scalar function
+# named rblob() with database handle $dbname. The function returns a
+# sequence of pseudo-random blobs based on seed value $seed.
+#
proc register_rblob_code {dbname seed} {
return [subst -nocommands {
set ::rcnt $seed
}]
}
+
# For cases 1.1 and 1.4, the number of pages read using xRead() is 4 on
# unix and 9 on windows. The difference is that windows only ever maps
# an integer number of OS pages (i.e. creates mappings that are a multiple
sqlite3_finalize $::STMT
} SQLITE_OK
-#-------------------------------------------------------------------------
-# Test various mmap_size settings.
-#
-foreach {tn1 mmap1 mmap2} {
- 1 6144 167773
- 2 18432 140399
- 3 43008 401302
- 4 92160 253899
- 5 190464 2
- 6 387072 752431
- 7 780288 291143
- 8 1566720 594306
- 9 3139584 829137
- 10 6285312 793963
- 11 12576768 1015590
-} {
- do_multiclient_test tn {
- sql1 {
- CREATE TABLE t1(a PRIMARY KEY);
- CREATE TABLE t2(x);
- INSERT INTO t2 VALUES('');
- }
-
- code1 [register_rblob_code db 0]
- code2 [register_rblob_code db2 444]
-
- sql1 "PRAGMA mmap_size = $mmap1"
- sql2 "PRAGMA mmap_size = $mmap2"
-
- do_test $tn1.$tn {
- for {set i 1} {$i <= 100} {incr i} {
- if {$i % 2} {
- set c1 sql1
- set c2 sql2
- } else {
- set c1 sql2
- set c2 sql1
- }
-
- $c1 {
- INSERT INTO t1 VALUES( rblob(5000) );
- UPDATE t2 SET x = (SELECT md5sum(a) FROM t1);
- }
-
- set res [$c2 {
- SELECT count(*) FROM t1;
- SELECT x == (SELECT md5sum(a) FROM t1) FROM t2;
- PRAGMA integrity_check;
- }]
- if {$res != [list $i 1 ok]} {
- do_test $tn1.$tn.$i {
- set ::res
- } [list $i 1 ok]
- }
- }
- set res 1
- } {1}
- }
-}
-
finish_test
--- /dev/null
+# 2016 February 04
+#
+# 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.
+#
+#***********************************************************************
+#
+# This file tests the effect of the mmap() or mremap() system calls
+# returning an error on the library.
+#
+# If either mmap() or mremap() fails, SQLite should log an error
+# message, then continue accessing the database using read() and
+# write() exclusively.
+#
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+ifcapable !mmap {
+ finish_test
+ return
+}
+source $testdir/lock_common.tcl
+set testprefix mmap4
+
+# Return a Tcl script that registers a user-defined scalar function
+# named rblob() with database handle $dbname. The function returns a
+# sequence of pseudo-random blobs based on seed value $seed.
+#
+proc register_rblob_code {dbname seed} {
+ return [subst -nocommands {
+ set ::rcnt $seed
+ proc rblob {n} {
+ set ::rcnt [expr (([set ::rcnt] << 3) + [set ::rcnt] + 456) & 0xFFFFFFFF]
+ set str [format %.8x [expr [set ::rcnt] ^ 0xbdf20da3]]
+ string range [string repeat [set str] [expr [set n]/4]] 1 [set n]
+ }
+ $dbname func rblob rblob
+ }]
+}
+
+#-------------------------------------------------------------------------
+# Test various mmap_size settings.
+#
+foreach {tn1 mmap1 mmap2} {
+ 1 6144 167773
+ 2 18432 140399
+ 3 43008 401302
+ 4 92160 253899
+ 5 190464 2
+ 6 387072 752431
+ 7 780288 291143
+ 8 1566720 594306
+ 9 3139584 829137
+ 10 6285312 793963
+ 11 12576768 1015590
+} {
+ do_multiclient_test tn {
+ sql1 {
+ CREATE TABLE t1(a PRIMARY KEY);
+ CREATE TABLE t2(x);
+ INSERT INTO t2 VALUES('');
+ }
+
+ code1 [register_rblob_code db 0]
+ code2 [register_rblob_code db2 444]
+
+ sql1 "PRAGMA mmap_size = $mmap1"
+ sql2 "PRAGMA mmap_size = $mmap2"
+
+ do_test $tn1.$tn {
+ for {set i 1} {$i <= 100} {incr i} {
+ if {$i % 2} {
+ set c1 sql1
+ set c2 sql2
+ } else {
+ set c1 sql2
+ set c2 sql1
+ }
+
+ $c1 {
+ INSERT INTO t1 VALUES( rblob(5000) );
+ UPDATE t2 SET x = (SELECT md5sum(a) FROM t1);
+ }
+
+ set res [$c2 {
+ SELECT count(*) FROM t1;
+ SELECT x == (SELECT md5sum(a) FROM t1) FROM t2;
+ PRAGMA integrity_check;
+ }]
+ if {$res != [list $i 1 ok]} {
+ do_test $tn1.$tn.$i {
+ set ::res
+ } [list $i 1 ok]
+ }
+ }
+ set res 1
+ } {1}
+ }
+}
+
+finish_test
vtab_err.test walslow.test walcrash.test walcrash3.test
walthread.test rtree3.test indexfault.test securedel2.test
sort3.test sort4.test fts4growth.test fts4growth2.test
- bigsort.test rbu.test
+ bigsort.test rbu.test walprotocol.test mmap4.test fuzzer2.test
+ walcrash2.test e_fkey.test backup.test
+
+ fts4merge.test fts4merge2.test fts4merge4.test fts4check.test
+ fts3cov.test fts3snippet.test fts3corrupt2.test fts3an.test
+ fts3defer.test fts4langid.test fts3sort.test fts5unicode.test
+
+ rtree4.test
}]
if {[info exists ::env(QUICKTEST_INCLUDE)]} {
set allquicktests [concat $allquicktests $::env(QUICKTEST_INCLUDE)]
This test suite is the same as the "quick" tests, except that some files
that test malloc and IO errors are omitted.
} -files [
- test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile*
+ test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* *_err*
]
test_suite "extraquick" -prefix "" -description {
This test suite is the same as the "veryquick" tests, except that
slower tests are omitted.
} -files [
- test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* \
+ test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* *_err* \
wal3.test fts4merge* sort2.test mmap1.test walcrash* \
percentile.test where8m.test walcksum.test savepoint3.test \
fuzzer1.test fuzzer3.test fts3expr3.test
Run the "veryquick" test suite with a couple of multi-process tests (that
fail under valgrind) omitted.
} -files [
- test_set $allquicktests -exclude *malloc* *ioerr* *fault* wal.test \
+ test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err* wal.test \
shell*.test crash8.test atof1.test selectG.test \
tkt-fc62af4523.test numindex1.test
] -initialize {
Run the "veryquick" test suite with a couple of multi-process tests (that
fail under valgrind) omitted.
} -files [
- test_set $allquicktests -exclude *malloc* *ioerr* *fault* wal.test atof1.test
+ test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err* \
+ wal.test atof1.test
] -initialize {
set ::G(valgrind) 1
catch {db close}
This test suite is the same as the "quick" tests, except that some files
that test malloc and IO errors are omitted.
} -files [
- test_set $allquicktests -exclude *malloc* *ioerr* *fault*
+ test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err*
] -initialize {
catch {db close}
sqlite3_shutdown
#
#***********************************************************************
#
-# $Id: savepoint3.test,v 1.5 2009/06/05 17:09:12 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
source $testdir/malloc_common.tcl
-do_malloc_test savepoint3-1 -sqlprep {
+set testprefix savepointfault
+
+do_malloc_test 1 -sqlprep {
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1, 2, 3);
} -sqlbody {
RELEASE one;
}
-do_malloc_test savepoint3-2 -sqlprep {
+do_malloc_test 2 -sqlprep {
PRAGMA cache_size = 10;
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(randstr(400,400), randstr(400,400), randstr(400,400));
RELEASE one;
}
-do_ioerr_test savepoint3.3 -sqlprep {
+do_ioerr_test 3 -sqlprep {
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1, randstr(1000,1000), randstr(1000,1000));
INSERT INTO t1 VALUES(2, randstr(1000,1000), randstr(1000,1000));
# The following test does a really big savepoint rollback. One involving
# more than 4000 pages. The idea is to get a specific sqlite3BitvecSet()
# operation in pagerPlaybackSavepoint() to fail.
-#do_malloc_test savepoint3-4 -sqlprep {
+#do_malloc_test 4 -sqlprep {
# BEGIN;
# CREATE TABLE t1(a, b);
# CREATE INDEX i1 ON t1(a);
# Cause a specific malloc in savepoint rollback code to fail.
#
-do_malloc_test savepoint3-4 -start 7 -sqlprep {
+do_malloc_test 4 -start 7 -sqlprep {
PRAGMA auto_vacuum = incremental;
PRAGMA cache_size = 1000;
SELECT a, b FROM t10 ORDER BY a;
} [db eval {SELECT a, b FROM t10 ORDER BY a, b}]
-#-------------------------------------------------------------------------
-# Sort some large ( > 4KiB) records.
-#
-proc cksum {x} {
- set i1 1
- set i2 2
- binary scan $x c* L
- foreach {a b} $L {
- set i1 [expr (($i2<<3) + $a) & 0x7FFFFFFF]
- set i2 [expr (($i1<<3) + $b) & 0x7FFFFFFF]
- }
- list $i1 $i2
-}
-db func cksum cksum
-
-do_execsql_test sort-14.0 {
- PRAGMA cache_size = 5;
- CREATE TABLE t11(a, b);
- INSERT INTO t11 VALUES(randomblob(5000), NULL);
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --2
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --3
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --4
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --5
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --6
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --7
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --8
- INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --9
- UPDATE t11 SET b = cksum(a);
-}
-
-foreach {tn mmap_limit} {
- 1 0
- 2 1000000
-} {
- do_test sort-14.$tn {
- sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $mmap_limit
- set prev ""
- db eval { SELECT * FROM t11 ORDER BY b } {
- if {$b != [cksum $a]} {error "checksum failed"}
- if {[string compare $b $prev] < 0} {error "sort failed"}
- set prev $b
- }
- set {} {}
- } {}
-}
-
#-------------------------------------------------------------------------
#
foreach {tn mmap_limit nWorker tmpstore coremutex fakeheap softheaplimit} {
catch { db eval {PRAGMA threads=7} }
}
} {
-
eval $script
do_execsql_test $tn.1 {
do_execsql_test $tn.2.4 { PRAGMA integrity_check } {ok}
- do_execsql_test $tn.3 {
- PRAGMA cache_size = 5;
- WITH r(x,y) AS (
- SELECT 1, randomblob(100)
- UNION ALL
- SELECT x+1, randomblob(100) FROM r
- LIMIT 1000000
- )
- SELECT count(x), length(y) FROM r GROUP BY (x%5)
- } {
- 200000 100 200000 100 200000 100 200000 100 200000 100
+ # Because it uses so much data, this test can take 12-13 seconds even on
+ # a modern workstation. So it is omitted from "veryquick" and other
+ # permutations.test tests.
+ if {[isquick]==0} {
+ do_execsql_test $tn.3 {
+ PRAGMA cache_size = 5;
+ WITH r(x,y) AS (
+ SELECT 1, randomblob(100)
+ UNION ALL
+ SELECT x+1, randomblob(100) FROM r
+ LIMIT 1000000
+ )
+ SELECT count(x), length(y) FROM r GROUP BY (x%5)
+ } {
+ 200000 100 200000 100 200000 100 200000 100 200000 100
+ }
}
}
source $testdir/tester.tcl
set testprefix sort3
+#-------------------------------------------------------------------------
+# Sort some large ( > 4KiB) records.
+#
+proc cksum {x} {
+ set i1 1
+ set i2 2
+ binary scan $x c* L
+ foreach {a b} $L {
+ set i1 [expr (($i2<<3) + $a) & 0x7FFFFFFF]
+ set i2 [expr (($i1<<3) + $b) & 0x7FFFFFFF]
+ }
+ list $i1 $i2
+}
+db func cksum cksum
+
+do_execsql_test 1.0 {
+ PRAGMA cache_size = 5;
+ CREATE TABLE t11(a, b);
+ INSERT INTO t11 VALUES(randomblob(5000), NULL);
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --2
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --3
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --4
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --5
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --6
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --7
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --8
+ INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --9
+ UPDATE t11 SET b = cksum(a);
+}
+
+foreach {tn mmap_limit} {
+ 1 0
+ 2 1000000
+} {
+ do_test 1.$tn {
+ sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $mmap_limit
+ set prev ""
+ db eval { SELECT * FROM t11 ORDER BY b } {
+ if {$b != [cksum $a]} {error "checksum failed"}
+ if {[string compare $b $prev] < 0} {error "sort failed"}
+ set prev $b
+ }
+ set {} {}
+ } {}
+}
+
+
# Sort roughly 20MB of data. Once with a mmap limit of 5MB and once without.
#
foreach {itest limit} {
2 0x7FFFFFFF
} {
sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $limit
- do_execsql_test 1.$itest {
+ do_execsql_test 2.$itest {
WITH r(x,y) AS (
SELECT 1, randomblob(1000)
UNION ALL
# Sort more than 2GB of data. At one point this was causing a problem.
# This test might take one minute or more to run.
#
-do_execsql_test 2 {
+do_execsql_test 3 {
PRAGMA cache_size = 20000;
WITH r(x,y) AS (
SELECT 1, randomblob(1000)
set presql
}
+proc isquick {} {
+ set ret 0
+ catch {set ret $::G(isquick)}
+ set ret
+}
+
#-------------------------------------------------------------------------
#
proc slave_test_script {script} {
db2 close
db close
-#-------------------------------------------------------------------------
-# Test large log summaries.
-#
-# In this case "large" usually means a log file that requires a wal-index
-# mapping larger than 64KB (the default initial allocation). A 64KB wal-index
-# is large enough for a log file that contains approximately 13100 frames.
-# So the following tests create logs containing at least this many frames.
-#
-# wal-13.1.*: This test case creates a very large log file within the
-# file-system (around 200MB). The log file does not contain
-# any valid frames. Test that the database file can still be
-# opened and queried, and that the invalid log file causes no
-# problems.
-#
-# wal-13.2.*: Test that a process may create a large log file and query
-# the database (including the log file that it itself created).
-#
-# wal-13.3.*: Test that if a very large log file is created, and then a
-# second connection is opened on the database file, it is possible
-# to query the database (and the very large log) using the
-# second connection.
-#
-# wal-13.4.*: Same test as wal-13.3.*. Except in this case the second
-# connection is opened by an external process.
-#
-do_test wal-13.1.1 {
- list [file exists test.db] [file exists test.db-wal]
-} {1 0}
-do_test wal-13.1.2 {
- set fd [open test.db-wal w]
- seek $fd [expr 200*1024*1024]
- puts $fd ""
- close $fd
- sqlite3 db test.db
- execsql { SELECT * FROM t2 }
-} {B 2}
-do_test wal-13.1.3 {
- db close
- file exists test.db-wal
-} {0}
-
-do_test wal-13.2.1 {
- sqlite3 db test.db
- execsql { SELECT count(*) FROM t2 }
-} {1}
-do_test wal-13.2.2 {
- db function blob blob
- for {set i 0} {$i < 16} {incr i} {
- execsql { INSERT INTO t2 SELECT blob(400), blob(400) FROM t2 }
- }
- execsql { SELECT count(*) FROM t2 }
-} [expr int(pow(2, 16))]
-do_test wal-13.2.3 {
- expr [file size test.db-wal] > [wal_file_size 33000 1024]
-} 1
-
-do_multiclient_test tn {
- incr tn 2
-
- do_test wal-13.$tn.0 {
- sql1 {
- PRAGMA journal_mode = WAL;
- CREATE TABLE t1(x);
- INSERT INTO t1 SELECT randomblob(800);
- }
- sql1 { SELECT count(*) FROM t1 }
- } {1}
-
- for {set ii 1} {$ii<16} {incr ii} {
- do_test wal-13.$tn.$ii.a {
- sql2 { INSERT INTO t1 SELECT randomblob(800) FROM t1 }
- sql2 { SELECT count(*) FROM t1 }
- } [expr (1<<$ii)]
- do_test wal-13.$tn.$ii.b {
- sql1 { SELECT count(*) FROM t1 }
- } [expr (1<<$ii)]
- do_test wal-13.$tn.$ii.c {
- sql1 { SELECT count(*) FROM t1 }
- } [expr (1<<$ii)]
- do_test wal-13.$tn.$ii.d {
- sql1 { PRAGMA integrity_check }
- } {ok}
- }
-}
-
#-------------------------------------------------------------------------
# Check a fun corruption case has been fixed.
#
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
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.
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
catch { db close }
catch { db2 close }
-#-------------------------------------------------------------------------
-# Test case walcksum-3.* tests that the checksum calculation detects single
-# byte changes to frame or frame-header data and considers the frame
-# invalid as a result.
-#
-do_test walcksum-3.1 {
- forcedelete test.db test.db-wal test.db-journal
- sqlite3 db test.db
-
- execsql {
- PRAGMA synchronous = NORMAL;
- PRAGMA page_size = 1024;
- CREATE TABLE t1(a, b);
- INSERT INTO t1 VALUES(1, randomblob(300));
- INSERT INTO t1 VALUES(2, randomblob(300));
- PRAGMA journal_mode = WAL;
- INSERT INTO t1 VALUES(3, randomblob(300));
- }
-
- file size test.db-wal
-} [wal_file_size 1 1024]
-do_test walcksum-3.2 {
- forcecopy test.db-wal test2.db-wal
- forcecopy test.db test2.db
- sqlite3 db2 test2.db
- execsql { SELECT a FROM t1 } db2
-} {1 2 3}
-db2 close
-forcecopy test.db test2.db
-
-
-foreach incr {1 2 3 20 40 60 80 100 120 140 160 180 200 220 240 253 254 255} {
- do_test walcksum-3.3.$incr {
- set FAIL 0
- for {set iOff 0} {$iOff < [wal_file_size 1 1024]} {incr iOff} {
-
- forcecopy test.db-wal test2.db-wal
- set fd [open test2.db-wal r+]
- fconfigure $fd -encoding binary
- fconfigure $fd -translation binary
-
- seek $fd $iOff
- binary scan [read $fd 1] c x
- seek $fd $iOff
- puts -nonewline $fd [binary format c [expr {($x+$incr)&0xFF}]]
- close $fd
-
- sqlite3 db2 test2.db
- if { [execsql { SELECT a FROM t1 } db2] != "1 2" } {set FAIL 1}
- db2 close
- }
- set FAIL
- } {0}
-}
finish_test
--- /dev/null
+# 2016 February 4
+#
+# 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.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library. The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL" mode.
+#
+# More specifically, it tests "locking protocol" errors - errors that
+# may be caused if one or more SQLite clients does not follow the expected
+# locking protocol when accessing a wal-mode database. These tests take
+# quite a while to run.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/wal_common.tcl
+ifcapable !wal {finish_test ; return }
+
+set testprefix walprotocol
+
+#-------------------------------------------------------------------------
+# 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 1.3).
+#
+# Also test the effect of hitting an SQLITE_BUSY while attempting to obtain
+# the WRITER lock (should be the same). Test case 1.4.
+#
+do_execsql_test 1.0 {
+ PRAGMA journal_mode = wal;
+ CREATE TABLE x(y);
+ INSERT INTO x VALUES('z');
+} {wal}
+
+proc lock_callback {method filename handle lock} {
+ lappend ::locks $lock
+}
+do_test 1.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 1.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 xSlee(1) 100 times."
+puts "# Normally this equates to a delay of roughly 10 seconds, but if SQLite"
+puts "# is built on unix without HAVE_USLEEP defined, it may be much longer."
+do_test 1.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 1.4 {
+ db close
+ set ::locks [list]
+ sqlite3 db test.db -vfs T
+ catchsql { SELECT * FROM x }
+} {1 {locking protocol}}
+db close
+T delete
+
+#-------------------------------------------------------------------------
+#
+do_test 2.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 2.2 {
+ execsql { SELECT * FROM b }
+} {Tehran Qom Markazi}
+do_test 2.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 2.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 2.5 {
+ execsql { SELECT * FROM b }
+} {Tehran Qom Markazi Qazvin Gilan Ardabil}
+do_test 2.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 2.7 {
+ execsql { SELECT * FROM b }
+} {Tehran Qom Markazi Qazvin Gilan Ardabil}
+do_test 2.8 {
+ set ::r
+} {1 {locking protocol}}
+
+db close
+db2 close
+T delete
+
+finish_test
set testdir [file dirname $argv0]
source $testdir/tester.tcl
+source $testdir/wal_common.tcl
+source $testdir/lock_common.tcl
ifcapable !wal {finish_test ; return }
+set testprefix walslow
+
proc reopen_db {} {
catch { db close }
forcedelete test.db test.db-wal
}
}
+#-------------------------------------------------------------------------
+# Test case walslow-3.* tests that the checksum calculation detects single
+# byte changes to frame or frame-header data and considers the frame
+# invalid as a result.
+#
+reset_db
+do_test 3.1 {
+
+ execsql {
+ PRAGMA synchronous = NORMAL;
+ PRAGMA page_size = 1024;
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES(1, randomblob(300));
+ INSERT INTO t1 VALUES(2, randomblob(300));
+ PRAGMA journal_mode = WAL;
+ INSERT INTO t1 VALUES(3, randomblob(300));
+ }
+
+ file size test.db-wal
+} [wal_file_size 1 1024]
+do_test 3.2 {
+ forcecopy test.db-wal test2.db-wal
+ forcecopy test.db test2.db
+ sqlite3 db2 test2.db
+ execsql { SELECT a FROM t1 } db2
+} {1 2 3}
+db2 close
+forcecopy test.db test2.db
+
+foreach incr {1 2 3 20 40 60 80 100 120 140 160 180 200 220 240 253 254 255} {
+ do_test 3.3.$incr {
+ set FAIL 0
+ for {set iOff 0} {$iOff < [wal_file_size 1 1024]} {incr iOff} {
+
+ forcecopy test.db-wal test2.db-wal
+ set fd [open test2.db-wal r+]
+ fconfigure $fd -encoding binary
+ fconfigure $fd -translation binary
+
+ seek $fd $iOff
+ binary scan [read $fd 1] c x
+ seek $fd $iOff
+ puts -nonewline $fd [binary format c [expr {($x+$incr)&0xFF}]]
+ close $fd
+
+ sqlite3 db2 test2.db
+ if { [execsql { SELECT a FROM t1 } db2] != "1 2" } {set FAIL 1}
+ db2 close
+ }
+ set FAIL
+ } {0}
+}
+
+
+#-------------------------------------------------------------------------
+# Test large log summaries.
+#
+# In this case "large" usually means a log file that requires a wal-index
+# mapping larger than 64KB (the default initial allocation). A 64KB wal-index
+# is large enough for a log file that contains approximately 13100 frames.
+# So the following tests create logs containing at least this many frames.
+#
+# 4.1.*: This test case creates a very large log file within the
+# file-system (around 200MB). The log file does not contain
+# any valid frames. Test that the database file can still be
+# opened and queried, and that the invalid log file causes no
+# problems.
+#
+# 4.2.*: Test that a process may create a large log file and query
+# the database (including the log file that it itself created).
+#
+# 4.3.*: Test that if a very large log file is created, and then a
+# second connection is opened on the database file, it is possible
+# to query the database (and the very large log) using the
+# second connection.
+#
+# 4.4.*: Same test as wal-13.3.*. Except in this case the second
+# connection is opened by an external process.
+#
+set ::blobcnt 0
+proc blob {nByte} {
+ incr ::blobcnt
+ return [string range [string repeat "${::blobcnt}x" $nByte] 1 $nByte]
+}
+
+reset_db
+do_execsql_test 4.1 {
+ PRAGMA journal_mode = wal;
+ CREATE TABLE t1(x, y);
+ INSERT INTO "t1" VALUES('A',0);
+ CREATE TABLE t2(x, y);
+ INSERT INTO "t2" VALUES('B',2);
+} {wal}
+db close
+
+do_test 4.1.1 {
+ list [file exists test.db] [file exists test.db-wal]
+} {1 0}
+do_test 4.1.2 {
+ set fd [open test.db-wal w]
+ seek $fd [expr 200*1024*1024]
+ puts $fd ""
+ close $fd
+ sqlite3 db test.db
+ execsql { SELECT * FROM t2 }
+} {B 2}
+do_test 4.1.3 {
+ db close
+ file exists test.db-wal
+} {0}
+
+do_test 4.2.1 {
+ sqlite3 db test.db
+ execsql { SELECT count(*) FROM t2 }
+} {1}
+do_test 4.2.2 {
+ db function blob blob
+ for {set i 0} {$i < 16} {incr i} {
+ execsql { INSERT INTO t2 SELECT blob(400), blob(400) FROM t2 }
+ }
+ execsql { SELECT count(*) FROM t2 }
+} [expr int(pow(2, 16))]
+do_test 4.2.3 {
+ expr [file size test.db-wal] > [wal_file_size 33000 1024]
+} 1
+
+do_multiclient_test tn {
+ incr tn 2
+
+ do_test 4.$tn.0 {
+ sql1 {
+ PRAGMA journal_mode = WAL;
+ CREATE TABLE t1(x);
+ INSERT INTO t1 SELECT randomblob(800);
+ }
+ sql1 { SELECT count(*) FROM t1 }
+ } {1}
+
+ for {set ii 1} {$ii<16} {incr ii} {
+ do_test 4.$tn.$ii.a {
+ sql2 { INSERT INTO t1 SELECT randomblob(800) FROM t1 }
+ sql2 { SELECT count(*) FROM t1 }
+ } [expr (1<<$ii)]
+ do_test 4.$tn.$ii.b {
+ sql1 { SELECT count(*) FROM t1 }
+ } [expr (1<<$ii)]
+ do_test 4.$tn.$ii.c {
+ sql1 { SELECT count(*) FROM t1 }
+ } [expr (1<<$ii)]
+ do_test 4.$tn.$ii.d {
+ sql1 { PRAGMA integrity_check }
+ } {ok}
+ }
+}
finish_test
#
#***********************************************************************
# This file implements regression tests for SQLite library. The focus
-# is testing of where.c. More specifically, the focus is the optimization
-# of WHERE clauses that feature the OR operator.
+# is testing of where.c. More specifically, the focus is on handling OOM
+# errors within the code that optimizes WHERE clauses that feature the
+# OR operator.
#
-# $Id: where8m.test,v 1.3 2009/06/05 17:09:12 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
source $testdir/malloc_common.tcl
-do_malloc_test where8m-1 -sqlprep {
+set testprefix wherefault
+
+do_malloc_test 1 -sqlprep {
CREATE TABLE t1(a, b, c);
CREATE INDEX i1 ON t1(a);
CREATE INDEX i2 ON t1(b);
a BETWEEN 1 AND 3 AND b < 5 AND b > 2 AND c = 4;
}
-do_malloc_test where8m-2 -tclprep {
+do_malloc_test 2 -tclprep {
db eval {
BEGIN;
CREATE TABLE t1(a, b, c);
projects / thirdparty / sqlite.git / commitdiff
