From: adam Date: Wed, 18 Aug 2010 00:09:47 +0000 (+0000) Subject: Updating apple-osx with minor source fixes, database truncate and replace private... X-Git-Tag: mountain-lion~56 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=45d55a254b848b182d8d40c7396773a3cf7e9737;p=thirdparty%2Fsqlite.git Updating apple-osx with minor source fixes, database truncate and replace private calls and a bunch of conditionalization for tests running in different environments FossilOrigin-Name: 5e2ee7db0f7a2a042b182336438107e2248d7b88 --- diff --git a/manifest b/manifest index 548a10bf18..276891a494 100644 --- a/manifest +++ b/manifest @@ -1,8 +1,5 @@ ------BEGIN PGP SIGNED MESSAGE----- -Hash: SHA1 - -C Merge\sin\sall\schanges\sup\sto\sthe\s3.7.0.1\srelease. -D 2010-08-07T11:46:07 +C Updating\sapple-osx\swith\sminor\ssource\sfixes,\sdatabase\struncate\sand\sreplace\sprivate\scalls\sand\sa\sbunch\sof\sconditionalization\sfor\stests\srunning\sin\sdifferent\senvironments +D 2010-08-18T00:09:48 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0 F Makefile.in 9e1872338c526a5d6797f19dd04388f2a321e3d6 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654 @@ -160,15 +157,15 @@ F src/os.c 60178f518c4d6c0dcb59f7292232281d7bea2dcf F src/os.h 9dbed8c2b9c1f2f2ebabc09e49829d4777c26bf9 F src/os_common.h a8f95b81eca8a1ab8593d23e94f8a35f35d4078f F src/os_os2.c 72d0b2e562952a2464308c4ce5f7913ac10bef3e -F src/os_unix.c 3109e0e5a0d5551bab2e8c7322b20a3b8b171248 -F src/os_win.c ed741817cfa97270e17f8f63c06f7e79e3b534d0 +F src/os_unix.c b7267d7fa3b77306bcebcd6bb2a322ebf06e4d21 +F src/os_win.c 1f8b0a1a5bcf6289e7754d0d3c16cec16d4c93ab F src/pager.c c0f3c60b701a794344961700da7c4e2ae23d79a8 F src/pager.h 879fdde5a102d2f21a3135d6f647530b21c2796c F src/parse.y 220a11ac72e2c9dffbf4cbe5fe462f328bd8d884 F src/pcache.c 1e9aa2dbc0845b52e1b51cc39753b6d1e041cb07 F src/pcache.h c683390d50f856d4cd8e24342ae62027d1bb6050 F src/pcache1.c 3a7c28f46a61b43ff0b5c087a7983c154f4b264c -F src/pragma.c 6ee427538964886ce466a6ef8b0c2557a2b27d7e +F src/pragma.c 055115ce2ba78af1aee2b973d947172a036f7a98 F src/prepare.c e81fd00d882e849498b0927a046cd06aab7bd502 F src/printf.c 5f5b65a83e63f2096a541a340722a509fa0240a7 F src/random.c cd4a67b3953b88019f8cd4ccd81394a8ddfaba50 @@ -177,13 +174,14 @@ F src/rowset.c 69afa95a97c524ba6faf3805e717b5b7ae85a697 F src/select.c 4903ff1bbd08b55cbce00ea43c645530de41b362 F src/shell.c fd4ccdb37c3b68de0623eb938a649e0990710714 F src/sqlite.h.in 8b05aef506d9bc7fc7da1572744e3174cb16ed59 +F src/sqlite3_private.h 2a814d17913732831acf13e7e87860105a3416e4 F src/sqlite3ext.h 69dfb8116af51b84a029cddb3b35062354270c89 F src/sqliteInt.h d9e42f2029d4c526f9ba960bda1980ef17429c30 F src/sqliteLimit.h 196e2f83c3b444c4548fc1874f52f84fdbda40f3 F src/status.c 4df6fe7dce2d256130b905847c6c60055882bdbe F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e F src/tclsqlite.c ae1e4fb653c91ddad7e2534d209711a12604ccc4 -F src/test1.c 0dc3be6a14d6478ded56daca868cc989fd8f7f1c +F src/test1.c 8d65857cd33db9baa6f276ce6fcd76c98c798261 F src/test2.c e3f564ab1e9fd0b47b0c9e23e7054e38bf0836cf F src/test3.c 4c21700c73a890a47fc685c1097bfb661346ac94 F src/test4.c ad03bb987ddedce928f4258c1e7fa4109a73497d @@ -196,7 +194,7 @@ F src/test_async.c 0612a752896fad42d55c3999a5122af10dcf22ad F src/test_autoext.c 30e7bd98ab6d70a62bb9ba572e4c7df347fe645e F src/test_backup.c 64fd6173ad99daade1227aa17c3ca0d18fa5e5fa F src/test_btree.c 47cd771250f09cdc6e12dda5bc71bc0b3abc96e2 -F src/test_config.c 5a11c51af2156e2d07186930b36f2b8239a4393f +F src/test_config.c 91e758b037c7c58a6e3b3ce6babae883666174e9 F src/test_demovfs.c da81a5f7785bb352bda7911c332a983ec4f17f27 F src/test_devsym.c e7498904e72ba7491d142d5c83b476c4e76993bc F src/test_func.c 13b582345fb1185a93e46c53310fae8547dcce20 @@ -224,10 +222,10 @@ F src/update.c 19c899c23cd29fd102c9068e0b0ff5b087204beb F src/utf.c 1baeeac91707a4df97ccc6141ec0f808278af685 F src/util.c 32aebf04c10e51ad3977a928b7416bed671b620b F src/vacuum.c 241a8386727c1497eba4955933356dfba6ff8c9f -F src/vdbe.c 6294de3327e09d14e9c06ecfd10e57c2d8e85307 +F src/vdbe.c a4c6eed89bb8332aa5ac4828e38e30e7c833477a F src/vdbe.h 471f6a3dcec4817ca33596fe7f6654d56c0e75f3 F src/vdbeInt.h 19ebc8c2a2e938340051ee65af3f377fb99102d1 -F src/vdbeapi.c 95b451c6d991fddef6f9e4e68acfe573f597fb2f +F src/vdbeapi.c a4e1b491545b8927d54c96b5ac8e44e460e2b7d5 F src/vdbeaux.c 7f99c1f00e4b31e8b28d8a87ecc2322bb46ae99c F src/vdbeblob.c 258a6010ba7a82b72b327fb24c55790655689256 F src/vdbemem.c 5e579abf6532001dfbee0e640dc34eae897a9807 @@ -273,7 +271,7 @@ F test/badutf.test d5360fc31f643d37a973ab0d8b4fb85799c3169f F test/between.test 16b1776c6323faadb097a52d673e8e3d8be7d070 F test/bigfile.test a8ec8073a20207456dab01a29ad9cde42b0dd103 F test/bigrow.test f0aeb7573dcb8caaafea76454be3ade29b7fc747 -F test/bind.test 3c7b320969000c441a70952b0b15938fbb66237c +F test/bind.test 30af0fc61bc3836034215cdbdeca46113ca1b4a1 F test/bindxfer.test efecd12c580c14df5f4ad3b3e83c667744a4f7e0 F test/bitvec.test 75894a880520164d73b1305c1c3f96882615e142 F test/blob.test e7ac6c7d3a985cc4678c64f325292529a69ae252 @@ -353,7 +351,7 @@ F test/enc.test e54531cd6bf941ee6760be041dff19a104c7acea F test/enc2.test 6d91a5286f59add0cfcbb2d0da913b76f2242398 F test/enc3.test 5c550d59ff31dccdba5d1a02ae11c7047d77c041 F test/eval.test bc269c365ba877554948441e91ad5373f9f91be3 -F test/exclusive.test 5fe18e10a159342dd52ca14b1554e33f98734267 +F test/exclusive.test b8ac927ca1067abd0044703aca2d00cd56d518ab F test/exclusive2.test fcbb1c9ca9739292a0a22a3763243ad6d868086b F test/exec.test e949714dc127eaa5ecc7d723efec1ec27118fdd7 F test/expr.test 9f521ae22f00e074959f72ce2e55d46b9ed23f68 @@ -475,7 +473,7 @@ F test/join5.test 86675fc2919269aa923c84dd00ee4249b97990fe F test/join6.test bf82cf3f979e9eade83ad0d056a66c5ed71d1901 F test/journal1.test 36f2d1bb9bf03f790f43fbdb439e44c0657fab19 F test/journal2.test 50a3604768494d4a337f194f0a9480e7c57dcb72 -F test/journal3.test ff175219be1b02d2f7e54297ad7e491b7533edb6 +F test/journal3.test 7cfbd86429305c96c9d985665320db5364764d96 F test/jrnlmode.test 2d5a8b6d68de8512f522532731d90ca96912f3b7 F test/jrnlmode2.test a19e28de1a6ec898067e46a122f1b71c9323bf00 F test/jrnlmode3.test cfcdb12b90e640a23b92785a002d96c0624c8710 @@ -491,11 +489,11 @@ F test/lock.test 842e80b6be816c79525a20b098cca066989feed7 F test/lock2.test 5242d8ac4e2d59c403aebff606af449b455aceff F test/lock3.test f271375930711ae044080f4fe6d6eda930870d00 F test/lock4.test c82268c031d39345d05efa672f80b025481b3ae5 -F test/lock5.test b2abb5e711bc59b0eae00f6c97a36ec9f458fada +F test/lock5.test d0d313f059ae5661726d3f197ba6ed8f69257d8e F test/lock6.test 8df56060f396151777390982422c800d026e1722 F test/lock7.test 64006c84c1c616657e237c7ad6532b765611cf64 F test/lock_common.tcl e7013c6208f5fa818735c324eb0249b4c0f317cf -F test/lock_proxy.test 364b6c6220c023b57fc37eb52ec97c1f5c682c47 +F test/lock_proxy.test 9ea4307b186949fcfd012e4cd44149d2b6360da6 F test/lookaside.test 382e7bc2fab23d902c8eafb1b9ed7ababfff75a6 F test/main.test 753e2b772c041bd8dbd17c7e4132b3981378eaab F test/make-where7.tcl 05c16b5d4f5d6512881dfec560cb793915932ef9 @@ -520,7 +518,7 @@ F test/mallocI.test a88c2b9627c8506bf4703d8397420043a786cdb6 F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e F test/mallocK.test d79968641d1b70d88f6c01bdb9a7eb4a55582cc9 F test/malloc_common.tcl bd0b0916f03cb4f4c973bcb793f3057e84d5ecfb -F test/manydb.test b3d3bc4c25657e7f68d157f031eb4db7b3df0d3c +F test/manydb.test 7faa0df55bbab2b14c25f323801db336c4e7ce3a F test/memdb.test f773146f66ee2c635854a8264317f39a6cc3e18c F test/memleak.test 10b9c6c57e19fc68c32941495e9ba1c50123f6e2 F test/memsubsys1.test 98d5ff4c9f534cc863c07b74043bd44921893f29 @@ -545,7 +543,7 @@ F test/notify3.test 7eeba3628c4e707c004b72a2489c48fbdbc5c2ee F test/notnull.test cc7c78340328e6112a13c3e311a9ab3127114347 F test/null.test a8b09b8ed87852742343b33441a9240022108993 F test/openv2.test af02ed0a9cbc0d2a61b8f35171d4d117e588e4ec -F test/pager1.test d8e4b2bc8164c920e6ea0572c9e13576d6e4f3fa +F test/pager1.test 8343530e91cf617b3157dac05531fa4038e9a263 F test/pager2.test f5c757c271ce642d36a393ecbfb3aef1c240dcef F test/pagerfault.test c1d176326ce244db157ce9c3ba128be2a9b172d6 F test/pagerfault2.test 1f79ea40d1133b2683a2f811b00f2399f7ec2401 @@ -592,7 +590,7 @@ F test/selectA.test 06d1032fa9009314c95394f2ca2e60d9f7ae8532 F test/selectB.test f305cc6660804cb239aab4e2f26b0e288b59958b F test/selectC.test 33bb5673a8141df193c6fd56e6de7fea38b8d2ee F test/server1.test f5b790d4c0498179151ca8a7715a65a7802c859c -F test/shared.test 3b448dc0f7a9356e641894ed81c27599f39d809d +F test/shared.test a192585f23f5b9aab2e16fe6f11af79893353a62 F test/shared2.test d6ba4ca1827ea36a1ac23a99e3c36eeac9165450 F test/shared3.test d69bdd5f156580876c5345652d21dc2092e85962 F test/shared4.test d0fadacb50bb6981b2fb9dc6d1da30fa1edddf83 @@ -614,8 +612,8 @@ F test/speed4.test abc0ad3399dcf9703abed2fff8705e4f8e416715 F test/speed4p.explain 6b5f104ebeb34a038b2f714150f51d01143e59aa F test/speed4p.test 0e51908951677de5a969b723e03a27a1c45db38b F test/sqllimits1.test e90a0ed94452076f6a10209d378e06b5f75ef0a0 -F test/stat.test 70fe540ffb285947aead5533dfd0c8c12f17f14e -F test/stmt.test 7915bd3e8380b956c095f40f41a775a30716e649 +F test/stat.test 8b7342007bdb49a9427d57a9bb94d02d6e54f2d0 +F test/stmt.test 8e39760750cdf8044d4ca441b2b95053817c9a5f F test/subquery.test b524f57c9574b2c0347045b4510ef795d4686796 F test/subselect.test d24fd8757daf97dafd2e889c73ea4c4272dcf4e4 F test/substr.test 18f57c4ca8a598805c4d64e304c418734d843c1a @@ -623,10 +621,10 @@ F test/sync.test ded6b39d8d8ca3c0c5518516c6371b3316d3e3a3 F test/table.test 04ba066432430657712d167ebf28080fe878d305 F test/tableapi.test 7262a8cbaa9965d429f1cbd2747edc185fa56516 F test/tclsqlite.test 8c154101e704170c2be10f137a5499ac2c6da8d3 -F test/tempdb.test 800c36623d67a2ad1f58784b9c5644e0405af6e6 +F test/tempdb.test 285dda9fdf10730702549e8aa19c9258bbf753b8 F test/temptable.test f42121a0d29a62f00f93274464164177ab1cc24a F test/temptrigger.test b0273db072ce5f37cf19140ceb1f0d524bbe9f05 -F test/tester.tcl 7ea0c78442dccd4d7dde572c4a271dbc8b615e17 +F test/tester.tcl faae2f58058f129fa13992bdf728ee672d513588 F test/thread001.test a3e6a7254d1cb057836cb3145b60c10bf5b7e60f F test/thread002.test afd20095e6e845b405df4f2c920cb93301ca69db F test/thread003.test b824d4f52b870ae39fc5bae4d8070eca73085dca @@ -703,7 +701,7 @@ F test/tkt3357.test 77c37c6482b526fe89941ce951c22d011f5922ed F test/tkt3419.test 1bbf36d7ea03b638c15804251287c2391f5c1f6b F test/tkt3424.test 61f831bd2b071bd128fa5d00fbda57e656ca5812 F test/tkt3442.test 89d7b41a4ec4d9d9b40ab8575d648579fb13cb4f -F test/tkt3457.test edbf54b05cbe5165f00192becbd621038f1615e4 +F test/tkt3457.test 8a8f29536bf65b994bef5dde881404530b61a62a F test/tkt3461.test 228ea328a5a21e8663f80ee3d212a6ad92549a19 F test/tkt3493.test 1686cbde85f8721fc1bdc0ee72f2ef2f63139218 F test/tkt3508.test d75704db9501625c7f7deec119fcaf1696aefb7d @@ -785,21 +783,21 @@ F test/vtabE.test 7c4693638d7797ce2eda17af74292b97e705cc61 F test/vtab_alter.test 9e374885248f69e251bdaacf480b04a197f125e5 F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8 F test/vtab_shared.test 0eff9ce4f19facbe0a3e693f6c14b80711a4222d -F test/wal.test 1891e6f72dd437a1c2a48091aa9182ba17a8f780 -F test/wal2.test fa6dc4457b46988f46cf6c68ea51ebe341765f4a -F test/wal3.test d2ae7e66f973bd6b58ce49e546b2c00f44fe0485 -F test/wal4.test 3404b048fa5e10605facaf70384e6d2943412e30 +F test/wal.test 93cbc7a85563b2445940b77bf20d527755e6fc9d +F test/wal2.test 86d38974445365f082fdc1c41cd8151f6d83685d +F test/wal3.test c5d29ae29989b87dfe583b96c839a824d830e8e4 +F test/wal4.test 6a68c45bc1ca24a3592ec449ddcb92b29d0e0e87 F test/wal_common.tcl 895d76138043b86bdccf36494054bdabcf65837b -F test/walbak.test 4df1c7369da0301caeb9a48fa45997fd592380e4 -F test/walbig.test e882bc1d014afffbfa2b6ba36e0f07d30a633ad0 -F test/walcksum.test a37b36375c595e61bdb7e1ec49b5f0979b6fc7ce -F test/walcrash.test e763841551d6b23677ccb419797c1589dcbdbaf5 -F test/walcrash2.test 019d60b89d96c1937adb2b30b850ac7e86e5a142 -F test/walfault.test 05c470688d742688e455dd56816bd6bcffa298f8 -F test/walhook.test ed00a40ba7255da22d6b66433ab61fab16a63483 -F test/walmode.test 5dc3008ef71988ecdd949ea16e5750e325b92b54 -F test/walslow.test d21625e2e99e11c032ce949e8a94661576548933 -F test/walthread.test a25a393c068a2b42b44333fa3fdaae9072f1617c +F test/walbak.test 767e1c9e0ea0cfb907873b332883e66e187fa4bc +F test/walbig.test 78ac493db2abdb65b9c6cace5b851cc32df1d449 +F test/walcksum.test cf6787f2ee1a6a3da6f0c2b20b9ede5153e4e03f +F test/walcrash.test 80c1cc3173a0ef09d8303fa556cb0187a36d82ea +F test/walcrash2.test 929c99d14ee2e3e3ef82585058968a8b12f72706 +F test/walfault.test 60527645638532a565a8e729db287ef0dba85ece +F test/walhook.test c934ac5219fee2b4e7653d291db9107b8dc73bba +F test/walmode.test 72517eb4f787c21b0478e608009642405885d613 +F test/walslow.test 989854bc5c214700a9f2d545bb158643813b8881 +F test/walthread.test e6e32e93ccebfa401dfc0dd930c79daa3472b0ae F test/where.test de337a3fe0a459ec7c93db16a519657a90552330 F test/where2.test 43d4becaf5a5df854e6c21d624a1cb84c6904554 F test/where3.test aa44a9b29e8c9f3d7bb94a3bb3a95b31627d520d @@ -844,14 +842,7 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f -P 21ca87f69125a9e7124c6ddc566d17f64661b0d3 042a1abb030a0711386add7eb6e10832cc8b0f57 -R a0302c2cc0f7d48015e224bb2b269904 -U drh -Z 2e5c390a58c654c840972d590ea9776b ------BEGIN PGP SIGNATURE----- -Version: GnuPG v1.4.6 (GNU/Linux) - -iD8DBQFMXUeCoxKgR168RlERAh3wAJ9vkuYLkmYAethkfRnCyA85itOWmQCdHqi9 -Um3XnsUJPDOzuj+sNtgxEE0= -=FT3/ ------END PGP SIGNATURE----- +P f88c6367d2f96cc93846ba38e6b963a1a3936e8d +R 5e13346496ee8c75e29f49b7f6c975c4 +U adam +Z 6d6d71585a30456468bba06c8dd3f59f diff --git a/manifest.uuid b/manifest.uuid index 82f216b47c..b71ba23600 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -f88c6367d2f96cc93846ba38e6b963a1a3936e8d \ No newline at end of file +5e2ee7db0f7a2a042b182336438107e2248d7b88 \ No newline at end of file diff --git a/src/os_unix.c b/src/os_unix.c index 9457516cac..5ddb7daf65 100644 --- a/src/os_unix.c +++ b/src/os_unix.c @@ -3033,6 +3033,11 @@ static int unixFileSize(sqlite3_file *id, i64 *pSize){ static int proxyFileControl(sqlite3_file*,int,void*); #endif +#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) +#include "sqlite3_private.h" +#include +static int getDbPathForUnixFile(unixFile *pFile, char *dbPath); +#endif /* ** Information and control of an open file handle. @@ -3072,6 +3077,219 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){ return proxyFileControl(id,op,pArg); } #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */ +#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) + case SQLITE_TRUNCATE_DATABASE: { + unixFile *pFile = (unixFile*)id; + int trc = SQLITE_OK; + int eFileLock = pFile->eFileLock; + int rc = SQLITE_OK; + char jPath[MAXPATHLEN+9]; + size_t jLen; + + if( eFileLockpMethod->xLock(id, SQLITE_LOCK_SHARED); + } + if( !rc && eFileLockpMethod->xLock(id, SQLITE_LOCK_EXCLUSIVE); + } + if( rc ){ + if( pFile->eFileLock > eFileLock ){ + pFile->pMethod->xUnlock(id, eFileLock); + } + return rc; + } + rc = pFile->pMethod->xTruncate(id, ((pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS) != 0) ? 1L : 0L); + if( !rc && (SQLITE_OK==getDbPathForUnixFile(pFile, jPath)) ){ + jLen = strlcat(jPath, "-journal", MAXPATHLEN+9); + if( jLen < MAXPATHLEN+9 ){ + int jfd = open(jPath, O_TRUNC); + if( (jfd == -1) ){ + if ( errno!=ENOENT ){ + perror(jPath); + } + } else { + fsync(jfd); + close(jfd); + } + } + }else{ + trc=rc; + } + if( !trc ){ + trc = pFile->pMethod->xSync(id, SQLITE_SYNC_FULL); + } + if( pFile->eFileLock > eFileLock ){ + int unlockRC = pFile->pMethod->xUnlock(id, SQLITE_LOCK_SHARED); + if (!rc) rc = unlockRC; + } + if( pFile->eFileLock > eFileLock ){ + int unlockRC = pFile->pMethod->xUnlock(id, SQLITE_LOCK_NONE); + if (!rc) rc = unlockRC; + } + if( trc ){ + return trc; + } + return rc; + } + + case SQLITE_REPLACE_DATABASE: { + unixFile *pFile = (unixFile*)id; + int trc = SQLITE_OK; + int eFileLock = pFile->eFileLock; + int rc = SQLITE_OK; + char jPath[MAXPATHLEN+9]; + size_t jLen; + sqlite3 *srcdb = (sqlite3 *)pArg; + Btree *pSrcBtree = NULL; + int eSrcFileLock = SQLITE_LOCK_NONE; + int srcLockRC = -1; + sqlite3_file *src_file = NULL; + unixFile *pSrcFile = NULL; + + if( !sqlite3SafetyCheckOk(srcdb) ){ + return SQLITE_MISUSE; + } + if( eFileLockpMethod->xLock(id, SQLITE_LOCK_SHARED); + } + if( !rc && eFileLockpMethod->xLock(id, SQLITE_LOCK_EXCLUSIVE); + } + if( !rc ){ + /* get the src file descriptor adhering to the db struct access rules + ** this code is modeled after sqlite3_file_control() in main.c + */ + sqlite3_mutex_enter(srcdb->mutex); + if( srcdb->nDb>0 ){ + pSrcBtree = srcdb->aDb[0].pBt; + } + if( pSrcBtree ){ + Pager *pSrcPager; + sqlite3BtreeEnter(pSrcBtree); + pSrcPager = sqlite3BtreePager(pSrcBtree); + assert( pSrcPager!=0 ); + src_file = sqlite3PagerFile(pSrcPager); + assert( src_file!=0 ); + if( src_file->pMethods ){ + pSrcFile = (unixFile *)src_file; + eSrcFileLock = pSrcFile->eFileLock; + if( eSrcFileLockpMethod->xLock(src_file, SQLITE_LOCK_SHARED); + srcLockRC = rc; /* SQLITE_OK means we need to unlock later */ + } else if( eSrcFileLock==SQLITE_LOCK_EXCLUSIVE ){ + /* if the src database has an exclusive lock, verify that the + ** it doesn't have a journal file with open transactions + */ + if( getDbPathForUnixFile(pSrcFile, jPath) ){ + rc = SQLITE_INTERNAL; + }else{ + jLen = strlcat(jPath, "-journal", MAXPATHLEN+9); + if( jLen < MAXPATHLEN+9 ){ + int jfd = open(jPath, O_RDONLY); + if( jfd==-1 ){ + if( errno!=ENOENT ){ + pFile->lastErrno = errno; + rc = SQLITE_IOERR; + } + }else{ + /* if the journal exists ensure there's no pending + ** transaction by checking the journal header */ + char magic[8]; + ssize_t rlen = pread(jfd, magic, 8, 0); + if( rlen<0 ){ + pFile->lastErrno = errno; + rc = SQLITE_IOERR; + }else if( rlen==8 ){ + char test[8] = {'\0','\0','\0','\0','\0','\0','\0','\0'}; + if( memcmp(magic,test,8) ){ + rc = SQLITE_LOCKED; + } + }else if( rlen!=0 ){ + rc = SQLITE_INTERNAL; + } + close(jfd); + } + } + } + } + }else{ + rc = SQLITE_MISUSE; + } + if( rc ){ + if( srcLockRC==SQLITE_OK ){ + pSrcFile->pMethod->xUnlock(src_file, eSrcFileLock); + } + sqlite3BtreeLeave(pSrcBtree); + } + } + if( pSrcFile==NULL || (pSrcFile->h<0) ){ + rc = SQLITE_INTERNAL; + sqlite3_mutex_leave(srcdb->mutex); + } + } + if( rc ){ + /* unroll state changes and return error code */ + if( pFile->eFileLock > eFileLock ){ + pFile->pMethod->xUnlock(id, eFileLock); + } + return rc; + }else{ + /* both databases are locked appropriately, copy file data + ** and then unroll the locks we added. + */ + copyfile_state_t s; + + s = copyfile_state_alloc(); + if( fcopyfile(pSrcFile->h, pFile->h, s, COPYFILE_ALL) ){ + switch(errno) { + case ENOMEM: + rc = SQLITE_NOMEM; + break; + default: + rc = SQLITE_INTERNAL; + } + } + copyfile_state_free(s); + if( srcLockRC==SQLITE_OK ){ + pSrcFile->pMethod->xUnlock(src_file, eSrcFileLock); + } + sqlite3BtreeLeave(pSrcBtree); + sqlite3_mutex_leave(srcdb->mutex); + } + + if( !rc && (SQLITE_OK==getDbPathForUnixFile(pFile, jPath)) ){ + jLen = strlcat(jPath, "-journal", MAXPATHLEN+9); + if( jLen < MAXPATHLEN+9 ){ + int jfd = open(jPath, O_TRUNC); + if( (jfd == -1) ){ + if ( errno!=ENOENT ){ + perror(jPath); + } + } else { + fsync(jfd); + close(jfd); + } + } + }else{ + trc=rc; + } + if( !trc ){ + trc = pFile->pMethod->xSync(id, SQLITE_SYNC_FULL); + } + if( pFile->eFileLock > eFileLock ){ + int unlockRC = pFile->pMethod->xUnlock(id, SQLITE_LOCK_SHARED); + if (!rc) rc = unlockRC; + } + if( pFile->eFileLock > eFileLock ){ + int unlockRC = pFile->pMethod->xUnlock(id, SQLITE_LOCK_NONE); + if (!rc) rc = unlockRC; + } + if( trc ){ + return trc; + } + return rc; + } +#endif /* (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) */ } return SQLITE_ERROR; } @@ -4575,6 +4793,9 @@ static int unixOpen( if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) { ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; } + if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } #endif #if SQLITE_ENABLE_LOCKING_STYLE @@ -4612,13 +4833,19 @@ static int unixOpen( if( useProxy ){ rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock, isDelete); if( rc==SQLITE_OK ){ + /* cache the pMethod in case the transform fails */ + const struct sqlite3_io_methods *pMethod = pFile->pMethods; rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:"); if( rc!=SQLITE_OK ){ /* Use unixClose to clean up the resources added in fillInUnixFile ** and clear all the structure's references. Specifically, ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op */ - unixClose(pFile); + if( pMethod!=NULL ){ + pMethod->xClose(pFile); + }else{ + unixClose(pFile); + } return rc; } } @@ -5815,7 +6042,7 @@ static int switchLockProxyPath(unixFile *pFile, const char *path) { ** This routine find the filename associated with pFile and writes it ** int dbPath. */ -static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){ +static int getDbPathForUnixFile(unixFile *pFile, char *dbPath){ #if defined(__APPLE__) if( pFile->pMethod == &afpIoMethods ){ /* afp style keeps a reference to the db path in the filePath field @@ -5854,7 +6081,7 @@ static int proxyTransformUnixFile(unixFile *pFile, const char *path) { if( pFile->eFileLock!=NO_LOCK ){ return SQLITE_BUSY; } - proxyGetDbPathForUnixFile(pFile, dbPath); + getDbPathForUnixFile(pFile, dbPath); if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){ lockPath=NULL; }else{ @@ -5897,6 +6124,9 @@ static int proxyTransformUnixFile(unixFile *pFile, const char *path) { } if( rc==SQLITE_OK && lockPath ){ pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath); + if( pCtx->lockProxyPath==NULL ){ + rc = SQLITE_NOMEM; + } } if( rc==SQLITE_OK ){ diff --git a/src/os_win.c b/src/os_win.c index d38683a478..0951312327 100644 --- a/src/os_win.c +++ b/src/os_win.c @@ -1146,11 +1146,6 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){ *(int*)pArg = (int)((winFile*)id)->lastErrno; return SQLITE_OK; } - case SQLITE_FCNTL_SIZE_HINT: { - sqlite3_int64 sz = *(sqlite3_int64*)pArg; - winTruncate(id, sz); - return SQLITE_OK; - } case SQLITE_FCNTL_SIZE_HINT: { sqlite3_int64 sz = *(sqlite3_int64*)pArg; SimulateIOErrorBenign(1); diff --git a/src/pragma.c b/src/pragma.c index 4841a40457..7015ae3633 100644 --- a/src/pragma.c +++ b/src/pragma.c @@ -1415,17 +1415,15 @@ void sqlite3Pragma( ** of N. */ if( sqlite3StrICmp(zLeft, "wal_autocheckpoint")==0 ){ - sqlite3_int64 ret; + i64 walArg = 0; if( zRight ){ int nAuto = atoi(zRight); sqlite3_wal_autocheckpoint(db, nAuto); } if( db->xWalCallback==sqlite3WalDefaultHook ){ - ret = SQLITE_PTR_TO_INT(db->pWalArg); - }else{ - ret = 0; + walArg = SQLITE_PTR_TO_INT(db->pWalArg); } - returnSingleInt(pParse, "wal_autocheckpoint", &ret); + returnSingleInt(pParse, "wal_autocheckpoint", &walArg); }else #endif diff --git a/src/sqlite3_private.h b/src/sqlite3_private.h new file mode 100644 index 0000000000..907da81822 --- /dev/null +++ b/src/sqlite3_private.h @@ -0,0 +1,21 @@ +/* + * sqlite3_private.h + */ + +#ifndef _SQLITE3_PRIVATE_H +#define _SQLITE3_PRIVATE_H + +/* +** Pass the SQLITE_TRUNCATE_DATABASE operation code to sqlite3_file_control() +** to truncate a database and its associated journal file to zero length. +*/ +#define SQLITE_TRUNCATE_DATABASE 101 + +/* +** Pass the SQLITE_REPLACE_DATABASE operation code to sqlite3_file_control() +** and a sqlite3 pointer to another open database file to safely copy the +** contents of that database file into the receiving database. +*/ +#define SQLITE_REPLACE_DATABASE 102 + +#endif diff --git a/src/test1.c b/src/test1.c index 3f2c033d8a..dd02971544 100644 --- a/src/test1.c +++ b/src/test1.c @@ -3134,11 +3134,28 @@ static int test_clear_bindings( return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; - sqlite3_clear_bindings(0); /* test for handling NULL */ Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt))); return TCL_OK; } +/* + ** Usage: sqlite3_clear_bindings STMT + ** + */ +static int test_clear_bindings_null( + void * clientData, + Tcl_Interp *interp, + int objc, + Tcl_Obj *CONST objv[] +){ + if( objc!=1 ){ + return TCL_ERROR; + } + /* test for handling NULL */ + Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(0))); + return TCL_OK; +} + /* ** Usage: sqlite3_sleep MILLISECONDS */ @@ -4684,6 +4701,97 @@ static int file_control_lockproxy_test( return TCL_OK; } +#ifdef __APPLE__ +#include +#include +#include +#endif + +/* + ** tclcmd: path_is_local PWD + */ +static int path_is_local( + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ + int objc, /* Number of arguments */ + Tcl_Obj *CONST objv[] /* Command arguments */ +){ + sqlite3 *db; + const char *zPath; + int nPath; + + if( objc!=2 ){ + Tcl_AppendResult(interp, "wrong # args: should be \"", + Tcl_GetStringFromObj(objv[0], 0), " PATH", 0); + return TCL_ERROR; + } + zPath = Tcl_GetStringFromObj(objv[1], &nPath); + +#ifdef __APPLE__ + { + struct statfs fsInfo; + if( statfs(zPath, &fsInfo) == -1 ){ + int err = errno; + Tcl_AppendResult(interp, "Error calling statfs on path", + Tcl_NewIntObj(err), 0); + return TCL_ERROR; + } + if( fsInfo.f_flags&MNT_LOCAL ){ + Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); + } else { + Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); + } + } +#else + Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); +#endif + + return TCL_OK; +} + +/* + ** tclcmd: path_is_dos PWD + */ +static int path_is_dos( + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ + int objc, /* Number of arguments */ + Tcl_Obj *CONST objv[] /* Command arguments */ +){ + sqlite3 *db; + const char *zPath; + int nPath; + + if( objc!=2 ){ + Tcl_AppendResult(interp, "wrong # args: should be \"", + Tcl_GetStringFromObj(objv[0], 0), " PATH", 0); + return TCL_ERROR; + } + zPath = Tcl_GetStringFromObj(objv[1], &nPath); + +#ifdef __APPLE__ + { + struct statfs fsInfo; + if( statfs(zPath, &fsInfo) == -1 ){ + int err = errno; + Tcl_AppendResult(interp, "Error calling statfs on path", + Tcl_NewIntObj(err), 0); + return TCL_ERROR; + } + if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) { + Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); + } else if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) { + Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); + } else { + Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); + } + } +#else + Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); +#endif + + return TCL_OK; +} /* ** tclcmd: sqlite3_vfs_list @@ -5023,6 +5131,7 @@ int Sqlitetest1_Init(Tcl_Interp *interp){ { "sqlite3_bind_parameter_name", test_bind_parameter_name, 0}, { "sqlite3_bind_parameter_index", test_bind_parameter_index, 0}, { "sqlite3_clear_bindings", test_clear_bindings, 0}, + { "sqlite3_clear_bindings_null", test_clear_bindings_null, 0}, { "sqlite3_sleep", test_sleep, 0}, { "sqlite3_errcode", test_errcode ,0 }, { "sqlite3_extended_errcode", test_ex_errcode ,0 }, @@ -5107,6 +5216,8 @@ int Sqlitetest1_Init(Tcl_Interp *interp){ { "file_control_test", file_control_test, 0 }, { "file_control_lasterrno_test", file_control_lasterrno_test, 0 }, { "file_control_lockproxy_test", file_control_lockproxy_test, 0 }, + { "path_is_local", path_is_local, 0 }, + { "path_is_dos", path_is_dos, 0 }, { "sqlite3_vfs_list", vfs_list, 0 }, /* Functions from os.h */ diff --git a/src/test_config.c b/src/test_config.c index 7ada13f4f6..c037e34e9a 100644 --- a/src/test_config.c +++ b/src/test_config.c @@ -528,7 +528,23 @@ Tcl_SetVar2(interp, "sqlite_options", "long_double", #else Tcl_SetVar2(interp, "sqlite_options", "yytrackmaxstackdepth", "0", TCL_GLOBAL_ONLY); #endif - + +#ifdef __APPLE__ +# if defined(__ppc__) + Tcl_SetVar2(interp, "os_options", "arch", "ppc", TCL_GLOBAL_ONLY); +# elif defined(__i386__) + Tcl_SetVar2(interp, "os_options", "arch", "i386", TCL_GLOBAL_ONLY); +# elif defined(__x86_64__) + Tcl_SetVar2(interp, "os_options", "arch", "x86_64", TCL_GLOBAL_ONLY); +# elif defined(__arm__) + Tcl_SetVar2(interp, "os_options", "arch", "arm", TCL_GLOBAL_ONLY); +# else +# error Unrecognized architecture for exec_options +# endif +#else + Tcl_SetVar2(interp, "os_options", "arch", "unknown", TCL_GLOBAL_ONLY); +#endif + #define LINKVAR(x) { \ static const int cv_ ## x = SQLITE_ ## x; \ Tcl_LinkVar(interp, "SQLITE_" #x, (char *)&(cv_ ## x), \ diff --git a/src/vdbe.c b/src/vdbe.c index 6813837d24..c888c64967 100644 --- a/src/vdbe.c +++ b/src/vdbe.c @@ -566,7 +566,7 @@ int sqlite3VdbeExec( ** sqlite3_column_text16() failed. */ goto no_mem; } - assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY ); + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || ((p->rc&0xFF) == SQLITE_LOCKED)); p->rc = SQLITE_OK; assert( p->explain==0 ); p->pResultSet = 0; diff --git a/src/vdbeapi.c b/src/vdbeapi.c index 45647d78ed..ef4eb43788 100644 --- a/src/vdbeapi.c +++ b/src/vdbeapi.c @@ -40,7 +40,8 @@ int sqlite3_expired(sqlite3_stmt *pStmt){ ** invalid). Return false if it is ok. */ static int vdbeSafety(Vdbe *p){ - if( p->db==0 ){ + sqlite3* db = p->db; + if((db==0) || (db->magic != SQLITE_MAGIC_OPEN) || ((p->magic != VDBE_MAGIC_RUN) && (p->magic != VDBE_MAGIC_HALT))){ sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement"); return 1; }else{ diff --git a/test/bind.test b/test/bind.test index 34f3155b95..1150961707 100644 --- a/test/bind.test +++ b/test/bind.test @@ -656,6 +656,9 @@ do_test bind-13.4 { [sqlite3_column_type $VM 2] } {NULL NULL NULL} sqlite3_finalize $VM +do_test bind-13.5 { + sqlite3_clear_bindings_null +} {0} #-------------------------------------------------------------------- # These tests attempt to reproduce bug #3463. diff --git a/test/exclusive.test b/test/exclusive.test index 4f20a6b9fc..d97459bd1f 100644 --- a/test/exclusive.test +++ b/test/exclusive.test @@ -395,12 +395,8 @@ sqlite db test.db # if we're using proxy locks, we use 3 filedescriptors for a db # that is open but NOT writing changes, normally # sqlite uses 1 (proxy locking adds the conch and the local lock) -set using_proxy 0 -foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] { - set using_proxy $value -} set extrafds 0 -if {$using_proxy!=0} { +if {[forced_proxy_locking]} { set extrafds 2 } diff --git a/test/journal3.test b/test/journal3.test index 7d29722202..3ed1a20b0b 100644 --- a/test/journal3.test +++ b/test/journal3.test @@ -20,7 +20,7 @@ source $testdir/malloc_common.tcl # If a connection is required to create a journal file, it creates it with # the same file-system permissions as the database file itself. Test this. # -if {$::tcl_platform(platform) == "unix"} { +if {$::tcl_platform(platform) == "unix" && ![path_is_dos "."]} { set umask [exec /bin/sh -c umask] faultsim_delete_and_reopen diff --git a/test/lock5.test b/test/lock5.test index 6ec86ba7e4..15ba156a27 100644 --- a/test/lock5.test +++ b/test/lock5.test @@ -106,88 +106,92 @@ if {[catch {sqlite3 db test.db -vfs unix-flock} msg]} { return } -do_test lock5-flock.1 { - sqlite3 db test.db -vfs unix-flock - execsql { - CREATE TABLE t1(a, b); - BEGIN; - INSERT INTO t1 VALUES(1, 2); - } -} {} - -# Make sure we are not accidentally using the dotfile locking scheme. -do_test lock5-flock.2 { - file exists test.db.lock -} {0} - -do_test lock5-flock.3 { - catch { sqlite3 db2 test.db -vfs unix-flock } - catchsql { SELECT * FROM t1 } db2 -} {1 {database is locked}} - -do_test lock5-flock.4 { - execsql COMMIT - catchsql { SELECT * FROM t1 } db2 -} {0 {1 2}} - -do_test lock5-flock.5 { - execsql BEGIN - catchsql { SELECT * FROM t1 } db2 -} {0 {1 2}} - -do_test lock5-flock.6 { - execsql {SELECT * FROM t1} - catchsql { SELECT * FROM t1 } db2 -} {1 {database is locked}} - -do_test lock5-flock.7 { - db close - catchsql { SELECT * FROM t1 } db2 -} {0 {1 2}} - -do_test lock5-flock.8 { - db2 close -} {} - -##################################################################### +# Only run the flock tests on a local file system +if { [path_is_local "."] } { + + do_test lock5-flock.1 { + sqlite3 db test.db -vfs unix-flock + execsql { + CREATE TABLE t1(a, b); + BEGIN; + INSERT INTO t1 VALUES(1, 2); + } + } {} + + # Make sure we are not accidentally using the dotfile locking scheme. + do_test lock5-flock.2 { + file exists test.db.lock + } {0} + + do_test lock5-flock.3 { + catch { sqlite3 db2 test.db -vfs unix-flock } + catchsql { SELECT * FROM t1 } db2 + } {1 {database is locked}} + + do_test lock5-flock.4 { + execsql COMMIT + catchsql { SELECT * FROM t1 } db2 + } {0 {1 2}} + + do_test lock5-flock.5 { + execsql BEGIN + catchsql { SELECT * FROM t1 } db2 + } {0 {1 2}} + + do_test lock5-flock.6 { + execsql {SELECT * FROM t1} + catchsql { SELECT * FROM t1 } db2 + } {1 {database is locked}} + + do_test lock5-flock.7 { + db close + catchsql { SELECT * FROM t1 } db2 + } {0 {1 2}} + + do_test lock5-flock.8 { + db2 close + } {} + + ##################################################################### + + do_test lock5-none.1 { + sqlite3 db test.db -vfs unix-none + sqlite3 db2 test.db -vfs unix-none + execsql { + BEGIN; + INSERT INTO t1 VALUES(3, 4); + } + } {} + do_test lock5-none.2 { + execsql { SELECT * FROM t1 } + } {1 2 3 4} + do_test lock5-flock.3 { + execsql { SELECT * FROM t1 } db2 + } {1 2} + do_test lock5-none.4 { + execsql { + BEGIN; + SELECT * FROM t1; + } db2 + } {1 2} + do_test lock5-none.5 { + execsql COMMIT + execsql {SELECT * FROM t1} db2 + } {1 2} -do_test lock5-none.1 { - sqlite3 db test.db -vfs unix-none - sqlite3 db2 test.db -vfs unix-none - execsql { - BEGIN; - INSERT INTO t1 VALUES(3, 4); + ifcapable memorymanage { + do_test lock5-none.6 { + sqlite3_release_memory 1000000 + execsql {SELECT * FROM t1} db2 + } {1 2 3 4} } -} {} -do_test lock5-none.2 { - execsql { SELECT * FROM t1 } -} {1 2 3 4} -do_test lock5-flock.3 { - execsql { SELECT * FROM t1 } db2 -} {1 2} -do_test lock5-none.4 { - execsql { - BEGIN; - SELECT * FROM t1; - } db2 -} {1 2} -do_test lock5-none.5 { - execsql COMMIT - execsql {SELECT * FROM t1} db2 -} {1 2} -ifcapable memorymanage { - do_test lock5-none.6 { - sqlite3_release_memory 1000000 - execsql {SELECT * FROM t1} db2 - } {1 2 3 4} + do_test lock5-flock.X { + db close + db2 close + } {} } -do_test lock5-flock.X { - db close - db2 close -} {} - ifcapable lock_proxy_pragmas { set env(SQLITE_FORCE_PROXY_LOCKING) $::using_proxy } diff --git a/test/lock_proxy.test b/test/lock_proxy.test index 60ea95b194..827dbbd8f4 100644 --- a/test/lock_proxy.test +++ b/test/lock_proxy.test @@ -26,21 +26,35 @@ if {[catch {sqlite3 db test.db -vfs unix-none} msg]} { db close file delete -force test.db.lock +##################################################################### ifcapable lock_proxy_pragmas { set ::using_proxy 0 foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] { set ::using_proxy $value } - # Disable the proxy locking for these tests - set env(SQLITE_FORCE_PROXY_LOCKING) "0" -} + # enable the proxy locking for these tests + set env(SQLITE_FORCE_PROXY_LOCKING) "1" -##################################################################### + # test conch file creation + # + + catch { file delete lock_proxy_test.db } + catch { file delete .lock_proxy_test.db-conch } + # test that proxy locking mode creates conch files + do_test lock_proxy1.0 { + sqlite3 db2 lock_proxy_test.db + catchsql { + create table x(y); + } db2 + file exists .lock_proxy_test.db-conch + } {1} + catch { db2 close } + + + # test proxy locking readonly file system handling + # -# test proxy locking readonly file system handling -# -ifcapable lock_proxy_pragmas { if {[file exists /usr/bin/hdiutil]} { puts "Creating readonly file system for proxy locking tests..." @@ -52,15 +66,16 @@ ifcapable lock_proxy_pragmas { } exec hdiutil create -megabytes 1 -fs HFS+ readonly.dmg -volname readonly exec hdiutil attach readonly.dmg - set sqlite_hostid_num 4 - set env(SQLITE_FORCE_PROXY_LOCKING) "1" + # create test1.db and a .test1.db-conch for host4 + set sqlite_hostid_num 4 sqlite3 db2 /Volumes/readonly/test1.db execsql { create table x(y); } db2 db2 close + # create test2.db and a .test2.db-conch for host5 set sqlite_hostid_num 5 sqlite3 db2 /Volumes/readonly/test2.db execsql { @@ -68,16 +83,19 @@ ifcapable lock_proxy_pragmas { } db2 db2 close + # create test3.db without a conch file set env(SQLITE_FORCE_PROXY_LOCKING) "0" sqlite3 db2 /Volumes/readonly/test3.db execsql { create table x(y); } db2 db2 close - set env(SQLITE_FORCE_PROXY_LOCKING) "1" exec hdiutil detach /Volumes/readonly exec hdiutil attach -readonly readonly.dmg + # test that an unwritable, host-mismatched conch file prevents + # read only proxy-locking mode database access + set env(SQLITE_FORCE_PROXY_LOCKING) "1" do_test lock_proxy2.0 { sqlite3 db2 /Volumes/readonly/test1.db catchsql { @@ -86,6 +104,8 @@ ifcapable lock_proxy_pragmas { } {1 {database is locked}} catch { db2 close } + # test that an unwritable, host-matching conch file allows + # read only proxy-locking mode database access do_test lock_proxy2.1 { sqlite3 db2 /Volumes/readonly/test2.db catchsql { @@ -94,6 +114,8 @@ ifcapable lock_proxy_pragmas { } {0 {table x x 2 {CREATE TABLE x(y)}}} catch { db2 close } + # test that an unwritable, nonexistant conch file allows + # read only proxy-locking mode database access do_test lock_proxy2.2 { sqlite3 db2 /Volumes/readonly/test3.db catchsql { diff --git a/test/manydb.test b/test/manydb.test index b9a8eaf8d4..4c69e88344 100644 --- a/test/manydb.test +++ b/test/manydb.test @@ -22,12 +22,8 @@ set N 300 # if we're using proxy locks, we use 5 filedescriptors for a db # that is open and in the middle of writing changes, normally # sqlite uses 3 (proxy locking adds the conch and the local lock) -set using_proxy 0 -foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] { - set using_proxy value -} set num_fd_per_openwrite_db 3 -if {$using_proxy>0} { +if {[forced_proxy_locking]} { set num_fd_per_openwrite_db 5 } diff --git a/test/pager1.test b/test/pager1.test index 7f28002705..cffa66102b 100644 --- a/test/pager1.test +++ b/test/pager1.test @@ -540,7 +540,11 @@ foreach {tn1 tcl} { # a valid page record (if the file page-size is 512 bytes). So as to # make sure SQLite doesn't get confused by this. # - set nPadding [expr 511 - $::mj_filename_length] + set target_length 511 + if { [forced_proxy_locking] } { + set target_length 255 + } + set nPadding [expr $target_length - $::mj_filename_length] if {$tcl_platform(platform)=="windows"} { # TBD need to figure out how to do this correctly for Windows!!! set nPadding [expr 255 - $::mj_filename_length] @@ -561,6 +565,7 @@ foreach {tn1 tcl} { set padding [string repeat x [expr $nPadding %32]] set prefix "test.db${padding}" + set prefix } } { eval $tcl @@ -1077,47 +1082,54 @@ do_execsql_test pager1-6.9 { COMMIT } {} # $ws: The expected size of the WAL file, in bytes, after executing # the SQL script. Or -1 if the WAL is not expected to exist. # -ifcapable wal { - faultsim_delete_and_reopen - foreach {tn sql res js ws} [subst { - - 1 { - CREATE TABLE t1(a, b); - PRAGMA auto_vacuum=OFF; - PRAGMA synchronous=NORMAL; - PRAGMA page_size=1024; - PRAGMA locking_mode=EXCLUSIVE; - PRAGMA journal_mode=TRUNCATE; - INSERT INTO t1 VALUES(1, 2); - } {exclusive truncate} 0 -1 - - 2 { - BEGIN IMMEDIATE; - SELECT * FROM t1; - COMMIT; - } {1 2} 0 -1 - - 3 { - BEGIN; - SELECT * FROM t1; - COMMIT; - } {1 2} 0 -1 - - 4 { PRAGMA journal_mode = WAL } wal -1 -1 - 5 { INSERT INTO t1 VALUES(3, 4) } {} -1 [wal_file_size 1 1024] - 6 { PRAGMA locking_mode = NORMAL } normal -1 [wal_file_size 1 1024] - 7 { INSERT INTO t1 VALUES(5, 6); } {} -1 [wal_file_size 2 1024] - - 8 { PRAGMA journal_mode = TRUNCATE } truncate 0 -1 - 9 { INSERT INTO t1 VALUES(7, 8) } {} 0 -1 - 10 { SELECT * FROM t1 } {1 2 3 4 5 6 7 8} 0 -1 - - }] { - do_execsql_test pager1-7.1.$tn.1 $sql $res - catch { set J -1 ; set J [file size test.db-journal] } - catch { set W -1 ; set W [file size test.db-wal] } - do_test pager1-7.1.$tn.2 { list $J $W } [list $js $ws] +set do_wal_tests [wal_is_ok] +if { $do_wal_tests } { + ifcapable wal { + faultsim_delete_and_reopen + foreach {tn sql res js ws} [subst { + + 1 { + CREATE TABLE t1(a, b); + PRAGMA auto_vacuum=OFF; + PRAGMA synchronous=NORMAL; + PRAGMA page_size=1024; + PRAGMA locking_mode=EXCLUSIVE; + PRAGMA journal_mode=TRUNCATE; + INSERT INTO t1 VALUES(1, 2); + } {exclusive truncate} 0 -1 + + 2 { + BEGIN IMMEDIATE; + SELECT * FROM t1; + COMMIT; + } {1 2} 0 -1 + + 3 { + BEGIN; + SELECT * FROM t1; + COMMIT; + } {1 2} 0 -1 + + 4 { PRAGMA journal_mode = WAL } wal -1 -1 + 5 { INSERT INTO t1 VALUES(3, 4) } {} -1 [wal_file_size 1 1024] + 6 { PRAGMA locking_mode = NORMAL } normal -1 [wal_file_size 1 1024] + 7 { INSERT INTO t1 VALUES(5, 6); } {} -1 [wal_file_size 2 1024] + + 8 { PRAGMA journal_mode = TRUNCATE } truncate 0 -1 + 9 { INSERT INTO t1 VALUES(7, 8) } {} 0 -1 + 10 { SELECT * FROM t1 } {1 2 3 4 5 6 7 8} 0 -1 + + }] { + do_execsql_test pager1-7.1.$tn.1 $sql $res + catch { set J -1 ; set J [file size test.db-journal] } + catch { set W -1 ; set W [file size test.db-wal] } + do_test pager1-7.1.$tn.2 { list $J $W } [list $js $ws] + } } +} else { + do_test pager1-7.1.wal_is_not_ok { + execsql { PRAGMA journal_mode = WAL } + } {delete} } do_test pager1-7.2.1 { @@ -1290,9 +1302,15 @@ do_test pager1-9.4.1 { sqlite3_backup B db2 main db main list [B step 10000] [B finish] } {SQLITE_DONE SQLITE_OK} -do_test pager1-9.4.2 { - list [file size test.db2] [file size test.db] -} {0 0} +if { [path_is_dos "."] } { + do_test pager1-9.4.2_dos { + list [file size test.db2] [file size test.db] + } {0 1} +} else { + do_test pager1-9.4.2 { + list [file size test.db2] [file size test.db] + } {0 0} +} db2 close #------------------------------------------------------------------------- @@ -1915,32 +1933,34 @@ do_test pager1-20.2.2 { } } {} -do_test pager1-20.3.1 { - faultsim_delete_and_reopen - db func a_string a_string - execsql { - PRAGMA cache_size = 10; - PRAGMA journal_mode = wal; - BEGIN; - CREATE TABLE t1(x); - CREATE TABLE t2(y); - INSERT INTO t1 VALUES(a_string(800)); - INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */ - INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */ - INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */ - INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */ - INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */ - COMMIT; - } -} {wal} -do_test pager1-20.3.2 { - execsql { - BEGIN; - INSERT INTO t2 VALUES('xxxx'); - } - recursive_select 32 t1 - execsql COMMIT -} {} +if { $do_wal_tests } { + do_test pager1-20.3.1 { + faultsim_delete_and_reopen + db func a_string a_string + execsql { + PRAGMA cache_size = 10; + PRAGMA journal_mode = wal; + BEGIN; + CREATE TABLE t1(x); + CREATE TABLE t2(y); + INSERT INTO t1 VALUES(a_string(800)); + INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */ + INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */ + INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */ + INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */ + INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */ + COMMIT; + } + } {wal} + do_test pager1-20.3.2 { + execsql { + BEGIN; + INSERT INTO t2 VALUES('xxxx'); + } + recursive_select 32 t1 + execsql COMMIT + } {} +} #------------------------------------------------------------------------- # Test that a WAL database may not be opened if: @@ -1948,28 +1968,30 @@ do_test pager1-20.3.2 { # pager1-21.1.*: The VFS has an iVersion less than 2, or # pager1-21.2.*: The VFS does not provide xShmXXX() methods. # -do_test pager1-21.0 { - faultsim_delete_and_reopen - execsql { - PRAGMA journal_mode = WAL; - CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def'); - INSERT INTO ko DEFAULT VALUES; - } -} {wal} -do_test pager1-21.1 { - testvfs tv -noshm 1 - sqlite3 db2 test.db -vfs tv - catchsql { SELECT * FROM ko } db2 -} {1 {unable to open database file}} -db2 close -tv delete -do_test pager1-21.2 { - testvfs tv -iversion 1 - sqlite3 db2 test.db -vfs tv - catchsql { SELECT * FROM ko } db2 -} {1 {unable to open database file}} -db2 close -tv delete +if { $do_wal_tests } { + do_test pager1-21.0 { + faultsim_delete_and_reopen + execsql { + PRAGMA journal_mode = WAL; + CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def'); + INSERT INTO ko DEFAULT VALUES; + } + } {wal} + do_test pager1-21.1 { + testvfs tv -noshm 1 + sqlite3 db2 test.db -vfs tv + catchsql { SELECT * FROM ko } db2 + } {1 {unable to open database file}} + db2 close + tv delete + do_test pager1-21.2 { + testvfs tv -iversion 1 + sqlite3 db2 test.db -vfs tv + catchsql { SELECT * FROM ko } db2 + } {1 {unable to open database file}} + db2 close + tv delete +} #------------------------------------------------------------------------- # Test that a "PRAGMA wal_checkpoint": diff --git a/test/shared.test b/test/shared.test index 9b04946420..6d7c414641 100644 --- a/test/shared.test +++ b/test/shared.test @@ -45,13 +45,9 @@ ifcapable autovacuum { # if we're using proxy locks, we use 2 filedescriptors for a db # that is open but NOT yet locked, after a lock is taken we'll have 3, # normally sqlite uses 1 (proxy locking adds the conch and the local lock) -set using_proxy 0 -foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] { - set using_proxy $value -} set extrafds_prelock 0 set extrafds_postlock 0 -if {$using_proxy>0} { +if {[forced_proxy_locking]} { set extrafds_prelock 1 set extrafds_postlock 2 } diff --git a/test/stat.test b/test/stat.test index 177da0a40a..2f1e2b864b 100644 --- a/test/stat.test +++ b/test/stat.test @@ -30,12 +30,13 @@ do_execsql_test stat-0.0 { CREATE VIRTUAL TABLE temp.stat USING dbstat; SELECT * FROM stat; } {} -do_execsql_test stat-0.1 { - PRAGMA journal_mode = WAL; - PRAGMA journal_mode = delete; - SELECT * FROM stat; -} {wal delete sqlite_master / 1 leaf 0 0 916 0} - +if {[wal_is_ok]} { + do_execsql_test stat-0.1 { + PRAGMA journal_mode = WAL; + PRAGMA journal_mode = delete; + SELECT * FROM stat; + } {wal delete sqlite_master / 1 leaf 0 0 916 0} +} do_test stat-1.0 { execsql { CREATE TABLE t1(a, b); diff --git a/test/stmt.test b/test/stmt.test index 482a7d4a3a..f11a2d2c52 100644 --- a/test/stmt.test +++ b/test/stmt.test @@ -30,8 +30,19 @@ if {$::TEMP_STORE==3} { finish_test return } + +# if we're using proxy locks, we use 3 filedescriptors for a db +# that is open but NOT writing changes, normally +# sqlite uses 1 (proxy locking adds the conch and the local lock) +set extrafds 0 +if {[forced_proxy_locking]} { + set extrafds 2 +} + + do_test stmt-1.2 { set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {1} do_test stmt-1.3 { execsql { @@ -39,16 +50,19 @@ do_test stmt-1.3 { INSERT INTO t1 VALUES(1, 1); } set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {2} do_test stmt-1.4 { execsql { INSERT INTO t1 SELECT a+1, b+1 FROM t1; } set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {3} do_test stmt-1.5 { execsql COMMIT set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {1} do_test stmt-1.6.1 { execsql { @@ -56,34 +70,37 @@ do_test stmt-1.6.1 { INSERT INTO t1 SELECT a+2, b+2 FROM t1; } set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {2} do_test stmt-1.6.2 { execsql { INSERT INTO t1 SELECT a+4, b+4 FROM t1 } set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {3} do_test stmt-1.7 { execsql COMMIT set sqlite_open_file_count + expr $sqlite_open_file_count-$extrafds } {1} -proc filecount {testname sql expected} { +proc filecount {testname sql expected extrafds} { uplevel [list do_test $testname [subst -nocommand { execsql BEGIN execsql { $sql } set ret [set sqlite_open_file_count] execsql ROLLBACK set ret - }] $expected] + }] [ expr $expected+$extrafds ] ] } -filecount stmt-2.1 { INSERT INTO t1 VALUES(9, 9) } 2 -filecount stmt-2.2 { REPLACE INTO t1 VALUES(9, 9) } 2 -filecount stmt-2.3 { INSERT INTO t1 SELECT 9, 9 } 2 +filecount stmt-2.1 { INSERT INTO t1 VALUES(9, 9) } 2 $extrafds +filecount stmt-2.2 { REPLACE INTO t1 VALUES(9, 9) } 2 $extrafds +filecount stmt-2.3 { INSERT INTO t1 SELECT 9, 9 } 2 $extrafds filecount stmt-2.4 { INSERT INTO t1 SELECT 9, 9; INSERT INTO t1 SELECT 10, 10; -} 3 +} 3 $extrafds do_test stmt-2.5 { execsql { CREATE INDEX i1 ON t1(b) } @@ -91,6 +108,6 @@ do_test stmt-2.5 { filecount stmt-2.6 { REPLACE INTO t1 VALUES(5, 5); REPLACE INTO t1 VALUES(5, 5); -} 3 +} 3 $extrafds finish_test diff --git a/test/tempdb.test b/test/tempdb.test index ef0c906bf0..311265132e 100644 --- a/test/tempdb.test +++ b/test/tempdb.test @@ -52,6 +52,11 @@ do_test tempdb-1.2 { } } {} +set extrafds 0 +if {[forced_proxy_locking]} { + set extrafds 2 +} + do_test tempdb-2.1 { # Set $::jrnl_in_memory if the journal file is expected to be in-memory. # Similarly, set $::subj_in_memory if the sub-journal file is expected @@ -76,7 +81,7 @@ do_test tempdb-2.2 { } catchsql { INSERT INTO t1 SELECT * FROM t2 } set sqlite_open_file_count -} [expr 1 + (0==$jrnl_in_memory) + (0==$subj_in_memory)] +} [expr 1 + $extrafds + (0==$jrnl_in_memory) + (0==$subj_in_memory)] do_test tempdb-2.3 { execsql { PRAGMA temp_store = 'memory'; @@ -88,6 +93,6 @@ do_test tempdb-2.3 { } catchsql { INSERT INTO t1 SELECT * FROM t2 } set sqlite_open_file_count -} [expr 1 + (0==$jrnl_in_memory)] +} [expr 1 + $extrafds + (0==$jrnl_in_memory)] finish_test diff --git a/test/tester.tcl b/test/tester.tcl index 05ed0b50b2..fc2fd73e69 100644 --- a/test/tester.tcl +++ b/test/tester.tcl @@ -1150,6 +1150,35 @@ proc permutation {} { set perm } +proc forced_proxy_locking {} { + ifcapable lock_proxy_pragmas&&prefer_proxy_locking { + set force_proxy_value 0 + set force_key "SQLITE_FORCE_PROXY_LOCKING=" + foreach {env_pair} [exec env] { + if { [string first $force_key $env_pair] == 0} { + set force_proxy_value [string range $env_pair [string length $force_key] end] + } + } + if { "$force_proxy_value " == "1 " } { + return 1 + } + } + return 0 +} + +proc wal_is_ok {} { + if { [forced_proxy_locking] } { + return 0 + } + if { ![path_is_local "."] } { + return 0 + } + if { [path_is_dos "."] } { + return 0 + } + return 1 +} + #------------------------------------------------------------------------- # proc slave_test_script {script} { diff --git a/test/tkt3457.test b/test/tkt3457.test index 71eb424640..495ea3e16f 100644 --- a/test/tkt3457.test +++ b/test/tkt3457.test @@ -62,26 +62,28 @@ do_test tkt3457-1.1 { execsql COMMIT } {} -do_test tkt3457-1.2 { - file copy -force bak.db-journal test.db-journal - file attributes test.db-journal -permissions --------- - catchsql { SELECT * FROM t1 } -} {1 {unable to open database file}} -do_test tkt3457-1.3 { - file copy -force bak.db-journal test.db-journal - file attributes test.db-journal -permissions -w--w--w- - catchsql { SELECT * FROM t1 } -} {1 {unable to open database file}} -do_test tkt3457-1.4 { - file copy -force bak.db-journal test.db-journal - file attributes test.db-journal -permissions r--r--r-- - catchsql { SELECT * FROM t1 } -} {1 {unable to open database file}} +if { ![path_is_dos "."] } { + do_test tkt3457-1.2 { + file copy -force bak.db-journal test.db-journal + file attributes test.db-journal -permissions --------- + catchsql { SELECT * FROM t1 } + } {1 {unable to open database file}} + do_test tkt3457-1.3 { + file copy -force bak.db-journal test.db-journal + file attributes test.db-journal -permissions -w--w--w- + catchsql { SELECT * FROM t1 } + } {1 {unable to open database file}} + do_test tkt3457-1.4 { + file copy -force bak.db-journal test.db-journal + file attributes test.db-journal -permissions r--r--r-- + catchsql { SELECT * FROM t1 } + } {1 {unable to open database file}} -do_test tkt3457-1.5 { - file copy -force bak.db-journal test.db-journal - file attributes test.db-journal -permissions rw-rw-rw- - catchsql { SELECT * FROM t1 } -} {0 {1 2 3 4 5 6}} + do_test tkt3457-1.5 { + file copy -force bak.db-journal test.db-journal + file attributes test.db-journal -permissions rw-rw-rw- + catchsql { SELECT * FROM t1 } + } {0 {1 2 3 4 5 6}} +} finish_test diff --git a/test/wal.test b/test/wal.test index 59097dc740..4bcfed5187 100644 --- a/test/wal.test +++ b/test/wal.test @@ -20,6 +20,10 @@ source $testdir/malloc_common.tcl source $testdir/wal_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} proc reopen_db {} { catch { db close } diff --git a/test/wal2.test b/test/wal2.test index c4d7fa7bc5..9481e2afa7 100644 --- a/test/wal2.test +++ b/test/wal2.test @@ -20,6 +20,10 @@ source $testdir/malloc_common.tcl source $testdir/wal_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] || [path_is_dos "."]} { + finish_test + return +} proc set_tvfs_hdr {file args} { diff --git a/test/wal3.test b/test/wal3.test index b344c1423d..3d784d12a4 100644 --- a/test/wal3.test +++ b/test/wal3.test @@ -19,6 +19,10 @@ source $testdir/lock_common.tcl source $testdir/wal_common.tcl source $testdir/malloc_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} set a_string_counter 1 proc a_string {n} { diff --git a/test/wal4.test b/test/wal4.test index 22ccfea72d..5e86c15b0b 100644 --- a/test/wal4.test +++ b/test/wal4.test @@ -16,6 +16,10 @@ set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/malloc_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] || [path_is_dos "."]} { + finish_test + return +} do_test wal4-1.1 { execsql { diff --git a/test/walbak.test b/test/walbak.test index fe5b99e1a4..48ecf8299d 100644 --- a/test/walbak.test +++ b/test/walbak.test @@ -21,6 +21,10 @@ source $testdir/malloc_common.tcl do_not_use_codec ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} # Test organization: diff --git a/test/walbig.test b/test/walbig.test index 9ceb8ede6d..98dbcc9403 100644 --- a/test/walbig.test +++ b/test/walbig.test @@ -27,6 +27,10 @@ ifcapable !lfs { finish_test return } +if { ![wal_is_ok] } { + finish_test + return +} set a_string_counter 1 proc a_string {n} { diff --git a/test/walcksum.test b/test/walcksum.test index b2c4a90530..269e80adf1 100644 --- a/test/walcksum.test +++ b/test/walcksum.test @@ -16,6 +16,10 @@ source $testdir/lock_common.tcl source $testdir/wal_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} # Read and return the contents of file $filename. Treat the content as # binary data. diff --git a/test/walcrash.test b/test/walcrash.test index 0ef21fff3a..964667d01a 100644 --- a/test/walcrash.test +++ b/test/walcrash.test @@ -28,6 +28,10 @@ set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} db close diff --git a/test/walcrash2.test b/test/walcrash2.test index 7116281c2d..60265de485 100644 --- a/test/walcrash2.test +++ b/test/walcrash2.test @@ -16,6 +16,10 @@ source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/wal_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} #------------------------------------------------------------------------- diff --git a/test/walfault.test b/test/walfault.test index f22a40ecfd..716cf95bf8 100644 --- a/test/walfault.test +++ b/test/walfault.test @@ -19,6 +19,10 @@ source $testdir/malloc_common.tcl source $testdir/lock_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} #------------------------------------------------------------------------- # This test case, walfault-1-*, simulates faults while executing a diff --git a/test/walhook.test b/test/walhook.test index 631ec834e3..23c27f729a 100644 --- a/test/walhook.test +++ b/test/walhook.test @@ -22,6 +22,10 @@ source $testdir/tester.tcl source $testdir/wal_common.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} set ::wal_hook [list] proc wal_hook {zDb nEntry} { diff --git a/test/walmode.test b/test/walmode.test index 1a54277418..938c65a029 100644 --- a/test/walmode.test +++ b/test/walmode.test @@ -35,6 +35,20 @@ ifcapable !wal { finish_test return } +if { ![wal_is_ok] } { + do_test walmode-0.1 { + execsql { PRAGMA journal_mode = wal } + } {delete} + do_test walmode-0.2 { + execsql { PRAGMA main.journal_mode = wal } + } {delete} + do_test walmode-0.3 { + execsql { PRAGMA main.journal_mode } + } {delete} + + finish_test + return +} do_test walmode-1.1 { set sqlite_sync_count 0 diff --git a/test/walslow.test b/test/walslow.test index d726952804..4ade626669 100644 --- a/test/walslow.test +++ b/test/walslow.test @@ -18,6 +18,10 @@ set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable !wal {finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} proc reopen_db {} { catch { db close } diff --git a/test/walthread.test b/test/walthread.test index 9817c0e0f5..bcc434a1de 100644 --- a/test/walthread.test +++ b/test/walthread.test @@ -19,6 +19,10 @@ source $testdir/tester.tcl source $testdir/lock_common.tcl if {[run_thread_tests]==0} { finish_test ; return } ifcapable !wal { finish_test ; return } +if { ![wal_is_ok] } { + finish_test + return +} set sqlite_walsummary_mmap_incr 64