Merge in the blocking-checkpoint enhancement, including the new
sqlite3_wal_checkpoint_v2() interface and the PRAGMA wal_checkpoint(full) statement. FossilOrigin-Name: bac7342c368a7c4f5f2878e08d9581dcbf57dd58
This commit is contained in:
drh
commit
87fa53ee8d
4
main.mk
4
main.mk
@ -536,8 +536,8 @@ test: testfixture$(EXE) sqlite3$(EXE)
|
||||
# threadtest runs a few thread-safety tests that are implemented in C. This
|
||||
# target is invoked by the releasetest.tcl script.
|
||||
#
|
||||
threadtest3$(EXE): sqlite3.c $(TOP)/test/threadtest3.c
|
||||
$(TCCX) -O2 sqlite3.c $(TOP)/test/threadtest3.c \
|
||||
threadtest3$(EXE): sqlite3.o $(TOP)/test/threadtest3.c $(TOP)/test/tt3_checkpoint.c
|
||||
$(TCCX) -O2 sqlite3.o $(TOP)/test/threadtest3.c \
|
||||
-o threadtest3$(EXE) $(THREADLIB)
|
||||
|
||||
threadtest: threadtest3$(EXE)
|
||||
|
||||
62
manifest
62
manifest
@ -1,5 +1,8 @@
|
||||
C Merge\sfts4aux\sbranch.
|
||||
D 2011-02-02T04:40:07.295
|
||||
-----BEGIN PGP SIGNED MESSAGE-----
|
||||
Hash: SHA1
|
||||
|
||||
C Merge\sin\sthe\sblocking-checkpoint\senhancement,\sincluding\sthe\snew\nsqlite3_wal_checkpoint_v2()\sinterface\sand\sthe\nPRAGMA\swal_checkpoint(full)\sstatement.
|
||||
D 2011-02-02T16:34:08.739
|
||||
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
|
||||
F Makefile.in de6498556d536ae60bb8bb10e8c1ba011448658c
|
||||
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
|
||||
@ -100,7 +103,7 @@ F ext/rtree/tkt3363.test 142ab96eded44a3615ec79fba98c7bde7d0f96de
|
||||
F ext/rtree/viewrtree.tcl eea6224b3553599ae665b239bd827e182b466024
|
||||
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
|
||||
F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
|
||||
F main.mk 589cd0fdc9d9bf7a8220511ff5db5bd57efe3558
|
||||
F main.mk 54190fab7cdba523e311c274c95ea480f32abfb5
|
||||
F mkdll.sh 7d09b23c05d56532e9d44a50868eb4b12ff4f74a
|
||||
F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f
|
||||
F mkextw.sh 4123480947681d9b434a5e7b1ee08135abe409ac
|
||||
@ -120,8 +123,8 @@ F src/auth.c 523da7fb4979469955d822ff9298352d6b31de34
|
||||
F src/backup.c 6728d6d48d55b449af76a3e51c0808849cb32a2e
|
||||
F src/bitvec.c af50f1c8c0ff54d6bdb7a80e2fceca5a93670bef
|
||||
F src/btmutex.c 96a12f50f7a17475155971a241d85ec5171573ff
|
||||
F src/btree.c 9004c98fc576306eee4fc0562ffeb362ef53912c
|
||||
F src/btree.h 10f9296bf4edf034f5adce921b7b4383a56a1c90
|
||||
F src/btree.c cefe096650179dc4c5d876e7a27593ff1e6a86ed
|
||||
F src/btree.h e2f2cd9933bf30724f53ffa12c4c5a3a864bbd6e
|
||||
F src/btreeInt.h 20f73dc93b1eeb83afd7259fbc6bd7dcf2df7fe4
|
||||
F src/build.c 00a327120d81ace6267e714ae8010c997d55de5d
|
||||
F src/callback.c a1d1b1c9c85415dff013af033e2fed9c8382d33b
|
||||
@ -142,7 +145,7 @@ F src/journal.c 552839e54d1bf76fb8f7abe51868b66acacf6a0e
|
||||
F src/legacy.c a199d7683d60cef73089e892409113e69c23a99f
|
||||
F src/lempar.c 7f026423f4d71d989e719a743f98a1cbd4e6d99e
|
||||
F src/loadext.c 8af9fcc75708d60b88636ccba38b4a7b3c155c3e
|
||||
F src/main.c 6653e46db7ecb5a7449d8a12900147192f748b97
|
||||
F src/main.c 1b04ef67eb03d026c8cc2d438c61635163153c24
|
||||
F src/malloc.c 92d59a007d7a42857d4e9454aa25b6b703286be1
|
||||
F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
|
||||
F src/mem1.c 00bd8265c81abb665c48fea1e0c234eb3b922206
|
||||
@ -163,13 +166,13 @@ F src/os_common.h a8f95b81eca8a1ab8593d23e94f8a35f35d4078f
|
||||
F src/os_os2.c 2e452c9f2ca507623ad351c33a8a8b27849b1863
|
||||
F src/os_unix.c 1be46a35bad4bec5171e4de88aaff817260eb378
|
||||
F src/os_win.c 9abdcdd925416d854eabb0996c96debd92abfef5
|
||||
F src/pager.c c22b8531596c984dcc6b90645714b7ed951023fe
|
||||
F src/pager.h 0ea59db2a33bc6c2c02cae34de33367e1effdf76
|
||||
F src/pager.c d62dfc1d77168c4415e7f3e23c6dbee4f3fdff60
|
||||
F src/pager.h 3f8c783de1d4706b40b1ac15b64f5f896bcc78d1
|
||||
F src/parse.y 12b7ebd61ea54f0e1b1083ff69cc2c8ce9353d58
|
||||
F src/pcache.c 09d38c44ab275db581f7a2f6ff8b9bc7f8c0faaa
|
||||
F src/pcache.h c683390d50f856d4cd8e24342ae62027d1bb6050
|
||||
F src/pcache1.c d548e31beafa792d1994b663a29a5303569efc4e
|
||||
F src/pragma.c 8a6cd3c787f882fa44f6490d2411fc26839ce8f3
|
||||
F src/pragma.c 3d48a7f0a90bae8740adcc0d86e583b79da57f5b
|
||||
F src/prepare.c 395b3fab1b93f45b6aa194b23ebc201221c47b99
|
||||
F src/printf.c df2ff3bb5409e8958136933342c46464fbd017e7
|
||||
F src/random.c cd4a67b3953b88019f8cd4ccd81394a8ddfaba50
|
||||
@ -177,9 +180,9 @@ F src/resolve.c 1c0f32b64f8e3f555fe1f732f9d6f501a7f05706
|
||||
F src/rowset.c 69afa95a97c524ba6faf3805e717b5b7ae85a697
|
||||
F src/select.c 8a7ba246b0b4bb45df7fbc52681728a0e3deaaa7
|
||||
F src/shell.c 83c6f0cc5a79a081c7b9ddfe4f557b47e0bad976
|
||||
F src/sqlite.h.in 7599c4975cd0d0fff8d8d8cd3e423ca893b48f47
|
||||
F src/sqlite.h.in c0456330093737c74409e7f7d89d0f1e0dbf43b7
|
||||
F src/sqlite3ext.h c90bd5507099f62043832d73f6425d8d5c5da754
|
||||
F src/sqliteInt.h 45926deaf59b1ce3f55d21d5f91a8cecb6a7eb4c
|
||||
F src/sqliteInt.h 4290fff17fabc6e07fc4338233df0e39e6350ca1
|
||||
F src/sqliteLimit.h a17dcd3fb775d63b64a43a55c54cb282f9726f44
|
||||
F src/status.c 4997380fbb915426fef9e500b4872e79c99267fc
|
||||
F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
|
||||
@ -229,7 +232,7 @@ F src/update.c 227e6cd512108b84f69421fc6c7aa1b83d60d6e0
|
||||
F src/utf.c 1baeeac91707a4df97ccc6141ec0f808278af685
|
||||
F src/util.c ab1c92426494f499f42b9e307537b03e923d75c1
|
||||
F src/vacuum.c 924bd1bcee2dfb05376f79845bd3b4cec7b54b2f
|
||||
F src/vdbe.c 5d310eaf1a4d8383602126fa82e01291ab7d3cf3
|
||||
F src/vdbe.c 7f54982de40509458ee7ede8e356dccc19f5b161
|
||||
F src/vdbe.h 4de0efb4b0fdaaa900cf419b35c458933ef1c6d2
|
||||
F src/vdbeInt.h 6e6f28e9bccc6c703dca1372fd661c57b5c15fb0
|
||||
F src/vdbeapi.c 8e9324fd35eb70d0b5904bd1af40f2598744dc4d
|
||||
@ -238,8 +241,8 @@ F src/vdbeblob.c 18955f0ee6b133cd08e1592010cb9a6b11e9984c
|
||||
F src/vdbemem.c 411649a35686f54268ccabeda175322c4697f5a6
|
||||
F src/vdbetrace.c 3ba13bc32bdf16d2bdea523245fd16736bed67b5
|
||||
F src/vtab.c b297e8fa656ab5e66244ab15680d68db0adbec30
|
||||
F src/wal.c dbca424f71678f663a286ab2a98f947af1d412a7
|
||||
F src/wal.h c1aac6593a0b02b15dc625987e619edeab39292e
|
||||
F src/wal.c e6a609ab090eeb27013cf908a979e448859d01c7
|
||||
F src/wal.h 7a5fbb00114b7f2cd40c7e1003d4c41ce9d26840
|
||||
F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
|
||||
F src/where.c af069e6b53234118014dabfece96a9515b69d76b
|
||||
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
|
||||
@ -259,7 +262,7 @@ F test/async2.test bf5e2ca2c96763b4cba3d016249ad7259a5603b6
|
||||
F test/async3.test 93edaa9122f498e56ea98c36c72abc407f4fb11e
|
||||
F test/async4.test 1787e3952128aa10238bf39945126de7ca23685a
|
||||
F test/async5.test f3592d79c84d6e83a5f50d3fd500445f7d97dfdf
|
||||
F test/attach.test ce9660e51768fab93cf129787be886c5d6c4fd81
|
||||
F test/attach.test f2b4ac6931f45695082b9f02be959c9c262e4f4d
|
||||
F test/attach2.test a295d2d7061adcee5884ef4a93c7c96a82765437
|
||||
F test/attach3.test bd9830bc3a0d22ed1310c9bff6896927937017dc
|
||||
F test/attachmalloc.test 1d5b821a676f7bf0b00d87cc106b78966789ba57
|
||||
@ -579,7 +582,7 @@ F test/notify3.test d60923e186e0900f4812a845fcdfd8eea096e33a
|
||||
F test/notnull.test cc7c78340328e6112a13c3e311a9ab3127114347
|
||||
F test/null.test a8b09b8ed87852742343b33441a9240022108993
|
||||
F test/openv2.test af02ed0a9cbc0d2a61b8f35171d4d117e588e4ec
|
||||
F test/pager1.test 7006a8b5dd3df1fe0d51d7da014333d7dc099778
|
||||
F test/pager1.test d8672fd0af5f4f9b99b06283d00f01547809bebe
|
||||
F test/pager2.test 745b911dde3d1f24ae0870bd433dfa83d7c658c1
|
||||
F test/pager3.test 3856d9c80839be0668efee1b74811b1b7f7fc95f
|
||||
F test/pagerfault.test 9de4d3e0c59970b4c6cb8dac511fa242f335d8a7
|
||||
@ -678,7 +681,7 @@ F test/thread2.test e08034b83fe9693ade77049732518e5b3d2d700d
|
||||
F test/thread_common.tcl 2aa6f2fdcd4d6e461169c3e5ca098eebf643b863
|
||||
F test/threadtest1.c 6029d9c5567db28e6dc908a0c63099c3ba6c383b
|
||||
F test/threadtest2.c ace893054fa134af3fc8d6e7cfecddb8e3acefb9
|
||||
F test/threadtest3.c d6d209190c7110f9a7e6a8154bdc3260efdbf8b7
|
||||
F test/threadtest3.c 0ed13e09690f6204d7455fac3b0e8ece490f6eef
|
||||
F test/tkt-02a8e81d44.test 58494de77be2cf249228ada3f313fa399821c6ab
|
||||
F test/tkt-26ff0c2d1e.test 888324e751512972c6e0d1a09df740d8f5aaf660
|
||||
F test/tkt-2ea2425d34.test 1cf13e6f75d149b3209a0cb32927a82d3d79fb28
|
||||
@ -807,6 +810,7 @@ F test/triggerA.test eaf11a29db2a11967d2d4b49d37f92bce598194e
|
||||
F test/triggerB.test 56780c031b454abac2340dbb3b71ac5c56c3d7fe
|
||||
F test/triggerC.test 8a691ff6dd47df2e57395bbec4b62101fac0f363
|
||||
F test/triggerD.test c6add3817351451e419f6ff9e9a259b02b6e2de7
|
||||
F test/tt3_checkpoint.c 415eccce672d681b297485fc20f44cdf0eac93af
|
||||
F test/types.test bf816ce73c7dfcfe26b700c19f97ef4050d194ff
|
||||
F test/types2.test 3555aacf8ed8dc883356e59efc314707e6247a84
|
||||
F test/types3.test a0f66bf12f80fad89493535474f7a6d16fa58150
|
||||
@ -837,12 +841,13 @@ 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 70227190e713b3e7eb2a7d5ec3510b66db01f327
|
||||
F test/wal2.test 3de797854de175323e7351b5f2514a30d1ee1410
|
||||
F test/wal3.test ac51126c36814bce334f66a0a4dbbfa56d429733
|
||||
F test/wal.test f060cae4b2164c4375109a8f803873187234661d
|
||||
F test/wal2.test c9b23c97329a825415abb004d7502844d72fd8fc
|
||||
F test/wal3.test ec87d9dd9e9cebabed4024064e8ff531d336ead2
|
||||
F test/wal4.test 3404b048fa5e10605facaf70384e6d2943412e30
|
||||
F test/wal5.test 1f99651d856c8b9e1376781c981d1b903e93a478
|
||||
F test/wal6.test 07aa31ca8892d0527f2c5c5a9a2a87aa421dfaa8
|
||||
F test/wal_common.tcl 895d76138043b86bdccf36494054bdabcf65837b
|
||||
F test/wal_common.tcl a98f17fba96206122eff624db0ab13ec377be4fe
|
||||
F test/walbak.test 4df1c7369da0301caeb9a48fa45997fd592380e4
|
||||
F test/walbig.test e882bc1d014afffbfa2b6ba36e0f07d30a633ad0
|
||||
F test/walcksum.test a37b36375c595e61bdb7e1ec49b5f0979b6fc7ce
|
||||
@ -901,7 +906,14 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
|
||||
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
|
||||
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
|
||||
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
|
||||
P ed759d5a9edb3bba5f48f243df47be29e3fe8cd7 0147d9739f318a02721d3ae0e7be339a19231f60
|
||||
R 531c9b98b4934054a140000876bf40a8
|
||||
U dan
|
||||
Z d29ed65f9181e7ba0766a4c73453d1ce
|
||||
P c6d9f7d8c48e1ff405e1c1d98a166974fc829f58 ebf74015f09fe241c1c6902dc8954f2b59ab41ec
|
||||
R 0634baae0b43c2b82e8b9905e8c6ee5b
|
||||
U drh
|
||||
Z d29f42a4b972ec3903a5f796629ef74c
|
||||
-----BEGIN PGP SIGNATURE-----
|
||||
Version: GnuPG v1.4.10 (Darwin)
|
||||
|
||||
iEYEARECAAYFAk1Jh4EACgkQoxKgR168RlEDdgCfTySKHScQj7r5Q2WPZ7harLi+
|
||||
uBIAn0+3gnlHjhVd4fzemcV4FGDrMm/Y
|
||||
=REwF
|
||||
-----END PGP SIGNATURE-----
|
||||
|
||||
@ -1 +1 @@
|
||||
c6d9f7d8c48e1ff405e1c1d98a166974fc829f58
|
||||
bac7342c368a7c4f5f2878e08d9581dcbf57dd58
|
||||
@ -7932,8 +7932,10 @@ int sqlite3BtreeIsInTrans(Btree *p){
|
||||
**
|
||||
** Return SQLITE_LOCKED if this or any other connection has an open
|
||||
** transaction on the shared-cache the argument Btree is connected to.
|
||||
**
|
||||
** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
|
||||
*/
|
||||
int sqlite3BtreeCheckpoint(Btree *p){
|
||||
int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){
|
||||
int rc = SQLITE_OK;
|
||||
if( p ){
|
||||
BtShared *pBt = p->pBt;
|
||||
@ -7941,7 +7943,7 @@ int sqlite3BtreeCheckpoint(Btree *p){
|
||||
if( pBt->inTransaction!=TRANS_NONE ){
|
||||
rc = SQLITE_LOCKED;
|
||||
}else{
|
||||
rc = sqlite3PagerCheckpoint(pBt->pPager);
|
||||
rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
|
||||
}
|
||||
sqlite3BtreeLeave(p);
|
||||
}
|
||||
|
||||
@ -207,7 +207,7 @@ void sqlite3BtreeCursorList(Btree*);
|
||||
#endif
|
||||
|
||||
#ifndef SQLITE_OMIT_WAL
|
||||
int sqlite3BtreeCheckpoint(Btree*);
|
||||
int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
||||
47
src/main.c
47
src/main.c
@ -1340,19 +1340,29 @@ void *sqlite3_wal_hook(
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
|
||||
** to contains a zero-length string, all attached databases are
|
||||
** checkpointed.
|
||||
** Checkpoint database zDb.
|
||||
*/
|
||||
int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
|
||||
int sqlite3_wal_checkpoint_v2(
|
||||
sqlite3 *db, /* Database handle */
|
||||
const char *zDb, /* Name of attached database (or NULL) */
|
||||
int eMode, /* SQLITE_CHECKPOINT_* value */
|
||||
int *pnLog, /* OUT: Size of WAL log in frames */
|
||||
int *pnCkpt /* OUT: Total number of frames checkpointed */
|
||||
){
|
||||
#ifdef SQLITE_OMIT_WAL
|
||||
return SQLITE_OK;
|
||||
#else
|
||||
int rc; /* Return code */
|
||||
int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
|
||||
|
||||
if( eMode!=SQLITE_CHECKPOINT_PASSIVE
|
||||
&& eMode!=SQLITE_CHECKPOINT_FULL
|
||||
&& eMode!=SQLITE_CHECKPOINT_RESTART
|
||||
){
|
||||
return SQLITE_MISUSE;
|
||||
}
|
||||
|
||||
sqlite3_mutex_enter(db->mutex);
|
||||
if( zDb && zDb[0] ){
|
||||
iDb = sqlite3FindDbName(db, zDb);
|
||||
@ -1361,7 +1371,7 @@ int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
|
||||
rc = SQLITE_ERROR;
|
||||
sqlite3Error(db, SQLITE_ERROR, "unknown database: %s", zDb);
|
||||
}else{
|
||||
rc = sqlite3Checkpoint(db, iDb);
|
||||
rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
|
||||
sqlite3Error(db, rc, 0);
|
||||
}
|
||||
rc = sqlite3ApiExit(db, rc);
|
||||
@ -1370,6 +1380,16 @@ int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
|
||||
** to contains a zero-length string, all attached databases are
|
||||
** checkpointed.
|
||||
*/
|
||||
int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
|
||||
return sqlite3_wal_checkpoint_v2(db, zDb, SQLITE_CHECKPOINT_PASSIVE, 0, 0);
|
||||
}
|
||||
|
||||
#ifndef SQLITE_OMIT_WAL
|
||||
/*
|
||||
** Run a checkpoint on database iDb. This is a no-op if database iDb is
|
||||
@ -1387,20 +1407,29 @@ int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
|
||||
** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
|
||||
** checkpointed. If an error is encountered it is returned immediately -
|
||||
** no attempt is made to checkpoint any remaining databases.
|
||||
**
|
||||
** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
|
||||
*/
|
||||
int sqlite3Checkpoint(sqlite3 *db, int iDb){
|
||||
int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
|
||||
int rc = SQLITE_OK; /* Return code */
|
||||
int i; /* Used to iterate through attached dbs */
|
||||
int bBusy = 0; /* True if SQLITE_BUSY has been encountered */
|
||||
|
||||
assert( sqlite3_mutex_held(db->mutex) );
|
||||
|
||||
for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
|
||||
if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
|
||||
rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt);
|
||||
rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
|
||||
pnLog = 0;
|
||||
pnCkpt = 0;
|
||||
if( rc==SQLITE_BUSY ){
|
||||
bBusy = 1;
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return rc;
|
||||
return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
|
||||
}
|
||||
#endif /* SQLITE_OMIT_WAL */
|
||||
|
||||
|
||||
18
src/pager.c
18
src/pager.c
@ -2947,7 +2947,7 @@ static int pagerRollbackWal(Pager *pPager){
|
||||
** This function is a wrapper around sqlite3WalFrames(). As well as logging
|
||||
** the contents of the list of pages headed by pList (connected by pDirty),
|
||||
** this function notifies any active backup processes that the pages have
|
||||
** changed.
|
||||
** changed.
|
||||
**
|
||||
** The list of pages passed into this routine is always sorted by page number.
|
||||
** Hence, if page 1 appears anywhere on the list, it will be the first page.
|
||||
@ -6599,14 +6599,20 @@ sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
|
||||
|
||||
#ifndef SQLITE_OMIT_WAL
|
||||
/*
|
||||
** This function is called when the user invokes "PRAGMA checkpoint".
|
||||
** This function is called when the user invokes "PRAGMA wal_checkpoint",
|
||||
** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
|
||||
** or wal_blocking_checkpoint() API functions.
|
||||
**
|
||||
** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
|
||||
*/
|
||||
int sqlite3PagerCheckpoint(Pager *pPager){
|
||||
int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
|
||||
int rc = SQLITE_OK;
|
||||
if( pPager->pWal ){
|
||||
u8 *zBuf = (u8 *)pPager->pTmpSpace;
|
||||
rc = sqlite3WalCheckpoint(pPager->pWal, pPager->ckptSyncFlags,
|
||||
pPager->pageSize, zBuf);
|
||||
rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
|
||||
pPager->xBusyHandler, pPager->pBusyHandlerArg,
|
||||
pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
|
||||
pnLog, pnCkpt
|
||||
);
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
@ -138,7 +138,7 @@ int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
|
||||
int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
|
||||
int sqlite3PagerSharedLock(Pager *pPager);
|
||||
|
||||
int sqlite3PagerCheckpoint(Pager *pPager);
|
||||
int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*);
|
||||
int sqlite3PagerWalSupported(Pager *pPager);
|
||||
int sqlite3PagerWalCallback(Pager *pPager);
|
||||
int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
|
||||
|
||||
20
src/pragma.c
20
src/pragma.c
@ -1386,13 +1386,29 @@ void sqlite3Pragma(
|
||||
|
||||
#ifndef SQLITE_OMIT_WAL
|
||||
/*
|
||||
** PRAGMA [database.]wal_checkpoint
|
||||
** PRAGMA [database.]wal_checkpoint = passive|full|restart
|
||||
**
|
||||
** Checkpoint the database.
|
||||
*/
|
||||
if( sqlite3StrICmp(zLeft, "wal_checkpoint")==0 ){
|
||||
int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
|
||||
int eMode = SQLITE_CHECKPOINT_PASSIVE;
|
||||
if( zRight ){
|
||||
if( sqlite3StrICmp(zRight, "full")==0 ){
|
||||
eMode = SQLITE_CHECKPOINT_FULL;
|
||||
}else if( sqlite3StrICmp(zRight, "restart")==0 ){
|
||||
eMode = SQLITE_CHECKPOINT_RESTART;
|
||||
}
|
||||
}
|
||||
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
|
||||
sqlite3VdbeAddOp3(v, OP_Checkpoint, pId2->z?iDb:SQLITE_MAX_ATTACHED, 0, 0);
|
||||
sqlite3VdbeSetNumCols(v, 3);
|
||||
pParse->nMem = 3;
|
||||
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLITE_STATIC);
|
||||
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
|
||||
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLITE_STATIC);
|
||||
|
||||
sqlite3VdbeAddOp2(v, OP_Checkpoint, iBt, eMode);
|
||||
sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
|
||||
}else
|
||||
|
||||
/*
|
||||
|
||||
@ -2666,7 +2666,7 @@ const char *sqlite3_sql(sqlite3_stmt *pStmt);
|
||||
/*
|
||||
** CAPI3REF: Determine If An SQL Statement Writes The Database
|
||||
**
|
||||
** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
|
||||
** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
|
||||
** and only if the [prepared statement] X makes no direct changes to
|
||||
** the content of the database file.
|
||||
**
|
||||
@ -6250,6 +6250,89 @@ int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
|
||||
*/
|
||||
int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
|
||||
|
||||
/*
|
||||
**
|
||||
** CAPI3REF: Checkpoint a database
|
||||
**
|
||||
** Run a checkpoint operation on WAL database zDb attached to database
|
||||
** handle db. The specific operation is determined by the value of the
|
||||
** eMode parameter:
|
||||
**
|
||||
** <dl>
|
||||
** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
|
||||
** Checkpoint as many frames as possible without waiting for any database
|
||||
** readers or writers to finish. Sync the db file if all frames in the log
|
||||
** are checkpointed. This mode is the same as calling
|
||||
** sqlite3_wal_checkpoint(). The busy-handler callback is never invoked.
|
||||
**
|
||||
** <dt>SQLITE_CHECKPOINT_FULL<dd>
|
||||
** This mode blocks (calls the busy-handler callback) until there is no
|
||||
** database writer and all readers are reading from the most recent database
|
||||
** snapshot. It then checkpoints all frames in the log file and syncs the
|
||||
** database file. This call blocks database writers while it is running,
|
||||
** but not database readers.
|
||||
**
|
||||
** <dt>SQLITE_CHECKPOINT_RESTART<dd>
|
||||
** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after
|
||||
** checkpointing the log file it blocks (calls the busy-handler callback)
|
||||
** until all readers are reading from the database file only. This ensures
|
||||
** that the next client to write to the database file restarts the log file
|
||||
** from the beginning. This call blocks database writers while it is running,
|
||||
** but not database readers.
|
||||
** </dl>
|
||||
**
|
||||
** If pnLog is not NULL, then *pnLog is set to the total number of frames in
|
||||
** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
|
||||
** the total number of checkpointed frames (including any that were already
|
||||
** checkpointed when this function is called). *pnLog and *pnCkpt may be
|
||||
** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
|
||||
** If no values are available because of an error, they are both set to -1
|
||||
** before returning to communicate this to the caller.
|
||||
**
|
||||
** All calls obtain an exclusive "checkpoint" lock on the database file. If
|
||||
** any other process is running a checkpoint operation at the same time, the
|
||||
** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a
|
||||
** busy-handler configured, it will not be invoked in this case.
|
||||
**
|
||||
** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive
|
||||
** "writer" lock on the database file. If the writer lock cannot be obtained
|
||||
** immediately, and a busy-handler is configured, it is invoked and the writer
|
||||
** lock retried until either the busy-handler returns 0 or the lock is
|
||||
** successfully obtained. The busy-handler is also invoked while waiting for
|
||||
** database readers as described above. If the busy-handler returns 0 before
|
||||
** the writer lock is obtained or while waiting for database readers, the
|
||||
** checkpoint operation proceeds from that point in the same way as
|
||||
** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
|
||||
** without blocking any further. SQLITE_BUSY is returned in this case.
|
||||
**
|
||||
** If parameter zDb is NULL or points to a zero length string, then the
|
||||
** specified operation is attempted on all WAL databases. In this case the
|
||||
** values written to output parameters *pnLog and *pnCkpt are undefined. If
|
||||
** an SQLITE_BUSY error is encountered when processing one or more of the
|
||||
** attached WAL databases, the operation is still attempted on any remaining
|
||||
** attached databases and SQLITE_BUSY is returned to the caller. If any other
|
||||
** error occurs while processing an attached database, processing is abandoned
|
||||
** and the error code returned to the caller immediately. If no error
|
||||
** (SQLITE_BUSY or otherwise) is encountered while processing the attached
|
||||
** databases, SQLITE_OK is returned.
|
||||
**
|
||||
** If database zDb is the name of an attached database that is not in WAL
|
||||
** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
|
||||
** zDb is not NULL (or a zero length string) and is not the name of any
|
||||
** attached database, SQLITE_ERROR is returned to the caller.
|
||||
*/
|
||||
int sqlite3_wal_checkpoint_v2(
|
||||
sqlite3 *db, /* Database handle */
|
||||
const char *zDb, /* Name of attached database (or NULL) */
|
||||
int eMode, /* SQLITE_CHECKPOINT_* value */
|
||||
int *pnLog, /* OUT: Size of WAL log in frames */
|
||||
int *pnCkpt /* OUT: Total number of frames checkpointed */
|
||||
);
|
||||
#define SQLITE_CHECKPOINT_PASSIVE 0
|
||||
#define SQLITE_CHECKPOINT_FULL 1
|
||||
#define SQLITE_CHECKPOINT_RESTART 2
|
||||
|
||||
|
||||
/*
|
||||
** Undo the hack that converts floating point types to integer for
|
||||
** builds on processors without floating point support.
|
||||
|
||||
@ -3041,7 +3041,7 @@ CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
|
||||
int sqlite3TempInMemory(const sqlite3*);
|
||||
VTable *sqlite3GetVTable(sqlite3*, Table*);
|
||||
const char *sqlite3JournalModename(int);
|
||||
int sqlite3Checkpoint(sqlite3*, int);
|
||||
int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
|
||||
int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
|
||||
|
||||
/* Declarations for functions in fkey.c. All of these are replaced by
|
||||
|
||||
26
src/vdbe.c
26
src/vdbe.c
@ -5215,13 +5215,33 @@ case OP_AggFinal: {
|
||||
}
|
||||
|
||||
#ifndef SQLITE_OMIT_WAL
|
||||
/* Opcode: Checkpoint P1 * * * *
|
||||
/* Opcode: Checkpoint P1 P2 P3 * *
|
||||
**
|
||||
** Checkpoint database P1. This is a no-op if P1 is not currently in
|
||||
** WAL mode.
|
||||
** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
|
||||
** or RESTART.
|
||||
*/
|
||||
case OP_Checkpoint: {
|
||||
rc = sqlite3Checkpoint(db, pOp->p1);
|
||||
int nLog = -1; /* Number of pages in WAL log */
|
||||
int nCkpt = -1; /* Number of checkpointed pages */
|
||||
int bBusy = 0;
|
||||
assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
|
||||
|| pOp->p2==SQLITE_CHECKPOINT_FULL
|
||||
|| pOp->p2==SQLITE_CHECKPOINT_RESTART
|
||||
);
|
||||
rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &nLog, &nCkpt);
|
||||
if( rc==SQLITE_BUSY ){
|
||||
rc = SQLITE_OK;
|
||||
bBusy = 1;
|
||||
}
|
||||
|
||||
aMem[1].u.i = bBusy;
|
||||
aMem[2].u.i = nLog;
|
||||
aMem[3].u.i = nCkpt;
|
||||
MemSetTypeFlag(&aMem[1], MEM_Int);
|
||||
MemSetTypeFlag(&aMem[2], MEM_Int);
|
||||
MemSetTypeFlag(&aMem[3], MEM_Int);
|
||||
|
||||
break;
|
||||
};
|
||||
#endif
|
||||
|
||||
136
src/wal.c
136
src/wal.c
@ -1558,6 +1558,34 @@ static int walIteratorInit(Wal *pWal, WalIterator **pp){
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and
|
||||
** n. If the attempt fails and parameter xBusy is not NULL, then it is a
|
||||
** busy-handler function. Invoke it and retry the lock until either the
|
||||
** lock is successfully obtained or the busy-handler returns 0.
|
||||
*/
|
||||
static int walBusyLock(
|
||||
Wal *pWal, /* WAL connection */
|
||||
int (*xBusy)(void*), /* Function to call when busy */
|
||||
void *pBusyArg, /* Context argument for xBusyHandler */
|
||||
int lockIdx, /* Offset of first byte to lock */
|
||||
int n /* Number of bytes to lock */
|
||||
){
|
||||
int rc;
|
||||
do {
|
||||
rc = walLockExclusive(pWal, lockIdx, n);
|
||||
}while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
** The cache of the wal-index header must be valid to call this function.
|
||||
** Return the page-size in bytes used by the database.
|
||||
*/
|
||||
static int walPagesize(Wal *pWal){
|
||||
return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
|
||||
}
|
||||
|
||||
/*
|
||||
** Copy as much content as we can from the WAL back into the database file
|
||||
** in response to an sqlite3_wal_checkpoint() request or the equivalent.
|
||||
@ -1591,9 +1619,12 @@ static int walIteratorInit(Wal *pWal, WalIterator **pp){
|
||||
*/
|
||||
static int walCheckpoint(
|
||||
Wal *pWal, /* Wal connection */
|
||||
int eMode, /* One of PASSIVE, FULL or RESTART */
|
||||
int (*xBusyCall)(void*), /* Function to call when busy */
|
||||
void *pBusyArg, /* Context argument for xBusyHandler */
|
||||
int sync_flags, /* Flags for OsSync() (or 0) */
|
||||
int nBuf, /* Size of zBuf in bytes */
|
||||
u8 *zBuf /* Temporary buffer to use */
|
||||
u8 *zBuf, /* Temporary buffer to use */
|
||||
int *pnCkpt /* Total frames checkpointed */
|
||||
){
|
||||
int rc; /* Return code */
|
||||
int szPage; /* Database page-size */
|
||||
@ -1604,8 +1635,9 @@ static int walCheckpoint(
|
||||
u32 mxPage; /* Max database page to write */
|
||||
int i; /* Loop counter */
|
||||
volatile WalCkptInfo *pInfo; /* The checkpoint status information */
|
||||
int (*xBusy)(void*) = 0; /* Function to call when waiting for locks */
|
||||
|
||||
szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
|
||||
szPage = walPagesize(pWal);
|
||||
testcase( szPage<=32768 );
|
||||
testcase( szPage>=65536 );
|
||||
pInfo = walCkptInfo(pWal);
|
||||
@ -1618,11 +1650,10 @@ static int walCheckpoint(
|
||||
}
|
||||
assert( pIter );
|
||||
|
||||
/*** TODO: Move this test out to the caller. Make it an assert() here ***/
|
||||
if( szPage!=nBuf ){
|
||||
rc = SQLITE_CORRUPT_BKPT;
|
||||
goto walcheckpoint_out;
|
||||
}
|
||||
pInfo = walCkptInfo(pWal);
|
||||
mxPage = pWal->hdr.nPage;
|
||||
if( pnCkpt ) *pnCkpt = pInfo->nBackfill;
|
||||
if( eMode!=SQLITE_CHECKPOINT_PASSIVE ) xBusy = xBusyCall;
|
||||
|
||||
/* Compute in mxSafeFrame the index of the last frame of the WAL that is
|
||||
** safe to write into the database. Frames beyond mxSafeFrame might
|
||||
@ -1633,14 +1664,15 @@ static int walCheckpoint(
|
||||
mxPage = pWal->hdr.nPage;
|
||||
for(i=1; i<WAL_NREADER; i++){
|
||||
u32 y = pInfo->aReadMark[i];
|
||||
if( mxSafeFrame>=y ){
|
||||
if( mxSafeFrame>y ){
|
||||
assert( y<=pWal->hdr.mxFrame );
|
||||
rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
|
||||
rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
|
||||
if( rc==SQLITE_OK ){
|
||||
pInfo->aReadMark[i] = READMARK_NOT_USED;
|
||||
walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
|
||||
}else if( rc==SQLITE_BUSY ){
|
||||
mxSafeFrame = y;
|
||||
xBusy = 0;
|
||||
}else{
|
||||
goto walcheckpoint_out;
|
||||
}
|
||||
@ -1648,7 +1680,7 @@ static int walCheckpoint(
|
||||
}
|
||||
|
||||
if( pInfo->nBackfill<mxSafeFrame
|
||||
&& (rc = walLockExclusive(pWal, WAL_READ_LOCK(0), 1))==SQLITE_OK
|
||||
&& (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLITE_OK
|
||||
){
|
||||
i64 nSize; /* Current size of database file */
|
||||
u32 nBackfill = pInfo->nBackfill;
|
||||
@ -1696,18 +1728,38 @@ static int walCheckpoint(
|
||||
}
|
||||
if( rc==SQLITE_OK ){
|
||||
pInfo->nBackfill = mxSafeFrame;
|
||||
if( pnCkpt ) *pnCkpt = mxSafeFrame;
|
||||
}
|
||||
}
|
||||
|
||||
/* Release the reader lock held while backfilling */
|
||||
walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
|
||||
}else if( rc==SQLITE_BUSY ){
|
||||
}
|
||||
|
||||
if( rc==SQLITE_BUSY ){
|
||||
/* Reset the return code so as not to report a checkpoint failure
|
||||
** just because active readers prevent any backfill.
|
||||
*/
|
||||
** just because there are active readers. */
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
|
||||
/* If this is an SQLITE_CHECKPOINT_RESTART operation, and the entire wal
|
||||
** file has been copied into the database file, then block until all
|
||||
** readers have finished using the wal file. This ensures that the next
|
||||
** process to write to the database restarts the wal file.
|
||||
*/
|
||||
if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
|
||||
assert( pWal->writeLock );
|
||||
if( pInfo->nBackfill<pWal->hdr.mxFrame ){
|
||||
rc = SQLITE_BUSY;
|
||||
}else if( eMode==SQLITE_CHECKPOINT_RESTART ){
|
||||
assert( mxSafeFrame==pWal->hdr.mxFrame );
|
||||
rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
|
||||
if( rc==SQLITE_OK ){
|
||||
walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
walcheckpoint_out:
|
||||
walIteratorFree(pIter);
|
||||
return rc;
|
||||
@ -1739,7 +1791,9 @@ int sqlite3WalClose(
|
||||
if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
|
||||
pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
|
||||
}
|
||||
rc = sqlite3WalCheckpoint(pWal, sync_flags, nBuf, zBuf);
|
||||
rc = sqlite3WalCheckpoint(
|
||||
pWal, SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
|
||||
);
|
||||
if( rc==SQLITE_OK ){
|
||||
isDelete = 1;
|
||||
}
|
||||
@ -2654,17 +2708,27 @@ int sqlite3WalFrames(
|
||||
**
|
||||
** Obtain a CHECKPOINT lock and then backfill as much information as
|
||||
** we can from WAL into the database.
|
||||
**
|
||||
** If parameter xBusy is not NULL, it is a pointer to a busy-handler
|
||||
** callback. In this case this function runs a blocking checkpoint.
|
||||
*/
|
||||
int sqlite3WalCheckpoint(
|
||||
Wal *pWal, /* Wal connection */
|
||||
int eMode, /* PASSIVE, FULL or RESTART */
|
||||
int (*xBusy)(void*), /* Function to call when busy */
|
||||
void *pBusyArg, /* Context argument for xBusyHandler */
|
||||
int sync_flags, /* Flags to sync db file with (or 0) */
|
||||
int nBuf, /* Size of temporary buffer */
|
||||
u8 *zBuf /* Temporary buffer to use */
|
||||
u8 *zBuf, /* Temporary buffer to use */
|
||||
int *pnLog, /* OUT: Number of frames in WAL */
|
||||
int *pnCkpt /* OUT: Number of backfilled frames in WAL */
|
||||
){
|
||||
int rc; /* Return code */
|
||||
int isChanged = 0; /* True if a new wal-index header is loaded */
|
||||
int eMode2 = eMode; /* Mode to pass to walCheckpoint() */
|
||||
|
||||
assert( pWal->ckptLock==0 );
|
||||
assert( pWal->writeLock==0 );
|
||||
|
||||
WALTRACE(("WAL%p: checkpoint begins\n", pWal));
|
||||
rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
|
||||
@ -2676,11 +2740,40 @@ int sqlite3WalCheckpoint(
|
||||
}
|
||||
pWal->ckptLock = 1;
|
||||
|
||||
/* Copy data from the log to the database file. */
|
||||
rc = walIndexReadHdr(pWal, &isChanged);
|
||||
if( rc==SQLITE_OK ){
|
||||
rc = walCheckpoint(pWal, sync_flags, nBuf, zBuf);
|
||||
/* If this is a blocking-checkpoint, then obtain the write-lock as well
|
||||
** to prevent any writers from running while the checkpoint is underway.
|
||||
** This has to be done before the call to walIndexReadHdr() below.
|
||||
**
|
||||
** If the writer lock cannot be obtained, then a passive checkpoint is
|
||||
** run instead. Since the checkpointer is not holding the writer lock,
|
||||
** there is no point in blocking waiting for any readers. Assuming no
|
||||
** other error occurs, this function will return SQLITE_BUSY to the caller.
|
||||
*/
|
||||
if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){
|
||||
rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_WRITE_LOCK, 1);
|
||||
if( rc==SQLITE_OK ){
|
||||
pWal->writeLock = 1;
|
||||
}else if( rc==SQLITE_BUSY ){
|
||||
eMode2 = SQLITE_CHECKPOINT_PASSIVE;
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
}
|
||||
|
||||
/* Read the wal-index header. */
|
||||
if( rc==SQLITE_OK ){
|
||||
rc = walIndexReadHdr(pWal, &isChanged);
|
||||
}
|
||||
|
||||
/* Copy data from the log to the database file. */
|
||||
if( rc==SQLITE_OK && pWal->hdr.mxFrame ){
|
||||
if( walPagesize(pWal)!=nBuf ){
|
||||
rc = SQLITE_CORRUPT_BKPT;
|
||||
}else{
|
||||
if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
|
||||
rc = walCheckpoint(pWal, eMode2, xBusy, pBusyArg, sync_flags,zBuf,pnCkpt);
|
||||
}
|
||||
}
|
||||
|
||||
if( isChanged ){
|
||||
/* If a new wal-index header was loaded before the checkpoint was
|
||||
** performed, then the pager-cache associated with pWal is now
|
||||
@ -2692,10 +2785,11 @@ int sqlite3WalCheckpoint(
|
||||
}
|
||||
|
||||
/* Release the locks. */
|
||||
sqlite3WalEndWriteTransaction(pWal);
|
||||
walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
|
||||
pWal->ckptLock = 0;
|
||||
WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));
|
||||
return rc;
|
||||
return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
|
||||
}
|
||||
|
||||
/* Return the value to pass to a sqlite3_wal_hook callback, the
|
||||
|
||||
35
src/wal.h
35
src/wal.h
@ -20,22 +20,22 @@
|
||||
#include "sqliteInt.h"
|
||||
|
||||
#ifdef SQLITE_OMIT_WAL
|
||||
# define sqlite3WalOpen(x,y,z) 0
|
||||
# define sqlite3WalClose(w,x,y,z) 0
|
||||
# define sqlite3WalBeginReadTransaction(y,z) 0
|
||||
# define sqlite3WalOpen(x,y,z) 0
|
||||
# define sqlite3WalClose(w,x,y,z) 0
|
||||
# define sqlite3WalBeginReadTransaction(y,z) 0
|
||||
# define sqlite3WalEndReadTransaction(z)
|
||||
# define sqlite3WalRead(v,w,x,y,z) 0
|
||||
# define sqlite3WalDbsize(y) 0
|
||||
# define sqlite3WalBeginWriteTransaction(y) 0
|
||||
# define sqlite3WalEndWriteTransaction(x) 0
|
||||
# define sqlite3WalUndo(x,y,z) 0
|
||||
# define sqlite3WalRead(v,w,x,y,z) 0
|
||||
# define sqlite3WalDbsize(y) 0
|
||||
# define sqlite3WalBeginWriteTransaction(y) 0
|
||||
# define sqlite3WalEndWriteTransaction(x) 0
|
||||
# define sqlite3WalUndo(x,y,z) 0
|
||||
# define sqlite3WalSavepoint(y,z)
|
||||
# define sqlite3WalSavepointUndo(y,z) 0
|
||||
# define sqlite3WalFrames(u,v,w,x,y,z) 0
|
||||
# define sqlite3WalCheckpoint(u,v,w,x) 0
|
||||
# define sqlite3WalCallback(z) 0
|
||||
# define sqlite3WalExclusiveMode(y,z) 0
|
||||
# define sqlite3WalHeapMemory(z) 0
|
||||
# define sqlite3WalSavepointUndo(y,z) 0
|
||||
# define sqlite3WalFrames(u,v,w,x,y,z) 0
|
||||
# define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
|
||||
# define sqlite3WalCallback(z) 0
|
||||
# define sqlite3WalExclusiveMode(y,z) 0
|
||||
# define sqlite3WalHeapMemory(z) 0
|
||||
#else
|
||||
|
||||
#define WAL_SAVEPOINT_NDATA 4
|
||||
@ -86,9 +86,14 @@ int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
|
||||
/* Copy pages from the log to the database file */
|
||||
int sqlite3WalCheckpoint(
|
||||
Wal *pWal, /* Write-ahead log connection */
|
||||
int eMode, /* One of PASSIVE, FULL and RESTART */
|
||||
int (*xBusy)(void*), /* Function to call when busy */
|
||||
void *pBusyArg, /* Context argument for xBusyHandler */
|
||||
int sync_flags, /* Flags to sync db file with (or 0) */
|
||||
int nBuf, /* Size of buffer nBuf */
|
||||
u8 *zBuf /* Temporary buffer to use */
|
||||
u8 *zBuf, /* Temporary buffer to use */
|
||||
int *pnLog, /* OUT: Number of frames in WAL */
|
||||
int *pnCkpt /* OUT: Number of backfilled frames in WAL */
|
||||
);
|
||||
|
||||
/* Return the value to pass to a sqlite3_wal_hook callback, the
|
||||
|
||||
@ -835,4 +835,5 @@ do_test attach-10.2 {
|
||||
PRAGMA database_list;
|
||||
}] 9 end
|
||||
} {4 noname {} 5 inmem {}}
|
||||
|
||||
finish_test
|
||||
|
||||
@ -1992,7 +1992,7 @@ do_test pager1-22.1.1 {
|
||||
INSERT INTO ko DEFAULT VALUES;
|
||||
}
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 -1 -1}
|
||||
do_test pager1-22.2.1 {
|
||||
testvfs tv -default 1
|
||||
tv filter xSync
|
||||
|
||||
@ -1394,6 +1394,7 @@ static void dynamic_triggers(int nMs){
|
||||
print_and_free_err(&err);
|
||||
}
|
||||
|
||||
#include "tt3_checkpoint.c"
|
||||
|
||||
int main(int argc, char **argv){
|
||||
struct ThreadTest {
|
||||
@ -1408,8 +1409,11 @@ int main(int argc, char **argv){
|
||||
{ walthread5, "walthread5", 1000 },
|
||||
{ walthread5, "walthread5", 1000 },
|
||||
|
||||
{ cgt_pager_1, "cgt_pager_1", 0 },
|
||||
{ cgt_pager_1, "cgt_pager_1", 0 },
|
||||
{ dynamic_triggers, "dynamic_triggers", 20000 },
|
||||
|
||||
{ checkpoint_starvation_1, "checkpoint_starvation_1", 10000 },
|
||||
{ checkpoint_starvation_2, "checkpoint_starvation_2", 10000 },
|
||||
};
|
||||
|
||||
int i;
|
||||
|
||||
150
test/tt3_checkpoint.c
Normal file
150
test/tt3_checkpoint.c
Normal file
@ -0,0 +1,150 @@
|
||||
/*
|
||||
** 2001 September 15
|
||||
**
|
||||
** The author disclaims copyright to this source code. In place of
|
||||
** a legal notice, here is a blessing:
|
||||
**
|
||||
** May you do good and not evil.
|
||||
** May you find forgiveness for yourself and forgive others.
|
||||
** May you share freely, never taking more than you give.
|
||||
**
|
||||
*************************************************************************
|
||||
** This file is part of the test program "threadtest3". Despite being a C
|
||||
** file it is not compiled separately, but included by threadtest3.c using
|
||||
** the #include directive normally used with header files.
|
||||
**
|
||||
** This file contains the implementation of test cases:
|
||||
**
|
||||
** checkpoint_starvation_1
|
||||
** checkpoint_starvation_2
|
||||
*/
|
||||
|
||||
/*
|
||||
** Both test cases involve 1 writer/checkpointer thread and N reader threads.
|
||||
**
|
||||
** Each reader thread performs a series of read transactions, one after
|
||||
** another. Each read transaction lasts for 100 ms.
|
||||
**
|
||||
** The writer writes transactions as fast as possible. It uses a callback
|
||||
** registered with sqlite3_wal_hook() to try to keep the WAL-size limited to
|
||||
** around 50 pages.
|
||||
**
|
||||
** In test case checkpoint_starvation_1, the auto-checkpoint uses
|
||||
** SQLITE_CHECKPOINT_PASSIVE. In checkpoint_starvation_2, it uses RESTART.
|
||||
** The expectation is that in the first case the WAL file will grow very
|
||||
** large, and in the second will be limited to the 50 pages or thereabouts.
|
||||
** However, the overall transaction throughput will be lower for
|
||||
** checkpoint_starvation_2, as every checkpoint will block for up to 200 ms
|
||||
** waiting for readers to clear.
|
||||
*/
|
||||
|
||||
/* Frame limit used by the WAL hook for these tests. */
|
||||
#define CHECKPOINT_STARVATION_FRAMELIMIT 50
|
||||
|
||||
/* Duration in ms of each read transaction */
|
||||
#define CHECKPOINT_STARVATION_READMS 100
|
||||
|
||||
struct CheckpointStarvationCtx {
|
||||
int eMode;
|
||||
int nMaxFrame;
|
||||
};
|
||||
typedef struct CheckpointStarvationCtx CheckpointStarvationCtx;
|
||||
|
||||
static int checkpoint_starvation_walhook(
|
||||
void *pCtx,
|
||||
sqlite3 *db,
|
||||
const char *zDb,
|
||||
int nFrame
|
||||
){
|
||||
CheckpointStarvationCtx *p = (CheckpointStarvationCtx *)pCtx;
|
||||
if( nFrame>p->nMaxFrame ){
|
||||
p->nMaxFrame = nFrame;
|
||||
}
|
||||
if( nFrame>=CHECKPOINT_STARVATION_FRAMELIMIT ){
|
||||
sqlite3_wal_checkpoint_v2(db, zDb, p->eMode, 0, 0);
|
||||
}
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static char *checkpoint_starvation_reader(int iTid, int iArg){
|
||||
Error err = {0};
|
||||
Sqlite db = {0};
|
||||
|
||||
opendb(&err, &db, "test.db", 0);
|
||||
while( !timetostop(&err) ){
|
||||
i64 iCount1, iCount2;
|
||||
sql_script(&err, &db, "BEGIN");
|
||||
iCount1 = execsql_i64(&err, &db, "SELECT count(x) FROM t1");
|
||||
usleep(CHECKPOINT_STARVATION_READMS*1000);
|
||||
iCount2 = execsql_i64(&err, &db, "SELECT count(x) FROM t1");
|
||||
sql_script(&err, &db, "COMMIT");
|
||||
|
||||
if( iCount1!=iCount2 ){
|
||||
test_error(&err, "Isolation failure - %lld %lld", iCount1, iCount2);
|
||||
}
|
||||
}
|
||||
closedb(&err, &db);
|
||||
|
||||
print_and_free_err(&err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void checkpoint_starvation_main(int nMs, CheckpointStarvationCtx *p){
|
||||
Error err = {0};
|
||||
Sqlite db = {0};
|
||||
Threadset threads = {0};
|
||||
int nInsert = 0;
|
||||
int i;
|
||||
|
||||
opendb(&err, &db, "test.db", 1);
|
||||
sql_script(&err, &db,
|
||||
"PRAGMA page_size = 1024;"
|
||||
"PRAGMA journal_mode = WAL;"
|
||||
"CREATE TABLE t1(x);"
|
||||
);
|
||||
|
||||
setstoptime(&err, nMs);
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
launch_thread(&err, &threads, checkpoint_starvation_reader, 0);
|
||||
usleep(CHECKPOINT_STARVATION_READMS*1000/4);
|
||||
}
|
||||
|
||||
sqlite3_wal_hook(db.db, checkpoint_starvation_walhook, (void *)p);
|
||||
while( !timetostop(&err) ){
|
||||
sql_script(&err, &db, "INSERT INTO t1 VALUES(randomblob(1200))");
|
||||
nInsert++;
|
||||
}
|
||||
|
||||
printf(" Checkpoint mode : %s\n",
|
||||
p->eMode==SQLITE_CHECKPOINT_PASSIVE ? "PASSIVE" : "RESTART"
|
||||
);
|
||||
printf(" Peak WAL : %d frames\n", p->nMaxFrame);
|
||||
printf(" Transaction count: %d transactions\n", nInsert);
|
||||
|
||||
join_all_threads(&err, &threads);
|
||||
closedb(&err, &db);
|
||||
print_and_free_err(&err);
|
||||
}
|
||||
|
||||
static void checkpoint_starvation_1(int nMs){
|
||||
Error err = {0};
|
||||
CheckpointStarvationCtx ctx = { SQLITE_CHECKPOINT_PASSIVE, 0 };
|
||||
checkpoint_starvation_main(nMs, &ctx);
|
||||
if( ctx.nMaxFrame<(CHECKPOINT_STARVATION_FRAMELIMIT*10) ){
|
||||
test_error(&err, "WAL failed to grow - %d frames", ctx.nMaxFrame);
|
||||
}
|
||||
print_and_free_err(&err);
|
||||
}
|
||||
|
||||
static void checkpoint_starvation_2(int nMs){
|
||||
Error err = {0};
|
||||
CheckpointStarvationCtx ctx = { SQLITE_CHECKPOINT_RESTART, 0 };
|
||||
checkpoint_starvation_main(nMs, &ctx);
|
||||
if( ctx.nMaxFrame>CHECKPOINT_STARVATION_FRAMELIMIT+10 ){
|
||||
test_error(&err, "WAL grew too large - %d frames", ctx.nMaxFrame);
|
||||
}
|
||||
print_and_free_err(&err);
|
||||
}
|
||||
|
||||
|
||||
@ -287,8 +287,8 @@ do_test wal-4.6.1 {
|
||||
INSERT INTO t2 VALUES('y', 'z');
|
||||
ROLLBACK TO save;
|
||||
COMMIT;
|
||||
SELECT * FROM t2;
|
||||
}
|
||||
execsql { SELECT * FROM t2 }
|
||||
} {w x}
|
||||
|
||||
|
||||
@ -542,7 +542,7 @@ do_multiclient_test tn {
|
||||
} {1 2 3 4 5 6 7 8 9 10}
|
||||
do_test wal-10.$tn.12 {
|
||||
catchsql { PRAGMA wal_checkpoint }
|
||||
} {0 {}} ;# Reader no longer block checkpoints
|
||||
} {0 {0 13 13}} ;# Reader no longer block checkpoints
|
||||
do_test wal-10.$tn.13 {
|
||||
execsql { INSERT INTO t1 VALUES(11, 12) }
|
||||
sql2 {SELECT * FROM t1}
|
||||
@ -552,7 +552,7 @@ do_multiclient_test tn {
|
||||
#
|
||||
do_test wal-10.$tn.14 {
|
||||
catchsql { PRAGMA wal_checkpoint }
|
||||
} {0 {}}
|
||||
} {0 {0 15 13}}
|
||||
|
||||
# The following series of test cases used to verify another blocking
|
||||
# case in WAL - a case which no longer blocks.
|
||||
@ -562,10 +562,10 @@ do_multiclient_test tn {
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
do_test wal-10.$tn.16 {
|
||||
catchsql { PRAGMA wal_checkpoint }
|
||||
} {0 {}}
|
||||
} {0 {0 15 15}}
|
||||
do_test wal-10.$tn.17 {
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 15 15}
|
||||
do_test wal-10.$tn.18 {
|
||||
sql3 { BEGIN; SELECT * FROM t1 }
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
@ -588,13 +588,13 @@ do_multiclient_test tn {
|
||||
#
|
||||
do_test wal-10.$tn.23 {
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 17 17}
|
||||
do_test wal-10.$tn.24 {
|
||||
sql2 { BEGIN; SELECT * FROM t1; }
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
|
||||
do_test wal-10.$tn.25 {
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 17 17}
|
||||
do_test wal-10.$tn.26 {
|
||||
catchsql { INSERT INTO t1 VALUES(15, 16) }
|
||||
} {0 {}}
|
||||
@ -611,11 +611,11 @@ do_multiclient_test tn {
|
||||
do_test wal-10.$tn.29 {
|
||||
execsql { INSERT INTO t1 VALUES(19, 20) }
|
||||
catchsql { PRAGMA wal_checkpoint }
|
||||
} {0 {}}
|
||||
} {0 {0 6 0}}
|
||||
do_test wal-10.$tn.30 {
|
||||
code3 { sqlite3_finalize $::STMT }
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 6 0}
|
||||
|
||||
# At one point, if a reader failed to upgrade to a writer because it
|
||||
# was reading an old snapshot, the write-locks were not being released.
|
||||
@ -654,7 +654,7 @@ do_multiclient_test tn {
|
||||
} {a b c d}
|
||||
do_test wal-10.$tn.36 {
|
||||
catchsql { PRAGMA wal_checkpoint }
|
||||
} {0 {}}
|
||||
} {0 {0 16 16}}
|
||||
do_test wal-10.$tn.36 {
|
||||
sql3 { INSERT INTO t1 VALUES('e', 'f') }
|
||||
sql2 { SELECT * FROM t1 }
|
||||
@ -662,7 +662,7 @@ do_multiclient_test tn {
|
||||
do_test wal-10.$tn.37 {
|
||||
sql2 COMMIT
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 18 18}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
@ -797,8 +797,8 @@ do_test wal-12.5 {
|
||||
UPDATE t1 SET y = 1 WHERE x = 'A';
|
||||
PRAGMA wal_checkpoint;
|
||||
UPDATE t1 SET y = 0 WHERE x = 'A';
|
||||
SELECT * FROM t2;
|
||||
}
|
||||
execsql { SELECT * FROM t2 }
|
||||
} {B 2}
|
||||
do_test wal-12.6 {
|
||||
file copy -force test.db test2.db
|
||||
@ -845,6 +845,7 @@ do_test wal-13.1.2 {
|
||||
sqlite3 db test.db
|
||||
execsql { SELECT * FROM t2 }
|
||||
} {B 2}
|
||||
breakpoint
|
||||
do_test wal-13.1.3 {
|
||||
db close
|
||||
file exists test.db-wal
|
||||
@ -1029,14 +1030,14 @@ catch { db close }
|
||||
foreach {tn ckpt_cmd ckpt_res ckpt_main ckpt_aux} {
|
||||
1 {sqlite3_wal_checkpoint db} SQLITE_OK 1 1
|
||||
2 {sqlite3_wal_checkpoint db ""} SQLITE_OK 1 1
|
||||
3 {db eval "PRAGMA wal_checkpoint"} {} 1 1
|
||||
3 {db eval "PRAGMA wal_checkpoint"} {0 10 10} 1 1
|
||||
|
||||
4 {sqlite3_wal_checkpoint db main} SQLITE_OK 1 0
|
||||
5 {sqlite3_wal_checkpoint db aux} SQLITE_OK 0 1
|
||||
6 {sqlite3_wal_checkpoint db temp} SQLITE_OK 0 0
|
||||
7 {db eval "PRAGMA main.wal_checkpoint"} {} 1 0
|
||||
8 {db eval "PRAGMA aux.wal_checkpoint"} {} 0 1
|
||||
9 {db eval "PRAGMA temp.wal_checkpoint"} {} 0 0
|
||||
7 {db eval "PRAGMA main.wal_checkpoint"} {0 10 10} 1 0
|
||||
8 {db eval "PRAGMA aux.wal_checkpoint"} {0 16 16} 0 1
|
||||
9 {db eval "PRAGMA temp.wal_checkpoint"} {0 -1 -1} 0 0
|
||||
} {
|
||||
do_test wal-16.$tn.1 {
|
||||
file delete -force test2.db test2.db-wal test2.db-journal
|
||||
@ -1400,10 +1401,8 @@ do_test wal-20.2 {
|
||||
} {0}
|
||||
do_test wal-20.3 {
|
||||
close $::buddy
|
||||
execsql {
|
||||
PRAGMA wal_checkpoint;
|
||||
SELECT count(*) FROM t1;
|
||||
}
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
execsql { SELECT count(*) FROM t1 }
|
||||
} {16384}
|
||||
do_test wal-20.4 {
|
||||
db close
|
||||
@ -1437,8 +1436,8 @@ do_test wal-21.2 {
|
||||
INSERT INTO t1 SELECT randomblob(900), randomblob(900) FROM t1;
|
||||
ROLLBACK TO s;
|
||||
COMMIT;
|
||||
SELECT * FROM t1;
|
||||
}
|
||||
execsql { SELECT * FROM t1 }
|
||||
} {1 2 3 4 5 6 7 8 9 10 11 12}
|
||||
do_test wal-21.3 {
|
||||
execsql { PRAGMA integrity_check }
|
||||
|
||||
@ -348,7 +348,7 @@ do_test wal2-4.1 {
|
||||
INSERT INTO data VALUES('need xShmOpen to see this');
|
||||
PRAGMA wal_checkpoint;
|
||||
}
|
||||
} {wal}
|
||||
} {wal 0 5 5}
|
||||
do_test wal2-4.2 {
|
||||
db close
|
||||
testvfs tvfs -noshm 1
|
||||
@ -714,7 +714,7 @@ do_test wal2-6.5.1 {
|
||||
INSERT INTO t2 VALUES('I', 'II');
|
||||
PRAGMA journal_mode;
|
||||
}
|
||||
} {wal exclusive wal}
|
||||
} {wal exclusive 0 3 3 wal}
|
||||
do_test wal2-6.5.2 {
|
||||
execsql {
|
||||
PRAGMA locking_mode = normal;
|
||||
@ -725,7 +725,7 @@ do_test wal2-6.5.2 {
|
||||
} {normal exclusive I II III IV}
|
||||
do_test wal2-6.5.3 {
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 4 4}
|
||||
db close
|
||||
|
||||
proc lock_control {method filename handle spec} {
|
||||
@ -809,9 +809,9 @@ do_test wal2-8.1.2 {
|
||||
CREATE TABLE t1(x);
|
||||
INSERT INTO t1 VALUES(zeroblob(8188*1020));
|
||||
CREATE TABLE t2(y);
|
||||
PRAGMA wal_checkpoint;
|
||||
}
|
||||
execsql {
|
||||
PRAGMA wal_checkpoint;
|
||||
SELECT rootpage>=8192 FROM sqlite_master WHERE tbl_name = 't2';
|
||||
}
|
||||
} {1}
|
||||
@ -1154,7 +1154,7 @@ if {$::tcl_platform(platform) == "unix"} {
|
||||
}
|
||||
catch { db close }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that "PRAGMA checkpoint_fullsync" appears to be working.
|
||||
|
||||
@ -427,7 +427,7 @@ do_test wal3-6.1.2 {
|
||||
} {o t t f}
|
||||
do_test wal3-6.1.3 {
|
||||
execsql { PRAGMA wal_checkpoint } db2
|
||||
} {}
|
||||
} {0 7 7}
|
||||
|
||||
# At this point the log file has been fully checkpointed. However,
|
||||
# connection [db3] holds a lock that prevents the log from being wrapped.
|
||||
@ -515,7 +515,7 @@ proc lock_callback {method file handle spec} {
|
||||
}
|
||||
do_test wal3-6.2.2 {
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
} {}
|
||||
} {0 7 7}
|
||||
do_test wal3-6.2.3 {
|
||||
set ::R
|
||||
} {h h l b}
|
||||
@ -624,7 +624,7 @@ do_test wal3-8.1 {
|
||||
INSERT INTO b VALUES('Markazi');
|
||||
PRAGMA wal_checkpoint;
|
||||
}
|
||||
} {wal}
|
||||
} {wal 0 9 9}
|
||||
do_test wal3-8.2 {
|
||||
execsql { SELECT * FROM b }
|
||||
} {Tehran Qom Markazi}
|
||||
|
||||
262
test/wal5.test
Normal file
262
test/wal5.test
Normal file
@ -0,0 +1,262 @@
|
||||
# 2010 April 13
|
||||
#
|
||||
# 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 "blocking-checkpoint"
|
||||
# operations.
|
||||
#
|
||||
|
||||
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 wal5
|
||||
|
||||
proc db_page_count {{file test.db}} { expr [file size $file] / 1024 }
|
||||
proc wal_page_count {{file test.db}} { wal_frame_count ${file}-wal 1024 }
|
||||
|
||||
|
||||
do_multiclient_test tn {
|
||||
|
||||
|
||||
set ::nBusyHandler 0
|
||||
set ::busy_handler_script ""
|
||||
proc busyhandler {n} {
|
||||
incr ::nBusyHandler
|
||||
eval $::busy_handler_script
|
||||
return 0
|
||||
}
|
||||
|
||||
proc reopen_all {} {
|
||||
code1 {db close}
|
||||
code2 {db2 close}
|
||||
code3 {db3 close}
|
||||
code1 {sqlite3 db test.db}
|
||||
code2 {sqlite3 db2 test.db}
|
||||
code3 {sqlite3 db3 test.db}
|
||||
sql1 { PRAGMA synchronous = NORMAL }
|
||||
code1 { db busy busyhandler }
|
||||
}
|
||||
|
||||
do_test 1.$tn.1 {
|
||||
reopen_all
|
||||
sql1 {
|
||||
PRAGMA page_size = 1024;
|
||||
PRAGMA auto_vacuum = 0;
|
||||
CREATE TABLE t1(x, y);
|
||||
PRAGMA journal_mode = WAL;
|
||||
INSERT INTO t1 VALUES(1, zeroblob(1200));
|
||||
INSERT INTO t1 VALUES(2, zeroblob(1200));
|
||||
INSERT INTO t1 VALUES(3, zeroblob(1200));
|
||||
}
|
||||
expr [file size test.db] / 1024
|
||||
} {2}
|
||||
|
||||
# Have connection 2 grab a read-lock on the current snapshot.
|
||||
do_test 1.$tn.2 { sql2 { BEGIN; SELECT x FROM t1 } } {1 2 3}
|
||||
|
||||
# Attempt a checkpoint.
|
||||
do_test 1.$tn.3 {
|
||||
sql1 { PRAGMA wal_checkpoint }
|
||||
list [db_page_count] [wal_page_count]
|
||||
} {5 9}
|
||||
|
||||
# Write to the db again. The log cannot wrap because of the lock still
|
||||
# held by connection 2. The busy-handler has not yet been invoked.
|
||||
do_test 1.$tn.4 {
|
||||
sql1 { INSERT INTO t1 VALUES(4, zeroblob(1200)) }
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {5 12 0}
|
||||
|
||||
# Now do a blocking-checkpoint. Set the busy-handler up so that connection
|
||||
# 2 releases its lock on the 6th invocation. The checkpointer should then
|
||||
# proceed to checkpoint the entire log file. Next write should go to the
|
||||
# start of the log file.
|
||||
#
|
||||
set ::busy_handler_script { if {$n==5} { sql2 COMMIT } }
|
||||
do_test 1.$tn.5 {
|
||||
sql1 { PRAGMA wal_checkpoint = RESTART }
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {6 12 6}
|
||||
do_test 1.$tn.6 {
|
||||
set ::nBusyHandler 0
|
||||
sql1 { INSERT INTO t1 VALUES(5, zeroblob(1200)) }
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {6 12 0}
|
||||
|
||||
do_test 1.$tn.7 {
|
||||
reopen_all
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {7 0 0}
|
||||
|
||||
do_test 1.$tn.8 { sql2 { BEGIN ; SELECT x FROM t1 } } {1 2 3 4 5}
|
||||
do_test 1.$tn.9 {
|
||||
sql1 { INSERT INTO t1 VALUES(6, zeroblob(1200)) }
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {7 5 0}
|
||||
do_test 1.$tn.10 { sql3 { BEGIN ; SELECT x FROM t1 } } {1 2 3 4 5 6}
|
||||
|
||||
set ::busy_handler_script {
|
||||
if {$n==5} { sql2 COMMIT }
|
||||
if {$n==6} { set ::db_file_size [db_page_count] }
|
||||
if {$n==7} { sql3 COMMIT }
|
||||
}
|
||||
do_test 1.$tn.11 {
|
||||
sql1 { PRAGMA wal_checkpoint = RESTART }
|
||||
list [db_page_count] [wal_page_count] $::nBusyHandler
|
||||
} {10 5 8}
|
||||
do_test 1.$tn.12 { set ::db_file_size } 10
|
||||
}
|
||||
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# This block of tests explores checkpoint operations on more than one
|
||||
# database file.
|
||||
#
|
||||
proc setup_and_attach_aux {} {
|
||||
sql1 { ATTACH 'test.db2' AS aux }
|
||||
sql2 { ATTACH 'test.db2' AS aux }
|
||||
sql3 { ATTACH 'test.db2' AS aux }
|
||||
sql1 {
|
||||
PRAGMA main.page_size=1024; PRAGMA main.journal_mode=WAL;
|
||||
PRAGMA aux.page_size=1024; PRAGMA aux.journal_mode=WAL;
|
||||
}
|
||||
}
|
||||
|
||||
proc file_page_counts {} {
|
||||
list [db_page_count test.db ] \
|
||||
[wal_page_count test.db ] \
|
||||
[db_page_count test.db2] \
|
||||
[wal_page_count test.db2]
|
||||
}
|
||||
|
||||
# Test that executing "PRAGMA wal_checkpoint" checkpoints all attached
|
||||
# databases, not just the main db.
|
||||
#
|
||||
do_multiclient_test tn {
|
||||
setup_and_attach_aux
|
||||
do_test 2.1.$tn.1 {
|
||||
sql1 {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
CREATE TABLE aux.t2(a, b);
|
||||
INSERT INTO t2 VALUES(1, 2);
|
||||
}
|
||||
} {}
|
||||
do_test 2.2.$tn.2 { file_page_counts } {1 5 1 5}
|
||||
do_test 2.1.$tn.3 { sql1 { PRAGMA wal_checkpoint } } {0 5 5}
|
||||
do_test 2.1.$tn.4 { file_page_counts } {2 5 2 5}
|
||||
}
|
||||
|
||||
do_multiclient_test tn {
|
||||
setup_and_attach_aux
|
||||
do_test 2.2.$tn.1 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
CREATE TABLE aux.t2(a, b);
|
||||
INSERT INTO t2 VALUES(1, 2);
|
||||
INSERT INTO t2 VALUES(3, 4);
|
||||
}
|
||||
} {}
|
||||
do_test 2.2.$tn.2 { file_page_counts } {1 5 1 7}
|
||||
do_test 2.2.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2}
|
||||
do_test 2.2.$tn.4 { sql1 { PRAGMA wal_checkpoint = RESTART } } {1 5 5}
|
||||
do_test 2.2.$tn.5 { file_page_counts } {2 5 2 7}
|
||||
}
|
||||
|
||||
do_multiclient_test tn {
|
||||
setup_and_attach_aux
|
||||
do_test 2.3.$tn.1 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
CREATE TABLE aux.t2(a, b);
|
||||
INSERT INTO t2 VALUES(1, 2);
|
||||
}
|
||||
} {}
|
||||
do_test 2.3.$tn.2 { file_page_counts } {1 5 1 5}
|
||||
do_test 2.3.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2}
|
||||
do_test 2.3.$tn.4 { sql1 { INSERT INTO t1 VALUES(3, 4) } } {}
|
||||
do_test 2.3.$tn.5 { sql1 { INSERT INTO t2 VALUES(3, 4) } } {}
|
||||
do_test 2.3.$tn.6 { file_page_counts } {1 7 1 7}
|
||||
do_test 2.3.$tn.7 { sql1 { PRAGMA wal_checkpoint = FULL } } {1 7 5}
|
||||
do_test 2.3.$tn.8 { file_page_counts } {1 7 2 7}
|
||||
}
|
||||
|
||||
# Check that checkpoints block on the correct locks. And respond correctly
|
||||
# if they cannot obtain those locks. There are three locks that a checkpoint
|
||||
# may block on (in the following order):
|
||||
#
|
||||
# 1. The writer lock: FULL and RESTART checkpoints block until any writer
|
||||
# process releases its lock.
|
||||
#
|
||||
# 2. Readers using part of the log file. FULL and RESTART checkpoints block
|
||||
# until readers using part (but not all) of the log file have finished.
|
||||
#
|
||||
# 3. Readers using any of the log file. After copying data into the
|
||||
# database file, RESTART checkpoints block until readers using any part
|
||||
# of the log file have finished.
|
||||
#
|
||||
# This test case involves running a checkpoint while there exist other
|
||||
# processes holding all three types of locks.
|
||||
#
|
||||
foreach {tn1 checkpoint busy_on ckpt_expected expected} {
|
||||
1 PASSIVE - {0 5 5} -
|
||||
2 TYPO - {0 5 5} -
|
||||
|
||||
3 FULL - {0 7 7} 2
|
||||
4 FULL 1 {1 5 5} 1
|
||||
5 FULL 2 {1 7 5} 2
|
||||
6 FULL 3 {0 7 7} 2
|
||||
|
||||
7 RESTART - {0 7 7} 3
|
||||
8 RESTART 1 {1 5 5} 1
|
||||
9 RESTART 2 {1 7 5} 2
|
||||
10 RESTART 3 {1 7 7} 3
|
||||
|
||||
} {
|
||||
do_multiclient_test tn {
|
||||
setup_and_attach_aux
|
||||
|
||||
proc busyhandler {x} {
|
||||
set ::max_busyhandler $x
|
||||
if {$::busy_on!="-" && $x==$::busy_on} { return 1 }
|
||||
switch -- $x {
|
||||
1 { sql2 "COMMIT ; BEGIN ; SELECT * FROM t1" }
|
||||
2 { sql3 "COMMIT" }
|
||||
3 { sql2 "COMMIT" }
|
||||
}
|
||||
return 0
|
||||
}
|
||||
set ::max_busyhandler -
|
||||
|
||||
do_test 2.4.$tn1.$tn.1 {
|
||||
sql1 {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
}
|
||||
sql2 { BEGIN; INSERT INTO t1 VALUES(3, 4) }
|
||||
sql3 { BEGIN; SELECT * FROM t1 }
|
||||
} {1 2}
|
||||
|
||||
do_test 2.4.$tn1.$tn.2 {
|
||||
code1 { db busy busyhandler }
|
||||
sql1 "PRAGMA wal_checkpoint = $checkpoint"
|
||||
} $ckpt_expected
|
||||
do_test 2.4.$tn1.$tn.3 { set ::max_busyhandler } $expected
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
|
||||
@ -18,7 +18,9 @@ proc wal_file_size {nFrame pgsz} {
|
||||
}
|
||||
|
||||
proc wal_frame_count {zFile pgsz} {
|
||||
if {[file exists $zFile]==0} { return 0 }
|
||||
set f [file size $zFile]
|
||||
if {$f < 32} { return 0 }
|
||||
expr {($f - 32) / ($pgsz+24)}
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user