OpenCoverage

wal.c

Absolute File Name:/home/opencoverage/opencoverage/guest-scripts/sqlite/src/src/wal.c
Source codeSwitch to Preprocessed file
LineSourceCount
1/*-
2** 2010 February 1-
3**-
4** The author disclaims copyright to this source code. In place of-
5** a legal notice, here is a blessing:-
6**-
7** May you do good and not evil.-
8** May you find forgiveness for yourself and forgive others.-
9** May you share freely, never taking more than you give.-
10**-
11*************************************************************************-
12**-
13** This file contains the implementation of a write-ahead log (WAL) used in -
14** "journal_mode=WAL" mode.-
15**-
16** WRITE-AHEAD LOG (WAL) FILE FORMAT-
17**-
18** A WAL file consists of a header followed by zero or more "frames".-
19** Each frame records the revised content of a single page from the-
20** database file. All changes to the database are recorded by writing-
21** frames into the WAL. Transactions commit when a frame is written that-
22** contains a commit marker. A single WAL can and usually does record -
23** multiple transactions. Periodically, the content of the WAL is-
24** transferred back into the database file in an operation called a-
25** "checkpoint".-
26**-
27** A single WAL file can be used multiple times. In other words, the-
28** WAL can fill up with frames and then be checkpointed and then new-
29** frames can overwrite the old ones. A WAL always grows from beginning-
30** toward the end. Checksums and counters attached to each frame are-
31** used to determine which frames within the WAL are valid and which-
32** are leftovers from prior checkpoints.-
33**-
34** The WAL header is 32 bytes in size and consists of the following eight-
35** big-endian 32-bit unsigned integer values:-
36**-
37** 0: Magic number. 0x377f0682 or 0x377f0683-
38** 4: File format version. Currently 3007000-
39** 8: Database page size. Example: 1024-
40** 12: Checkpoint sequence number-
41** 16: Salt-1, random integer incremented with each checkpoint-
42** 20: Salt-2, a different random integer changing with each ckpt-
43** 24: Checksum-1 (first part of checksum for first 24 bytes of header).-
44** 28: Checksum-2 (second part of checksum for first 24 bytes of header).-
45**-
46** Immediately following the wal-header are zero or more frames. Each-
47** frame consists of a 24-byte frame-header followed by a <page-size> bytes-
48** of page data. The frame-header is six big-endian 32-bit unsigned -
49** integer values, as follows:-
50**-
51** 0: Page number.-
52** 4: For commit records, the size of the database image in pages -
53** after the commit. For all other records, zero.-
54** 8: Salt-1 (copied from the header)-
55** 12: Salt-2 (copied from the header)-
56** 16: Checksum-1.-
57** 20: Checksum-2.-
58**-
59** A frame is considered valid if and only if the following conditions are-
60** true:-
61**-
62** (1) The salt-1 and salt-2 values in the frame-header match-
63** salt values in the wal-header-
64**-
65** (2) The checksum values in the final 8 bytes of the frame-header-
66** exactly match the checksum computed consecutively on the-
67** WAL header and the first 8 bytes and the content of all frames-
68** up to and including the current frame.-
69**-
70** The checksum is computed using 32-bit big-endian integers if the-
71** magic number in the first 4 bytes of the WAL is 0x377f0683 and it-
72** is computed using little-endian if the magic number is 0x377f0682.-
73** The checksum values are always stored in the frame header in a-
74** big-endian format regardless of which byte order is used to compute-
75** the checksum. The checksum is computed by interpreting the input as-
76** an even number of unsigned 32-bit integers: x[0] through x[N]. The-
77** algorithm used for the checksum is as follows:-
78** -
79** for i from 0 to n-1 step 2:-
80** s0 += x[i] + s1;-
81** s1 += x[i+1] + s0;-
82** endfor-
83**-
84** Note that s0 and s1 are both weighted checksums using fibonacci weights-
85** in reverse order (the largest fibonacci weight occurs on the first element-
86** of the sequence being summed.) The s1 value spans all 32-bit -
87** terms of the sequence whereas s0 omits the final term.-
88**-
89** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the-
90** WAL is transferred into the database, then the database is VFS.xSync-ed.-
91** The VFS.xSync operations serve as write barriers - all writes launched-
92** before the xSync must complete before any write that launches after the-
93** xSync begins.-
94**-
95** After each checkpoint, the salt-1 value is incremented and the salt-2-
96** value is randomized. This prevents old and new frames in the WAL from-
97** being considered valid at the same time and being checkpointing together-
98** following a crash.-
99**-
100** READER ALGORITHM-
101**-
102** To read a page from the database (call it page number P), a reader-
103** first checks the WAL to see if it contains page P. If so, then the-
104** last valid instance of page P that is a followed by a commit frame-
105** or is a commit frame itself becomes the value read. If the WAL-
106** contains no copies of page P that are valid and which are a commit-
107** frame or are followed by a commit frame, then page P is read from-
108** the database file.-
109**-
110** To start a read transaction, the reader records the index of the last-
111** valid frame in the WAL. The reader uses this recorded "mxFrame" value-
112** for all subsequent read operations. New transactions can be appended-
113** to the WAL, but as long as the reader uses its original mxFrame value-
114** and ignores the newly appended content, it will see a consistent snapshot-
115** of the database from a single point in time. This technique allows-
116** multiple concurrent readers to view different versions of the database-
117** content simultaneously.-
118**-
119** The reader algorithm in the previous paragraphs works correctly, but -
120** because frames for page P can appear anywhere within the WAL, the-
121** reader has to scan the entire WAL looking for page P frames. If the-
122** WAL is large (multiple megabytes is typical) that scan can be slow,-
123** and read performance suffers. To overcome this problem, a separate-
124** data structure called the wal-index is maintained to expedite the-
125** search for frames of a particular page.-
126** -
127** WAL-INDEX FORMAT-
128**-
129** Conceptually, the wal-index is shared memory, though VFS implementations-
130** might choose to implement the wal-index using a mmapped file. Because-
131** the wal-index is shared memory, SQLite does not support journal_mode=WAL -
132** on a network filesystem. All users of the database must be able to-
133** share memory.-
134**-
135** In the default unix and windows implementation, the wal-index is a mmapped-
136** file whose name is the database name with a "-shm" suffix added. For that-
137** reason, the wal-index is sometimes called the "shm" file.-
138**-
139** The wal-index is transient. After a crash, the wal-index can (and should-
140** be) reconstructed from the original WAL file. In fact, the VFS is required-
141** to either truncate or zero the header of the wal-index when the last-
142** connection to it closes. Because the wal-index is transient, it can-
143** use an architecture-specific format; it does not have to be cross-platform.-
144** Hence, unlike the database and WAL file formats which store all values-
145** as big endian, the wal-index can store multi-byte values in the native-
146** byte order of the host computer.-
147**-
148** The purpose of the wal-index is to answer this question quickly: Given-
149** a page number P and a maximum frame index M, return the index of the -
150** last frame in the wal before frame M for page P in the WAL, or return-
151** NULL if there are no frames for page P in the WAL prior to M.-
152**-
153** The wal-index consists of a header region, followed by an one or-
154** more index blocks. -
155**-
156** The wal-index header contains the total number of frames within the WAL-
157** in the mxFrame field.-
158**-
159** Each index block except for the first contains information on -
160** HASHTABLE_NPAGE frames. The first index block contains information on-
161** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and -
162** HASHTABLE_NPAGE are selected so that together the wal-index header and-
163** first index block are the same size as all other index blocks in the-
164** wal-index.-
165**-
166** Each index block contains two sections, a page-mapping that contains the-
167** database page number associated with each wal frame, and a hash-table -
168** that allows readers to query an index block for a specific page number.-
169** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE-
170** for the first index block) 32-bit page numbers. The first entry in the -
171** first index-block contains the database page number corresponding to the-
172** first frame in the WAL file. The first entry in the second index block-
173** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in-
174** the log, and so on.-
175**-
176** The last index block in a wal-index usually contains less than the full-
177** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,-
178** depending on the contents of the WAL file. This does not change the-
179** allocated size of the page-mapping array - the page-mapping array merely-
180** contains unused entries.-
181**-
182** Even without using the hash table, the last frame for page P-
183** can be found by scanning the page-mapping sections of each index block-
184** starting with the last index block and moving toward the first, and-
185** within each index block, starting at the end and moving toward the-
186** beginning. The first entry that equals P corresponds to the frame-
187** holding the content for that page.-
188**-
189** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.-
190** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the-
191** hash table for each page number in the mapping section, so the hash -
192** table is never more than half full. The expected number of collisions -
193** prior to finding a match is 1. Each entry of the hash table is an-
194** 1-based index of an entry in the mapping section of the same-
195** index block. Let K be the 1-based index of the largest entry in-
196** the mapping section. (For index blocks other than the last, K will-
197** always be exactly HASHTABLE_NPAGE (4096) and for the last index block-
198** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table-
199** contain a value of 0.-
200**-
201** To look for page P in the hash table, first compute a hash iKey on-
202** P as follows:-
203**-
204** iKey = (P * 383) % HASHTABLE_NSLOT-
205**-
206** Then start scanning entries of the hash table, starting with iKey-
207** (wrapping around to the beginning when the end of the hash table is-
208** reached) until an unused hash slot is found. Let the first unused slot-
209** be at index iUnused. (iUnused might be less than iKey if there was-
210** wrap-around.) Because the hash table is never more than half full,-
211** the search is guaranteed to eventually hit an unused entry. Let -
212** iMax be the value between iKey and iUnused, closest to iUnused,-
213** where aHash[iMax]==P. If there is no iMax entry (if there exists-
214** no hash slot such that aHash[i]==p) then page P is not in the-
215** current index block. Otherwise the iMax-th mapping entry of the-
216** current index block corresponds to the last entry that references -
217** page P.-
218**-
219** A hash search begins with the last index block and moves toward the-
220** first index block, looking for entries corresponding to page P. On-
221** average, only two or three slots in each index block need to be-
222** examined in order to either find the last entry for page P, or to-
223** establish that no such entry exists in the block. Each index block-
224** holds over 4000 entries. So two or three index blocks are sufficient-
225** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10-
226** comparisons (on average) suffice to either locate a frame in the-
227** WAL or to establish that the frame does not exist in the WAL. This-
228** is much faster than scanning the entire 10MB WAL.-
229**-
230** Note that entries are added in order of increasing K. Hence, one-
231** reader might be using some value K0 and a second reader that started-
232** at a later time (after additional transactions were added to the WAL-
233** and to the wal-index) might be using a different value K1, where K1>K0.-
234** Both readers can use the same hash table and mapping section to get-
235** the correct result. There may be entries in the hash table with-
236** K>K0 but to the first reader, those entries will appear to be unused-
237** slots in the hash table and so the first reader will get an answer as-
238** if no values greater than K0 had ever been inserted into the hash table-
239** in the first place - which is what reader one wants. Meanwhile, the-
240** second reader using K1 will see additional values that were inserted-
241** later, which is exactly what reader two wants. -
242**-
243** When a rollback occurs, the value of K is decreased. Hash table entries-
244** that correspond to frames greater than the new K value are removed-
245** from the hash table at this point.-
246*/-
247#ifndef SQLITE_OMIT_WAL-
248-
249#include "wal.h"-
250-
251/*-
252** Trace output macros-
253*/-
254#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)-
255int sqlite3WalTrace = 0;-
256# define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X-
257#else-
258# define WALTRACE(X)-
259#endif-
260-
261/*-
262** WAL mode depends on atomic aligned 32-bit loads and stores in a few-
263** places. The following macros try to make this explicit.-
264*/-
265#if GCC_VESRION>=5004000-
266# define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED)-
267# define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED)-
268#else-
269# define AtomicLoad(PTR) (*(PTR))-
270# define AtomicStore(PTR,VAL) (*(PTR) = (VAL))-
271#endif-
272-
273/*-
274** The maximum (and only) versions of the wal and wal-index formats-
275** that may be interpreted by this version of SQLite.-
276**-
277** If a client begins recovering a WAL file and finds that (a) the checksum-
278** values in the wal-header are correct and (b) the version field is not-
279** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN.-
280**-
281** Similarly, if a client successfully reads a wal-index header (i.e. the -
282** checksum test is successful) and finds that the version field is not-
283** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite-
284** returns SQLITE_CANTOPEN.-
285*/-
286#define WAL_MAX_VERSION 3007000-
287#define WALINDEX_MAX_VERSION 3007000-
288-
289/*-
290** Index numbers for various locking bytes. WAL_NREADER is the number-
291** of available reader locks and should be at least 3. The default-
292** is SQLITE_SHM_NLOCK==8 and WAL_NREADER==5.-
293**-
294** Technically, the various VFSes are free to implement these locks however-
295** they see fit. However, compatibility is encouraged so that VFSes can-
296** interoperate. The standard implemention used on both unix and windows-
297** is for the index number to indicate a byte offset into the-
298** WalCkptInfo.aLock[] array in the wal-index header. In other words, all-
299** locks are on the shm file. The WALINDEX_LOCK_OFFSET constant (which-
300** should be 120) is the location in the shm file for the first locking-
301** byte.-
302*/-
303#define WAL_WRITE_LOCK 0-
304#define WAL_ALL_BUT_WRITE 1-
305#define WAL_CKPT_LOCK 1-
306#define WAL_RECOVER_LOCK 2-
307#define WAL_READ_LOCK(I) (3+(I))-
308#define WAL_NREADER (SQLITE_SHM_NLOCK-3)-
309-
310-
311/* Object declarations */-
312typedef struct WalIndexHdr WalIndexHdr;-
313typedef struct WalIterator WalIterator;-
314typedef struct WalCkptInfo WalCkptInfo;-
315-
316-
317/*-
318** The following object holds a copy of the wal-index header content.-
319**-
320** The actual header in the wal-index consists of two copies of this-
321** object followed by one instance of the WalCkptInfo object.-
322** For all versions of SQLite through 3.10.0 and probably beyond,-
323** the locking bytes (WalCkptInfo.aLock) start at offset 120 and-
324** the total header size is 136 bytes.-
325**-
326** The szPage value can be any power of 2 between 512 and 32768, inclusive.-
327** Or it can be 1 to represent a 65536-byte page. The latter case was-
328** added in 3.7.1 when support for 64K pages was added. -
329*/-
330struct WalIndexHdr {-
331 u32 iVersion; /* Wal-index version */-
332 u32 unused; /* Unused (padding) field */-
333 u32 iChange; /* Counter incremented each transaction */-
334 u8 isInit; /* 1 when initialized */-
335 u8 bigEndCksum; /* True if checksums in WAL are big-endian */-
336 u16 szPage; /* Database page size in bytes. 1==64K */-
337 u32 mxFrame; /* Index of last valid frame in the WAL */-
338 u32 nPage; /* Size of database in pages */-
339 u32 aFrameCksum[2]; /* Checksum of last frame in log */-
340 u32 aSalt[2]; /* Two salt values copied from WAL header */-
341 u32 aCksum[2]; /* Checksum over all prior fields */-
342};-
343-
344/*-
345** A copy of the following object occurs in the wal-index immediately-
346** following the second copy of the WalIndexHdr. This object stores-
347** information used by checkpoint.-
348**-
349** nBackfill is the number of frames in the WAL that have been written-
350** back into the database. (We call the act of moving content from WAL to-
351** database "backfilling".) The nBackfill number is never greater than-
352** WalIndexHdr.mxFrame. nBackfill can only be increased by threads-
353** holding the WAL_CKPT_LOCK lock (which includes a recovery thread).-
354** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from-
355** mxFrame back to zero when the WAL is reset.-
356**-
357** nBackfillAttempted is the largest value of nBackfill that a checkpoint-
358** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however-
359** the nBackfillAttempted is set before any backfilling is done and the-
360** nBackfill is only set after all backfilling completes. So if a checkpoint-
361** crashes, nBackfillAttempted might be larger than nBackfill. The-
362** WalIndexHdr.mxFrame must never be less than nBackfillAttempted.-
363**-
364** The aLock[] field is a set of bytes used for locking. These bytes should-
365** never be read or written.-
366**-
367** There is one entry in aReadMark[] for each reader lock. If a reader-
368** holds read-lock K, then the value in aReadMark[K] is no greater than-
369** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)-
370** for any aReadMark[] means that entry is unused. aReadMark[0] is -
371** a special case; its value is never used and it exists as a place-holder-
372** to avoid having to offset aReadMark[] indexs by one. Readers holding-
373** WAL_READ_LOCK(0) always ignore the entire WAL and read all content-
374** directly from the database.-
375**-
376** The value of aReadMark[K] may only be changed by a thread that-
377** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of-
378** aReadMark[K] cannot changed while there is a reader is using that mark-
379** since the reader will be holding a shared lock on WAL_READ_LOCK(K).-
380**-
381** The checkpointer may only transfer frames from WAL to database where-
382** the frame numbers are less than or equal to every aReadMark[] that is-
383** in use (that is, every aReadMark[j] for which there is a corresponding-
384** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the-
385** largest value and will increase an unused aReadMark[] to mxFrame if there-
386** is not already an aReadMark[] equal to mxFrame. The exception to the-
387** previous sentence is when nBackfill equals mxFrame (meaning that everything-
388** in the WAL has been backfilled into the database) then new readers-
389** will choose aReadMark[0] which has value 0 and hence such reader will-
390** get all their all content directly from the database file and ignore -
391** the WAL.-
392**-
393** Writers normally append new frames to the end of the WAL. However,-
394** if nBackfill equals mxFrame (meaning that all WAL content has been-
395** written back into the database) and if no readers are using the WAL-
396** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then-
397** the writer will first "reset" the WAL back to the beginning and start-
398** writing new content beginning at frame 1.-
399**-
400** We assume that 32-bit loads are atomic and so no locks are needed in-
401** order to read from any aReadMark[] entries.-
402*/-
403struct WalCkptInfo {-
404 u32 nBackfill; /* Number of WAL frames backfilled into DB */-
405 u32 aReadMark[WAL_NREADER]; /* Reader marks */-
406 u8 aLock[SQLITE_SHM_NLOCK]; /* Reserved space for locks */-
407 u32 nBackfillAttempted; /* WAL frames perhaps written, or maybe not */-
408 u32 notUsed0; /* Available for future enhancements */-
409};-
410#define READMARK_NOT_USED 0xffffffff-
411-
412-
413/* A block of WALINDEX_LOCK_RESERVED bytes beginning at-
414** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems-
415** only support mandatory file-locks, we do not read or write data-
416** from the region of the file on which locks are applied.-
417*/-
418#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock))-
419#define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))-
420-
421/* Size of header before each frame in wal */-
422#define WAL_FRAME_HDRSIZE 24-
423-
424/* Size of write ahead log header, including checksum. */-
425#define WAL_HDRSIZE 32-
426-
427/* WAL magic value. Either this value, or the same value with the least-
428** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit-
429** big-endian format in the first 4 bytes of a WAL file.-
430**-
431** If the LSB is set, then the checksums for each frame within the WAL-
432** file are calculated by treating all data as an array of 32-bit -
433** big-endian words. Otherwise, they are calculated by interpreting -
434** all data as 32-bit little-endian words.-
435*/-
436#define WAL_MAGIC 0x377f0682-
437-
438/*-
439** Return the offset of frame iFrame in the write-ahead log file, -
440** assuming a database page size of szPage bytes. The offset returned-
441** is to the start of the write-ahead log frame-header.-
442*/-
443#define walFrameOffset(iFrame, szPage) ( \-
444 WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \-
445)-
446-
447/*-
448** An open write-ahead log file is represented by an instance of the-
449** following object.-
450*/-
451struct Wal {-
452 sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */-
453 sqlite3_file *pDbFd; /* File handle for the database file */-
454 sqlite3_file *pWalFd; /* File handle for WAL file */-
455 u32 iCallback; /* Value to pass to log callback (or 0) */-
456 i64 mxWalSize; /* Truncate WAL to this size upon reset */-
457 int nWiData; /* Size of array apWiData */-
458 int szFirstBlock; /* Size of first block written to WAL file */-
459 volatile u32 **apWiData; /* Pointer to wal-index content in memory */-
460 u32 szPage; /* Database page size */-
461 i16 readLock; /* Which read lock is being held. -1 for none */-
462 u8 syncFlags; /* Flags to use to sync header writes */-
463 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */-
464 u8 writeLock; /* True if in a write transaction */-
465 u8 ckptLock; /* True if holding a checkpoint lock */-
466 u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */-
467 u8 truncateOnCommit; /* True to truncate WAL file on commit */-
468 u8 syncHeader; /* Fsync the WAL header if true */-
469 u8 padToSectorBoundary; /* Pad transactions out to the next sector */-
470 u8 bShmUnreliable; /* SHM content is read-only and unreliable */-
471 WalIndexHdr hdr; /* Wal-index header for current transaction */-
472 u32 minFrame; /* Ignore wal frames before this one */-
473 u32 iReCksum; /* On commit, recalculate checksums from here */-
474 const char *zWalName; /* Name of WAL file */-
475 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */-
476#ifdef SQLITE_DEBUG-
477 u8 lockError; /* True if a locking error has occurred */-
478#endif-
479#ifdef SQLITE_ENABLE_SNAPSHOT-
480 WalIndexHdr *pSnapshot; /* Start transaction here if not NULL */-
481#endif-
482};-
483-
484/*-
485** Candidate values for Wal.exclusiveMode.-
486*/-
487#define WAL_NORMAL_MODE 0-
488#define WAL_EXCLUSIVE_MODE 1 -
489#define WAL_HEAPMEMORY_MODE 2-
490-
491/*-
492** Possible values for WAL.readOnly-
493*/-
494#define WAL_RDWR 0 /* Normal read/write connection */-
495#define WAL_RDONLY 1 /* The WAL file is readonly */-
496#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */-
497-
498/*-
499** Each page of the wal-index mapping contains a hash-table made up of-
500** an array of HASHTABLE_NSLOT elements of the following type.-
501*/-
502typedef u16 ht_slot;-
503-
504/*-
505** This structure is used to implement an iterator that loops through-
506** all frames in the WAL in database page order. Where two or more frames-
507** correspond to the same database page, the iterator visits only the -
508** frame most recently written to the WAL (in other words, the frame with-
509** the largest index).-
510**-
511** The internals of this structure are only accessed by:-
512**-
513** walIteratorInit() - Create a new iterator,-
514** walIteratorNext() - Step an iterator,-
515** walIteratorFree() - Free an iterator.-
516**-
517** This functionality is used by the checkpoint code (see walCheckpoint()).-
518*/-
519struct WalIterator {-
520 int iPrior; /* Last result returned from the iterator */-
521 int nSegment; /* Number of entries in aSegment[] */-
522 struct WalSegment {-
523 int iNext; /* Next slot in aIndex[] not yet returned */-
524 ht_slot *aIndex; /* i0, i1, i2... such that aPgno[iN] ascend */-
525 u32 *aPgno; /* Array of page numbers. */-
526 int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */-
527 int iZero; /* Frame number associated with aPgno[0] */-
528 } aSegment[1]; /* One for every 32KB page in the wal-index */-
529};-
530-
531/*-
532** Define the parameters of the hash tables in the wal-index file. There-
533** is a hash-table following every HASHTABLE_NPAGE page numbers in the-
534** wal-index.-
535**-
536** Changing any of these constants will alter the wal-index format and-
537** create incompatibilities.-
538*/-
539#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */-
540#define HASHTABLE_HASH_1 383 /* Should be prime */-
541#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */-
542-
543/* -
544** The block of page numbers associated with the first hash-table in a-
545** wal-index is smaller than usual. This is so that there is a complete-
546** hash-table on each aligned 32KB page of the wal-index.-
547*/-
548#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))-
549-
550/* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */-
551#define WALINDEX_PGSZ ( \-
552 sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \-
553)-
554-
555/*-
556** Obtain a pointer to the iPage'th page of the wal-index. The wal-index-
557** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are-
558** numbered from zero.-
559**-
560** If the wal-index is currently smaller the iPage pages then the size-
561** of the wal-index might be increased, but only if it is safe to do-
562** so. It is safe to enlarge the wal-index if pWal->writeLock is true-
563** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE.-
564**-
565** If this call is successful, *ppPage is set to point to the wal-index-
566** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,-
567** then an SQLite error code is returned and *ppPage is set to 0.-
568*/-
569static SQLITE_NOINLINE int walIndexPageRealloc(-
570 Wal *pWal, /* The WAL context */-
571 int iPage, /* The page we seek */-
572 volatile u32 **ppPage /* Write the page pointer here */-
573){-
574 int rc = SQLITE_OK;-
575-
576 /* Enlarge the pWal->apWiData[] array if required */-
577 if( pWal->nWiData<=iPage ){
pWal->nWiData<=iPageDescription
TRUEevaluated 1514 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 920 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (74)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
920-1514
578 int nByte = sizeof(u32*)*(iPage+1);-
579 volatile u32 **apNew;-
580 apNew = (volatile u32 **)sqlite3_realloc64((void *)pWal->apWiData, nByte);-
581 if( !apNew ){
!apNewDescription
TRUEnever evaluated
FALSEevaluated 1514 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
0-1514
582 *ppPage = 0;-
583 return SQLITE_NOMEM_BKPT;
never executed: return 7;
0
584 }-
585 memset((void*)&apNew[pWal->nWiData], 0,-
586 sizeof(u32*)*(iPage+1-pWal->nWiData));-
587 pWal->apWiData = apNew;-
588 pWal->nWiData = iPage+1;-
589 }
executed 1514 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1514
590-
591 /* Request a pointer to the required page from the VFS */-
592 assert( pWal->apWiData[iPage]==0 );-
593 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
pWal->exclusiveMode==2Description
TRUEevaluated 34 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
FALSEevaluated 2400 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
34-2400
594 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);-
595 if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
never executed: rc = 7;
!pWal->apWiData[iPage]Description
TRUEnever evaluated
FALSEevaluated 34 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
0-34
596 }else{
executed 34 times by 2 tests: end of block
Executed by:
  • Self test (104)
  • Self test (438)
34
597 rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, -
598 pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]-
599 );-
600 assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 );-
601 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );-
602 if( (rc&0xff)==SQLITE_READONLY ){
(rc&0xff)==8Description
TRUEevaluated 32 times by 3 tests
Evaluated by:
  • Self test (103)
  • Self test (104)
  • Self test (438)
FALSEevaluated 2368 times by 48 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
32-2368
603 pWal->readOnly |= WAL_SHM_RDONLY;-
604 if( rc==SQLITE_READONLY ){
rc==8Description
TRUEevaluated 10 times by 3 tests
Evaluated by:
  • Self test (103)
  • Self test (104)
  • Self test (438)
FALSEevaluated 22 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
10-22
605 rc = SQLITE_OK;-
606 }
executed 10 times by 3 tests: end of block
Executed by:
  • Self test (103)
  • Self test (104)
  • Self test (438)
10
607 }
executed 32 times by 3 tests: end of block
Executed by:
  • Self test (103)
  • Self test (104)
  • Self test (438)
32
608 }
executed 2400 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
2400
609-
610 *ppPage = pWal->apWiData[iPage];-
611 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );-
612 return rc;
executed 2434 times by 49 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
2434
613}-
614static int walIndexPage(-
615 Wal *pWal, /* The WAL context */-
616 int iPage, /* The page we seek */-
617 volatile u32 **ppPage /* Write the page pointer here */-
618){-
619 if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){
pWal->nWiData<=iPageDescription
TRUEevaluated 1514 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 3607105 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
(*ppPage = pWa...ata[iPage])==0Description
TRUEevaluated 920 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (74)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 3606185 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
920-3607105
620 return walIndexPageRealloc(pWal, iPage, ppPage);
executed 2434 times by 49 tests: return walIndexPageRealloc(pWal, iPage, ppPage);
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
2434
621 }-
622 return SQLITE_OK;
executed 3606185 times by 49 tests: return 0;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
3606185
623}-
624-
625/*-
626** Return a pointer to the WalCkptInfo structure in the wal-index.-
627*/-
628static volatile WalCkptInfo *walCkptInfo(Wal *pWal){-
629 assert( pWal->nWiData>0 && pWal->apWiData[0] );-
630 return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
executed 85059 times by 49 tests: return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
85059
631}-
632-
633/*-
634** Return a pointer to the WalIndexHdr structure in the wal-index.-
635*/-
636static volatile WalIndexHdr *walIndexHdr(Wal *pWal){-
637 assert( pWal->nWiData>0 && pWal->apWiData[0] );-
638 return (volatile WalIndexHdr*)pWal->apWiData[0];
executed 403297 times by 49 tests: return (volatile WalIndexHdr*)pWal->apWiData[0];
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
403297
639}-
640-
641/*-
642** The argument to this macro must be of type u32. On a little-endian-
643** architecture, it returns the u32 value that results from interpreting-
644** the 4 bytes as a big-endian value. On a big-endian architecture, it-
645** returns the value that would be produced by interpreting the 4 bytes-
646** of the input value as a little-endian integer.-
647*/-
648#define BYTESWAP32(x) ( \-
649 (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \-
650 + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \-
651)-
652-
653/*-
654** Generate or extend an 8 byte checksum based on the data in -
655** array aByte[] and the initial values of aIn[0] and aIn[1] (or-
656** initial values of 0 and 0 if aIn==NULL).-
657**-
658** The checksum is written back into aOut[] before returning.-
659**-
660** nByte must be a positive multiple of 8.-
661*/-
662static void walChecksumBytes(-
663 int nativeCksum, /* True for native byte-order, false for non-native */-
664 u8 *a, /* Content to be checksummed */-
665 int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */-
666 const u32 *aIn, /* Initial checksum value input */-
667 u32 *aOut /* OUT: Final checksum value output */-
668){-
669 u32 s1, s2;-
670 u32 *aData = (u32 *)a;-
671 u32 *aEnd = (u32 *)&a[nByte];-
672-
673 if( aIn ){
aInDescription
TRUEevaluated 876618 times by 26 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
FALSEevaluated 130607 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
130607-876618
674 s1 = aIn[0];-
675 s2 = aIn[1];-
676 }else{
executed 876618 times by 26 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
876618
677 s1 = s2 = 0;-
678 }
executed 130607 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
130607
679-
680 assert( nByte>=8 );-
681 assert( (nByte&0x00000007)==0 );-
682-
683 if( nativeCksum ){
nativeCksumDescription
TRUEevaluated 1007183 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 42 times by 1 test
Evaluated by:
  • Self test (438)
42-1007183
684 do {-
685 s1 += *aData++ + s2;-
686 s2 += *aData++ + s1;-
687 }while( aData<aEnd );
executed 57119004 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
aData<aEndDescription
TRUEevaluated 56111821 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 1007183 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1007183-57119004
688 }else{
executed 1007183 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1007183
689 do {-
690 s1 += BYTESWAP32(aData[0]) + s2;-
691 s2 += BYTESWAP32(aData[1]) + s1;-
692 aData += 2;-
693 }while( aData<aEnd );
executed 2586 times by 1 test: end of block
Executed by:
  • Self test (438)
aData<aEndDescription
TRUEevaluated 2544 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 42 times by 1 test
Evaluated by:
  • Self test (438)
42-2586
694 }
executed 42 times by 1 test: end of block
Executed by:
  • Self test (438)
42
695-
696 aOut[0] = s1;-
697 aOut[1] = s2;-
698}
executed 1007225 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1007225
699-
700static void walShmBarrier(Wal *pWal){-
701 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
pWal->exclusiveMode!=2Description
TRUEevaluated 189453 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 146 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
146-189453
702 sqlite3OsShmBarrier(pWal->pDbFd);-
703 }
executed 189453 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
189453
704}
executed 189599 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
189599
705-
706/*-
707** Write the header information in pWal->hdr into the wal-index.-
708**-
709** The checksum on pWal->hdr is updated before it is written.-
710*/-
711static void walIndexWriteHdr(Wal *pWal){-
712 volatile WalIndexHdr *aHdr = walIndexHdr(pWal);-
713 const int nCksum = offsetof(WalIndexHdr, aCksum);-
714-
715 assert( pWal->writeLock );-
716 pWal->hdr.isInit = 1;-
717 pWal->hdr.iVersion = WALINDEX_MAX_VERSION;-
718 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);-
719 memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));-
720 walShmBarrier(pWal);-
721 memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr));-
722}
executed 60765 times by 29 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (86)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • ...
60765
723-
724/*-
725** This function encodes a single frame header and writes it to a buffer-
726** supplied by the caller. A frame-header is made up of a series of -
727** 4-byte big-endian integers, as follows:-
728**-
729** 0: Page number.-
730** 4: For commit records, the size of the database image in pages -
731** after the commit. For all other records, zero.-
732** 8: Salt-1 (copied from the wal-header)-
733** 12: Salt-2 (copied from the wal-header)-
734** 16: Checksum-1.-
735** 20: Checksum-2.-
736*/-
737static void walEncodeFrame(-
738 Wal *pWal, /* The write-ahead log */-
739 u32 iPage, /* Database page number for frame */-
740 u32 nTruncate, /* New db size (or 0 for non-commit frames) */-
741 u8 *aData, /* Pointer to page data */-
742 u8 *aFrame /* OUT: Write encoded frame here */-
743){-
744 int nativeCksum; /* True for native byte-order checksums */-
745 u32 *aCksum = pWal->hdr.aFrameCksum;-
746 assert( WAL_FRAME_HDRSIZE==24 );-
747 sqlite3Put4byte(&aFrame[0], iPage);-
748 sqlite3Put4byte(&aFrame[4], nTruncate);-
749 if( pWal->iReCksum==0 ){
pWal->iReCksum==0Description
TRUEevaluated 194920 times by 26 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
FALSEevaluated 11917 times by 1 test
Evaluated by:
  • Self test (438)
11917-194920
750 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);-
751-
752 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);-
753 walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);-
754 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);-
755-
756 sqlite3Put4byte(&aFrame[16], aCksum[0]);-
757 sqlite3Put4byte(&aFrame[20], aCksum[1]);-
758 }else{
executed 194920 times by 26 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
194920
759 memset(&aFrame[8], 0, 16);-
760 }
executed 11917 times by 1 test: end of block
Executed by:
  • Self test (438)
11917
761}-
762-
763/*-
764** Check to see if the frame with header in aFrame[] and content-
765** in aData[] is valid. If it is a valid frame, fill *piPage and-
766** *pnTruncate and return true. Return if the frame is not valid.-
767*/-
768static int walDecodeFrame(-
769 Wal *pWal, /* The write-ahead log */-
770 u32 *piPage, /* OUT: Database page number for frame */-
771 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */-
772 u8 *aData, /* Pointer to page data (for checksum) */-
773 u8 *aFrame /* Frame data */-
774){-
775 int nativeCksum; /* True for native byte-order checksums */-
776 u32 *aCksum = pWal->hdr.aFrameCksum;-
777 u32 pgno; /* Page number of the frame */-
778 assert( WAL_FRAME_HDRSIZE==24 );-
779-
780 /* A frame is only valid if the salt values in the frame-header-
781 ** match the salt values in the wal-header. -
782 */-
783 if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
memcmp(&pWal->...rame[8], 8)!=0Description
TRUEevaluated 29 times by 2 tests
Evaluated by:
  • Self test (101)
  • Self test (438)
FALSEevaluated 243389 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
29-243389
784 return 0;
executed 29 times by 2 tests: return 0;
Executed by:
  • Self test (101)
  • Self test (438)
29
785 }-
786-
787 /* A frame is only valid if the page number is creater than zero.-
788 */-
789 pgno = sqlite3Get4byte(&aFrame[0]);-
790 if( pgno==0 ){
pgno==0Description
TRUEnever evaluated
FALSEevaluated 243389 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-243389
791 return 0;
never executed: return 0;
0
792 }-
793-
794 /* A frame is only valid if a checksum of the WAL header,-
795 ** all prior frams, the first 16 bytes of this frame-header, -
796 ** and the frame-data matches the checksum in the last 8 -
797 ** bytes of this frame-header.-
798 */-
799 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);-
800 walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);-
801 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);-
802 if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
aCksum[0]!=sql...e(&aFrame[16])Description
TRUEevaluated 59 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
FALSEevaluated 243330 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
59-243330
803 || aCksum[1]!=sqlite3Get4byte(&aFrame[20])
aCksum[1]!=sql...e(&aFrame[20])Description
TRUEnever evaluated
FALSEevaluated 243330 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-243330
804 ){-
805 /* Checksum failed. */-
806 return 0;
executed 59 times by 2 tests: return 0;
Executed by:
  • Self test (104)
  • Self test (438)
59
807 }-
808-
809 /* If we reach this point, the frame is valid. Return the page number-
810 ** and the new database size.-
811 */-
812 *piPage = pgno;-
813 *pnTruncate = sqlite3Get4byte(&aFrame[4]);-
814 return 1;
executed 243330 times by 5 tests: return 1;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
243330
815}-
816-
817-
818#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)-
819/*-
820** Names of locks. This routine is used to provide debugging output and is not-
821** a part of an ordinary build.-
822*/-
823static const char *walLockName(int lockIdx){-
824 if( lockIdx==WAL_WRITE_LOCK ){-
825 return "WRITE-LOCK";-
826 }else if( lockIdx==WAL_CKPT_LOCK ){-
827 return "CKPT-LOCK";-
828 }else if( lockIdx==WAL_RECOVER_LOCK ){-
829 return "RECOVER-LOCK";-
830 }else{-
831 static char zName[15];-
832 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",-
833 lockIdx-WAL_READ_LOCK(0));-
834 return zName;-
835 }-
836}-
837#endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */-
838 -
839-
840/*-
841** Set or release locks on the WAL. Locks are either shared or exclusive.-
842** A lock cannot be moved directly between shared and exclusive - it must go-
843** through the unlocked state first.-
844**-
845** In locking_mode=EXCLUSIVE, all of these routines become no-ops.-
846*/-
847static int walLockShared(Wal *pWal, int lockIdx){-
848 int rc;-
849 if( pWal->exclusiveMode ) return SQLITE_OK;
executed 52 times by 1 test: return 0;
Executed by:
  • Self test (438)
pWal->exclusiveModeDescription
TRUEevaluated 52 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 63102 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
52-63102
850 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,-
851 SQLITE_SHM_LOCK | SQLITE_SHM_SHARED);-
852 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,-
853 walLockName(lockIdx), rc ? "failed" : "ok"));-
854 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )-
855 return rc;
executed 63102 times by 49 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
63102
856}-
857static void walUnlockShared(Wal *pWal, int lockIdx){-
858 if( pWal->exclusiveMode ) return;
executed 54 times by 1 test: return;
Executed by:
  • Self test (438)
pWal->exclusiveModeDescription
TRUEevaluated 54 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 63082 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
54-63082
859 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,-
860 SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED);-
861 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));-
862}
executed 63082 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
63082
863static int walLockExclusive(Wal *pWal, int lockIdx, int n){-
864 int rc;-
865 if( pWal->exclusiveMode ) return SQLITE_OK;
executed 1724 times by 10 tests: return 0;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
pWal->exclusiveModeDescription
TRUEevaluated 1724 times by 10 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
FALSEevaluated 134790 times by 46 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
1724-134790
866 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,-
867 SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE);-
868 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,-
869 walLockName(lockIdx), n, rc ? "failed" : "ok"));-
870 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )-
871 return rc;
executed 134790 times by 46 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
134790
872}-
873static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){-
874 if( pWal->exclusiveMode ) return;
executed 1724 times by 10 tests: return;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
pWal->exclusiveModeDescription
TRUEevaluated 1724 times by 10 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
FALSEevaluated 129675 times by 46 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
1724-129675
875 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,-
876 SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE);-
877 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,-
878 walLockName(lockIdx), n));-
879}
executed 129675 times by 46 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
129675
880-
881/*-
882** Compute a hash on a page number. The resulting hash value must land-
883** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances-
884** the hash to the next value in the event of a collision.-
885*/-
886static int walHash(u32 iPage){-
887 assert( iPage>0 );-
888 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );-
889 return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1);
executed 3536740 times by 48 tests: return (iPage*383) & ((4096*2)-1);
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
3536740
890}-
891static int walNextHash(int iPriorHash){-
892 return (iPriorHash+1)&(HASHTABLE_NSLOT-1);
executed 15557106 times by 45 tests: return (iPriorHash+1)&((4096*2)-1);
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
15557106
893}-
894-
895/*-
896** An instance of the WalHashLoc object is used to describe the location-
897** of a page hash table in the wal-index. This becomes the return value-
898** from walHashGet().-
899*/-
900typedef struct WalHashLoc WalHashLoc;-
901struct WalHashLoc {-
902 volatile ht_slot *aHash; /* Start of the wal-index hash table */-
903 volatile u32 *aPgno; /* aPgno[1] is the page of first frame indexed */-
904 u32 iZero; /* One less than the frame number of first indexed*/-
905};-
906-
907/* -
908** Return pointers to the hash table and page number array stored on-
909** page iHash of the wal-index. The wal-index is broken into 32KB pages-
910** numbered starting from 0.-
911**-
912** Set output variable pLoc->aHash to point to the start of the hash table-
913** in the wal-index file. Set pLoc->iZero to one less than the frame -
914** number of the first frame indexed by this hash table. If a-
915** slot in the hash table is set to N, it refers to frame number -
916** (pLoc->iZero+N) in the log.-
917**-
918** Finally, set pLoc->aPgno so that pLoc->aPgno[1] is the page number of the-
919** first frame indexed by the hash table, frame (pLoc->iZero+1).-
920*/-
921static int walHashGet(-
922 Wal *pWal, /* WAL handle */-
923 int iHash, /* Find the iHash'th table */-
924 WalHashLoc *pLoc /* OUT: Hash table location */-
925){-
926 int rc; /* Return code */-
927-
928 rc = walIndexPage(pWal, iHash, &pLoc->aPgno);-
929 assert( rc==SQLITE_OK || iHash>0 );-
930-
931 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 3541959 times by 48 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEnever evaluated
0-3541959
932 pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE];-
933 if( iHash==0 ){
iHash==0Description
TRUEevaluated 1840038 times by 48 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 1701921 times by 3 tests
Evaluated by:
  • Self test (438)
  • Self test (64)
  • Self test (74)
1701921-1840038
934 pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];-
935 pLoc->iZero = 0;-
936 }else{
executed 1840038 times by 48 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1840038
937 pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;-
938 }
executed 1701921 times by 3 tests: end of block
Executed by:
  • Self test (438)
  • Self test (64)
  • Self test (74)
1701921
939 pLoc->aPgno = &pLoc->aPgno[-1];-
940 }
executed 3541959 times by 48 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
3541959
941 return rc;
executed 3541959 times by 48 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
3541959
942}-
943-
944/*-
945** Return the number of the wal-index page that contains the hash-table-
946** and page-number array that contain entries corresponding to WAL frame-
947** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages -
948** are numbered starting from 0.-
949*/-
950static int walFramePage(u32 iFrame){-
951 int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;-
952 assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)-
953 && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE)-
954 && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE))-
955 && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)-
956 && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE))-
957 );-
958 return iHash;
executed 3715446 times by 48 tests: return iHash;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
3715446
959}-
960-
961/*-
962** Return the page number associated with frame iFrame in this WAL.-
963*/-
964static u32 walFramePgno(Wal *pWal, u32 iFrame){-
965 int iHash = walFramePage(iFrame);-
966 if( iHash==0 ){
iHash==0Description
TRUEevaluated 1971 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 4738 times by 1 test
Evaluated by:
  • Self test (438)
1971-4738
967 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
executed 1971 times by 1 test: return pWal->apWiData[0][(sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))/sizeof(u32) + iFrame - 1];
Executed by:
  • Self test (438)
1971
968 }-
969 return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
executed 4738 times by 1 test: return pWal->apWiData[iHash][(iFrame-1-(4096 - ((sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo))/sizeof(u32))))%4096];
Executed by:
  • Self test (438)
4738
970}-
971-
972/*-
973** Remove entries from the hash table that point to WAL slots greater-
974** than pWal->hdr.mxFrame.-
975**-
976** This function is called whenever pWal->hdr.mxFrame is decreased due-
977** to a rollback or savepoint.-
978**-
979** At most only the hash table containing pWal->hdr.mxFrame needs to be-
980** updated. Any later hash tables will be automatically cleared when-
981** pWal->hdr.mxFrame advances to the point where those hash tables are-
982** actually needed.-
983*/-
984static void walCleanupHash(Wal *pWal){-
985 WalHashLoc sLoc; /* Hash table location */-
986 int iLimit = 0; /* Zero values greater than this */-
987 int nByte; /* Number of bytes to zero in aPgno[] */-
988 int i; /* Used to iterate through aHash[] */-
989-
990 assert( pWal->writeLock );-
991 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );-
992 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );-
993 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );-
994-
995 if( pWal->hdr.mxFrame==0 ) return;
executed 3 times by 1 test: return;
Executed by:
  • Self test (438)
pWal->hdr.mxFrame==0Description
TRUEevaluated 3 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 80 times by 1 test
Evaluated by:
  • Self test (438)
3-80
996-
997 /* Obtain pointers to the hash-table and page-number array containing -
998 ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed-
999 ** that the page said hash-table and array reside on is already mapped.-
1000 */-
1001 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );-
1002 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );-
1003 walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);-
1004-
1005 /* Zero all hash-table entries that correspond to frame numbers greater-
1006 ** than pWal->hdr.mxFrame.-
1007 */-
1008 iLimit = pWal->hdr.mxFrame - sLoc.iZero;-
1009 assert( iLimit>0 );-
1010 for(i=0; i<HASHTABLE_NSLOT; i++){
i<(4096*2)Description
TRUEevaluated 655360 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 80 times by 1 test
Evaluated by:
  • Self test (438)
80-655360
1011 if( sLoc.aHash[i]>iLimit ){
sLoc.aHash[i]>iLimitDescription
TRUEevaluated 7218 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 648142 times by 1 test
Evaluated by:
  • Self test (438)
7218-648142
1012 sLoc.aHash[i] = 0;-
1013 }
executed 7218 times by 1 test: end of block
Executed by:
  • Self test (438)
7218
1014 }
executed 655360 times by 1 test: end of block
Executed by:
  • Self test (438)
655360
1015 -
1016 /* Zero the entries in the aPgno array that correspond to frames with-
1017 ** frame numbers greater than pWal->hdr.mxFrame. -
1018 */-
1019 nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]);-
1020 memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte);-
1021-
1022#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT-
1023 /* Verify that the every entry in the mapping region is still reachable-
1024 ** via the hash table even after the cleanup.-
1025 */-
1026 if( iLimit ){-
1027 int j; /* Loop counter */-
1028 int iKey; /* Hash key */-
1029 for(j=1; j<=iLimit; j++){-
1030 for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){-
1031 if( sLoc.aHash[iKey]==j ) break;-
1032 }-
1033 assert( sLoc.aHash[iKey]==j );-
1034 }-
1035 }-
1036#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */-
1037}
executed 80 times by 1 test: end of block
Executed by:
  • Self test (438)
80
1038-
1039-
1040/*-
1041** Set an entry in the wal-index that will map database page number-
1042** pPage into WAL frame iFrame.-
1043*/-
1044static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){-
1045 int rc; /* Return code */-
1046 WalHashLoc sLoc; /* Wal-index hash table location */-
1047-
1048 rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);-
1049-
1050 /* Assuming the wal-index file was successfully mapped, populate the-
1051 ** page number array and hash table entry.-
1052 */-
1053 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 439729 times by 26 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
FALSEnever evaluated
0-439729
1054 int iKey; /* Hash table key */-
1055 int idx; /* Value to write to hash-table slot */-
1056 int nCollide; /* Number of hash collisions */-
1057-
1058 idx = iFrame - sLoc.iZero;-
1059 assert( idx <= HASHTABLE_NSLOT/2 + 1 );-
1060 -
1061 /* If this is the first entry to be added to this hash-table, zero the-
1062 ** entire hash table and aPgno[] array before proceeding. -
1063 */-
1064 if( idx==1 ){
idx==1Description
TRUEevaluated 5184 times by 20 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (64)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 434545 times by 25 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
5184-434545
1065 int nByte = (int)((u8 *)&sLoc.aHash[HASHTABLE_NSLOT]-
1066 - (u8 *)&sLoc.aPgno[1]);-
1067 memset((void*)&sLoc.aPgno[1], 0, nByte);-
1068 }
executed 5184 times by 20 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (64)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
5184
1069-
1070 /* If the entry in aPgno[] is already set, then the previous writer-
1071 ** must have exited unexpectedly in the middle of a transaction (after-
1072 ** writing one or more dirty pages to the WAL to free up memory). -
1073 ** Remove the remnants of that writers uncommitted transaction from -
1074 ** the hash-table before writing any new entries.-
1075 */-
1076 if( sLoc.aPgno[idx] ){
sLoc.aPgno[idx]Description
TRUEnever evaluated
FALSEevaluated 439729 times by 26 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
0-439729
1077 walCleanupHash(pWal);-
1078 assert( !sLoc.aPgno[idx] );-
1079 }
never executed: end of block
0
1080-
1081 /* Write the aPgno[] array entry and the hash-table slot. */-
1082 nCollide = idx;-
1083 for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){
sLoc.aHash[iKey]Description
TRUEevaluated 6814097 times by 22 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 439728 times by 26 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
439728-6814097
1084 if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
executed 1 time by 1 test: return sqlite3CorruptError(1084);
Executed by:
  • Self test (438)
(nCollide--)==0Description
TRUEevaluated 1 time by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 6814096 times by 22 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
1-6814096
1085 }
executed 6814096 times by 22 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
6814096
1086 sLoc.aPgno[idx] = iPage;-
1087 sLoc.aHash[iKey] = (ht_slot)idx;-
1088-
1089#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT-
1090 /* Verify that the number of entries in the hash table exactly equals-
1091 ** the number of entries in the mapping region.-
1092 */-
1093 {-
1094 int i; /* Loop counter */-
1095 int nEntry = 0; /* Number of entries in the hash table */-
1096 for(i=0; i<HASHTABLE_NSLOT; i++){ if( sLoc.aHash[i] ) nEntry++; }-
1097 assert( nEntry==idx );-
1098 }-
1099-
1100 /* Verify that the every entry in the mapping region is reachable-
1101 ** via the hash table. This turns out to be a really, really expensive-
1102 ** thing to check, so only do this occasionally - not on every-
1103 ** iteration.-
1104 */-
1105 if( (idx&0x3ff)==0 ){-
1106 int i; /* Loop counter */-
1107 for(i=1; i<=idx; i++){-
1108 for(iKey=walHash(sLoc.aPgno[i]);-
1109 sLoc.aHash[iKey];-
1110 iKey=walNextHash(iKey)){-
1111 if( sLoc.aHash[iKey]==i ) break;-
1112 }-
1113 assert( sLoc.aHash[iKey]==i );-
1114 }-
1115 }-
1116#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */-
1117 }
executed 439728 times by 26 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
439728
1118-
1119-
1120 return rc;
executed 439728 times by 26 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (72)
  • Self test (73)
  • Self test (81)
  • Self test (83)
  • Self test (86)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • ...
439728
1121}-
1122-
1123-
1124/*-
1125** Recover the wal-index by reading the write-ahead log file. -
1126**-
1127** This routine first tries to establish an exclusive lock on the-
1128** wal-index to prevent other threads/processes from doing anything-
1129** with the WAL or wal-index while recovery is running. The-
1130** WAL_RECOVER_LOCK is also held so that other threads will know-
1131** that this thread is running recovery. If unable to establish-
1132** the necessary locks, this routine returns SQLITE_BUSY.-
1133*/-
1134static int walIndexRecover(Wal *pWal){-
1135 int rc; /* Return Code */-
1136 i64 nSize; /* Size of log file */-
1137 u32 aFrameCksum[2] = {0, 0};-
1138 int iLock; /* Lock offset to lock for checkpoint */-
1139-
1140 /* Obtain an exclusive lock on all byte in the locking range not already-
1141 ** locked by the caller. The caller is guaranteed to have locked the-
1142 ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.-
1143 ** If successful, the same bytes that are locked here are unlocked before-
1144 ** this function returns.-
1145 */-
1146 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );-
1147 assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );-
1148 assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );-
1149 assert( pWal->writeLock );-
1150 iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;-
1151 rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);-
1152 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 960 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 15 times by 3 tests
Evaluated by:
  • Self test (438)
  • Self test (50)
  • Self test (51)
15-960
1153 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);-
1154 if( rc!=SQLITE_OK ){
rc!=0Description
TRUEnever evaluated
FALSEevaluated 960 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
0-960
1155 walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);-
1156 }
never executed: end of block
0
1157 }
executed 960 times by 21 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
960
1158 if( rc ){
rcDescription
TRUEevaluated 15 times by 3 tests
Evaluated by:
  • Self test (438)
  • Self test (50)
  • Self test (51)
FALSEevaluated 960 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
15-960
1159 return rc;
executed 15 times by 3 tests: return rc;
Executed by:
  • Self test (438)
  • Self test (50)
  • Self test (51)
15
1160 }-
1161-
1162 WALTRACE(("WAL%p: recovery begin...\n", pWal));-
1163-
1164 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));-
1165-
1166 rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);-
1167 if( rc!=SQLITE_OK ){
rc!=0Description
TRUEnever evaluated
FALSEevaluated 960 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
0-960
1168 goto recovery_error;
never executed: goto recovery_error;
0
1169 }-
1170-
1171 if( nSize>WAL_HDRSIZE ){
nSize>32Description
TRUEevaluated 305 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
FALSEevaluated 655 times by 19 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (28)
  • Self test (438)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
305-655
1172 u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */-
1173 u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */-
1174 int szFrame; /* Number of bytes in buffer aFrame[] */-
1175 u8 *aData; /* Pointer to data part of aFrame buffer */-
1176 int iFrame; /* Index of last frame read */-
1177 i64 iOffset; /* Next offset to read from log file */-
1178 int szPage; /* Page size according to the log */-
1179 u32 magic; /* Magic value read from WAL header */-
1180 u32 version; /* Magic value read from WAL header */-
1181 int isValid; /* True if this frame is valid */-
1182-
1183 /* Read in the WAL header. */-
1184 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);-
1185 if( rc!=SQLITE_OK ){
rc!=0Description
TRUEnever evaluated
FALSEevaluated 305 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-305
1186 goto recovery_error;
never executed: goto recovery_error;
0
1187 }-
1188-
1189 /* If the database page size is not a power of two, or is greater than-
1190 ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid -
1191 ** data. Similarly, if the 'magic' value is invalid, ignore the whole-
1192 ** WAL file.-
1193 */-
1194 magic = sqlite3Get4byte(&aBuf[0]);-
1195 szPage = sqlite3Get4byte(&aBuf[8]);-
1196 if( (magic&0xFFFFFFFE)!=WAL_MAGIC
(magic&0xFFFFFFFE)!=0x377f0682Description
TRUEnever evaluated
FALSEevaluated 305 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-305
1197 || szPage&(szPage-1)
szPage&(szPage-1)Description
TRUEevaluated 3 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 302 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
3-302
1198 || szPage>SQLITE_MAX_PAGE_SIZE
szPage>65536Description
TRUEevaluated 3 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 299 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
3-299
1199 || szPage<512
szPage<512Description
TRUEevaluated 6 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 293 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
6-293
1200 ){-
1201 goto finished;
executed 12 times by 1 test: goto finished;
Executed by:
  • Self test (438)
12
1202 }-
1203 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);-
1204 pWal->szPage = szPage;-
1205 pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);-
1206 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);-
1207-
1208 /* Verify that the WAL header checksum is correct */-
1209 walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, -
1210 aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum-
1211 );-
1212 if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
pWal->hdr.aFra...yte(&aBuf[24])Description
TRUEnever evaluated
FALSEevaluated 293 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-293
1213 || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
pWal->hdr.aFra...yte(&aBuf[28])Description
TRUEnever evaluated
FALSEevaluated 293 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-293
1214 ){-
1215 goto finished;
never executed: goto finished;
0
1216 }-
1217-
1218 /* Verify that the version number on the WAL format is one that-
1219 ** are able to understand */-
1220 version = sqlite3Get4byte(&aBuf[4]);-
1221 if( version!=WAL_MAX_VERSION ){
version!=3007000Description
TRUEevaluated 2 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 291 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
2-291
1222 rc = SQLITE_CANTOPEN_BKPT;-
1223 goto finished;
executed 2 times by 1 test: goto finished;
Executed by:
  • Self test (438)
2
1224 }-
1225-
1226 /* Malloc a buffer to read frames into. */-
1227 szFrame = szPage + WAL_FRAME_HDRSIZE;-
1228 aFrame = (u8 *)sqlite3_malloc64(szFrame);-
1229 if( !aFrame ){
!aFrameDescription
TRUEnever evaluated
FALSEevaluated 291 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-291
1230 rc = SQLITE_NOMEM_BKPT;-
1231 goto recovery_error;
never executed: goto recovery_error;
0
1232 }-
1233 aData = &aFrame[WAL_FRAME_HDRSIZE];-
1234-
1235 /* Read all frames from the log file. */-
1236 iFrame = 0;-
1237 for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
(iOffset+szFrame)<=nSizeDescription
TRUEevaluated 243001 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
FALSEevaluated 213 times by 4 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
213-243001
1238 u32 pgno; /* Database page number for frame */-
1239 u32 nTruncate; /* dbsize field from frame header */-
1240-
1241 /* Read and decode the next log frame. */-
1242 iFrame++;-
1243 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);-
1244 if( rc!=SQLITE_OK ) break;
executed 2 times by 1 test: break;
Executed by:
  • Self test (438)
rc!=0Description
TRUEevaluated 2 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 242999 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
2-242999
1245 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);-
1246 if( !isValid ) break;
executed 76 times by 3 tests: break;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (438)
!isValidDescription
TRUEevaluated 76 times by 3 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (438)
FALSEevaluated 242923 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
76-242923
1247 rc = walIndexAppend(pWal, iFrame, pgno);-
1248 if( rc!=SQLITE_OK ) break;
never executed: break;
rc!=0Description
TRUEnever evaluated
FALSEevaluated 242923 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
0-242923
1249-
1250 /* If nTruncate is non-zero, this is a commit record. */-
1251 if( nTruncate ){
nTruncateDescription
TRUEevaluated 2073 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
FALSEevaluated 240850 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
2073-240850
1252 pWal->hdr.mxFrame = iFrame;-
1253 pWal->hdr.nPage = nTruncate;-
1254 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));-
1255 testcase( szPage<=32768 );-
1256 testcase( szPage>=65536 );-
1257 aFrameCksum[0] = pWal->hdr.aFrameCksum[0];-
1258 aFrameCksum[1] = pWal->hdr.aFrameCksum[1];-
1259 }
executed 2073 times by 5 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
2073
1260 }
executed 242923 times by 5 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
242923
1261-
1262 sqlite3_free(aFrame);-
1263 }
executed 291 times by 5 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
291
1264-
1265finished:
code before this statement executed 946 times by 21 tests: finished:
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
946
1266 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 956 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 4 times by 1 test
Evaluated by:
  • Self test (438)
4-956
1267 volatile WalCkptInfo *pInfo;-
1268 int i;-
1269 pWal->hdr.aFrameCksum[0] = aFrameCksum[0];-
1270 pWal->hdr.aFrameCksum[1] = aFrameCksum[1];-
1271 walIndexWriteHdr(pWal);-
1272-
1273 /* Reset the checkpoint-header. This is safe because this thread is -
1274 ** currently holding locks that exclude all other readers, writers and-
1275 ** checkpointers.-
1276 */-
1277 pInfo = walCkptInfo(pWal);-
1278 pInfo->nBackfill = 0;-
1279 pInfo->nBackfillAttempted = pWal->hdr.mxFrame;-
1280 pInfo->aReadMark[0] = 0;-
1281 for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
executed 3824 times by 21 tests: pInfo->aReadMark[i] = 0xffffffff;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
i<(8 -3)Description
TRUEevaluated 3824 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
FALSEevaluated 956 times by 21 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
956-3824
1282 if( pWal->hdr.mxFrame ) pInfo->aReadMark[1] = pWal->hdr.mxFrame;
executed 286 times by 5 tests: pInfo->aReadMark[1] = pWal->hdr.mxFrame;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
pWal->hdr.mxFrameDescription
TRUEevaluated 286 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
FALSEevaluated 670 times by 19 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (28)
  • Self test (438)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
286-670
1283-
1284 /* If more than one frame was recovered from the log file, report an-
1285 ** event via sqlite3_log(). This is to help with identifying performance-
1286 ** problems caused by applications routinely shutting down without-
1287 ** checkpointing the log file.-
1288 */-
1289 if( pWal->hdr.nPage ){
pWal->hdr.nPageDescription
TRUEevaluated 286 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
FALSEevaluated 670 times by 19 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (28)
  • Self test (438)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
286-670
1290 sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,-
1291 "recovered %d frames from WAL file %s",-
1292 pWal->hdr.mxFrame, pWal->zWalName-
1293 );-
1294 }
executed 286 times by 5 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (50)
286
1295 }
executed 956 times by 21 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
956
1296-
1297recovery_error:
code before this statement executed 960 times by 21 tests: recovery_error:
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
960
1298 WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));-
1299 walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);-
1300 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);-
1301 return rc;
executed 960 times by 21 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (438)
  • Self test (50)
  • Self test (79)
  • Self test (81)
  • Self test (83)
  • Self test (85)
  • Self test (90)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
960
1302}-
1303-
1304/*-
1305** Close an open wal-index.-
1306*/-
1307static void walIndexClose(Wal *pWal, int isDelete){-
1308 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){
pWal->exclusiveMode==2Description
TRUEevaluated 14 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 1369 times by 38 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
pWal->bShmUnreliableDescription
TRUEevaluated 11 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
FALSEevaluated 1358 times by 38 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
11-1369
1309 int i;-
1310 for(i=0; i<pWal->nWiData; i++){
i<pWal->nWiDataDescription
TRUEevaluated 25 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
FALSEevaluated 25 times by 2 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
25
1311 sqlite3_free((void *)pWal->apWiData[i]);-
1312 pWal->apWiData[i] = 0;-
1313 }
executed 25 times by 2 tests: end of block
Executed by:
  • Self test (104)
  • Self test (438)
25
1314 }
executed 25 times by 2 tests: end of block
Executed by:
  • Self test (104)
  • Self test (438)
25
1315 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
pWal->exclusiveMode!=2Description
TRUEevaluated 1369 times by 38 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
FALSEevaluated 14 times by 1 test
Evaluated by:
  • Self test (438)
14-1369
1316 sqlite3OsShmUnmap(pWal->pDbFd, isDelete);-
1317 }
executed 1369 times by 38 tests: end of block
Executed by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
1369
1318}
executed 1383 times by 38 tests: end of block
Executed by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
1383
1319-
1320/* -
1321** Open a connection to the WAL file zWalName. The database file must -
1322** already be opened on connection pDbFd. The buffer that zWalName points-
1323** to must remain valid for the lifetime of the returned Wal* handle.-
1324**-
1325** A SHARED lock should be held on the database file when this function-
1326** is called. The purpose of this SHARED lock is to prevent any other-
1327** client from unlinking the WAL or wal-index file. If another process-
1328** were to do this just after this client opened one of these files, the-
1329** system would be badly broken.-
1330**-
1331** If the log file is successfully opened, SQLITE_OK is returned and -
1332** *ppWal is set to point to a new WAL handle. If an error occurs,-
1333** an SQLite error code is returned and *ppWal is left unmodified.-
1334*/-
1335int sqlite3WalOpen(-
1336 sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */-
1337 sqlite3_file *pDbFd, /* The open database file */-
1338 const char *zWalName, /* Name of the WAL file */-
1339 int bNoShm, /* True to run in heap-memory mode */-
1340 i64 mxWalSize, /* Truncate WAL to this size on reset */-
1341 Wal **ppWal /* OUT: Allocated Wal handle */-
1342){-
1343 int rc; /* Return Code */-
1344 Wal *pRet; /* Object to allocate and return */-
1345 int flags; /* Flags passed to OsOpen() */-
1346-
1347 assert( zWalName && zWalName[0] );-
1348 assert( pDbFd );-
1349-
1350 /* In the amalgamation, the os_unix.c and os_win.c source files come before-
1351 ** this source file. Verify that the #defines of the locking byte offsets-
1352 ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.-
1353 ** For that matter, if the lock offset ever changes from its initial design-
1354 ** value of 120, we need to know that so there is an assert() to check it.-
1355 */-
1356 assert( 120==WALINDEX_LOCK_OFFSET );-
1357 assert( 136==WALINDEX_HDR_SIZE );-
1358#ifdef WIN_SHM_BASE-
1359 assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );-
1360#endif-
1361#ifdef UNIX_SHM_BASE-
1362 assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );-
1363#endif-
1364-
1365-
1366 /* Allocate an instance of struct Wal to return. */-
1367 *ppWal = 0;-
1368 pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);-
1369 if( !pRet ){
!pRetDescription
TRUEnever evaluated
FALSEevaluated 1392 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
0-1392
1370 return SQLITE_NOMEM_BKPT;
never executed: return 7;
0
1371 }-
1372-
1373 pRet->pVfs = pVfs;-
1374 pRet->pWalFd = (sqlite3_file *)&pRet[1];-
1375 pRet->pDbFd = pDbFd;-
1376 pRet->readLock = -1;-
1377 pRet->mxWalSize = mxWalSize;-
1378 pRet->zWalName = zWalName;-
1379 pRet->syncHeader = 1;-
1380 pRet->padToSectorBoundary = 1;-
1381 pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
bNoShmDescription
TRUEevaluated 12 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 1380 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
12-1380
1382-
1383 /* Open file handle on the write-ahead log file. */-
1384 flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);-
1385 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);-
1386 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
rc==0Description
TRUEevaluated 1390 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
FALSEevaluated 2 times by 1 test
Evaluated by:
  • Self test (438)
flags&0x00000001Description
TRUEevaluated 1 time by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 1389 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1-1390
1387 pRet->readOnly = WAL_RDONLY;-
1388 }
executed 1 time by 1 test: end of block
Executed by:
  • Self test (438)
1
1389-
1390 if( rc!=SQLITE_OK ){
rc!=0Description
TRUEevaluated 2 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 1390 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
2-1390
1391 walIndexClose(pRet, 0);-
1392 sqlite3OsClose(pRet->pWalFd);-
1393 sqlite3_free(pRet);-
1394 }else{
executed 2 times by 1 test: end of block
Executed by:
  • Self test (438)
2
1395 int iDC = sqlite3OsDeviceCharacteristics(pDbFd);-
1396 if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }
never executed: end of block
iDC & 0x00000400Description
TRUEnever evaluated
FALSEevaluated 1390 times by 49 tests
Evaluated by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
0-1390
1397 if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){
iDC & 0x00001000Description
TRUEevaluated 1360 times by 39 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
FALSEevaluated 30 times by 11 tests
Evaluated by:
  • Self test (100)
  • Self test (438)
  • Self test (91)
  • Self test (92)
  • Self test (93)
  • Self test (94)
  • Self test (95)
  • Self test (96)
  • Self test (97)
  • Self test (98)
  • Self test (99)
30-1360
1398 pRet->padToSectorBoundary = 0;-
1399 }
executed 1360 times by 39 tests: end of block
Executed by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • ...
1360
1400 *ppWal = pRet;-
1401 WALTRACE(("WAL%d: opened\n", pRet));-
1402 }
executed 1390 times by 49 tests: end of block
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1390
1403 return rc;
executed 1392 times by 49 tests: return rc;
Executed by:
  • Self test (100)
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (64)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • ...
1392
1404}-
1405-
1406/*-
1407** Change the size to which the WAL file is trucated on each reset.-
1408*/-
1409void sqlite3WalLimit(Wal *pWal, i64 iLimit){-
1410 if( pWal ) pWal->mxWalSize = iLimit;
never executed: pWal->mxWalSize = iLimit;
pWalDescription
TRUEnever evaluated
FALSEevaluated 10 times by 1 test
Evaluated by:
  • Self test (438)
0-10
1411}
executed 10 times by 1 test: end of block
Executed by:
  • Self test (438)
10
1412-
1413/*-
1414** Find the smallest page number out of all pages held in the WAL that-
1415** has not been returned by any prior invocation of this method on the-
1416** same WalIterator object. Write into *piFrame the frame index where-
1417** that page was last written into the WAL. Write into *piPage the page-
1418** number.-
1419**-
1420** Return 0 on success. If there are no pages in the WAL with a page-
1421** number larger than *piPage, then return 1.-
1422*/-
1423static int walIteratorNext(-
1424 WalIterator *p, /* Iterator */-
1425 u32 *piPage, /* OUT: The page number of the next page */-
1426 u32 *piFrame /* OUT: Wal frame index of next page */-
1427){-
1428 u32 iMin; /* Result pgno must be greater than iMin */-
1429 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */-
1430 int i; /* For looping through segments */-
1431-
1432 iMin = p->iPrior;-
1433 assert( iMin<0xffffffff );-
1434 for(i=p->nSegment-1; i>=0; i--){
i>=0Description
TRUEevaluated 855010 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 361376 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
361376-855010
1435 struct WalSegment *pSegment = &p->aSegment[i];-
1436 while( pSegment->iNext<pSegment->nEntry ){
pSegment->iNex...egment->nEntryDescription
TRUEevaluated 903509 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 308881 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
308881-903509
1437 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];-
1438 if( iPg>iMin ){
iPg>iMinDescription
TRUEevaluated 546129 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 357380 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
357380-546129
1439 if( iPg<iRet ){
iPg<iRetDescription
TRUEevaluated 543553 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 2576 times by 1 test
Evaluated by:
  • Self test (438)
2576-543553
1440 iRet = iPg;-
1441 *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];-
1442 }
executed 543553 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
543553
1443 break;
executed 546129 times by 8 tests: break;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
546129
1444 }-
1445 pSegment->iNext++;-
1446 }
executed 357380 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
357380
1447 }
executed 855010 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
855010
1448-
1449 *piPage = p->iPrior = iRet;-
1450 return (iRet==0xFFFFFFFF);
executed 361376 times by 8 tests: return (iRet==0xFFFFFFFF);
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
361376
1451}-
1452-
1453/*-
1454** This function merges two sorted lists into a single sorted list.-
1455**-
1456** aLeft[] and aRight[] are arrays of indices. The sort key is-
1457** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following-
1458** is guaranteed for all J<K:-
1459**-
1460** aContent[aLeft[J]] < aContent[aLeft[K]]-
1461** aContent[aRight[J]] < aContent[aRight[K]]-
1462**-
1463** This routine overwrites aRight[] with a new (probably longer) sequence-
1464** of indices such that the aRight[] contains every index that appears in-
1465** either aLeft[] or the old aRight[] and such that the second condition-
1466** above is still met.-
1467**-
1468** The aContent[aLeft[X]] values will be unique for all X. And the-
1469** aContent[aRight[X]] values will be unique too. But there might be-
1470** one or more combinations of X and Y such that-
1471**-
1472** aLeft[X]!=aRight[Y] && aContent[aLeft[X]] == aContent[aRight[Y]]-
1473**-
1474** When that happens, omit the aLeft[X] and use the aRight[Y] index.-
1475*/-
1476static void walMerge(-
1477 const u32 *aContent, /* Pages in wal - keys for the sort */-
1478 ht_slot *aLeft, /* IN: Left hand input list */-
1479 int nLeft, /* IN: Elements in array *paLeft */-
1480 ht_slot **paRight, /* IN/OUT: Right hand input list */-
1481 int *pnRight, /* IN/OUT: Elements in *paRight */-
1482 ht_slot *aTmp /* Temporary buffer */-
1483){-
1484 int iLeft = 0; /* Current index in aLeft */-
1485 int iRight = 0; /* Current index in aRight */-
1486 int iOut = 0; /* Current index in output buffer */-
1487 int nRight = *pnRight;-
1488 ht_slot *aRight = *paRight;-
1489-
1490 assert( nLeft>0 && nRight>0 );-
1491 while( iRight<nRight || iLeft<nLeft ){
iRight<nRightDescription
TRUEevaluated 4143709 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 454379 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
iLeft<nLeftDescription
TRUEevaluated 32122 times by 2 tests
Evaluated by:
  • Self test (438)
  • Self test (72)
FALSEevaluated 422257 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
32122-4143709
1492 ht_slot logpage;-
1493 Pgno dbpage;-
1494-
1495 if( (iLeft<nLeft)
(iLeft<nLeft)Description
TRUEevaluated 2307771 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 1868060 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
1868060-2307771
1496 && (iRight>=nRight || aContent[aLeft[iLeft]]<aContent[aRight[iRight]])
iRight>=nRightDescription
TRUEevaluated 32122 times by 2 tests
Evaluated by:
  • Self test (438)
  • Self test (72)
FALSEevaluated 2275649 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
aContent[aLeft...Right[iRight]]Description
TRUEevaluated 2046639 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 229010 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
32122-2275649
1497 ){-
1498 logpage = aLeft[iLeft++];-
1499 }else{
executed 2078761 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
2078761
1500 logpage = aRight[iRight++];-
1501 }
executed 2097070 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
2097070
1502 dbpage = aContent[logpage];-
1503-
1504 aTmp[iOut++] = logpage;-
1505 if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;
executed 69721 times by 5 tests: iLeft++;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
iLeft<nLeftDescription
TRUEevaluated 1924009 times by 6 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
FALSEevaluated 2251822 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
aContent[aLeft[iLeft]]==dbpageDescription
TRUEevaluated 69721 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
FALSEevaluated 1854288 times by 6 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
69721-2251822
1506-
1507 assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );-
1508 assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );-
1509 }
executed 4175831 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
4175831
1510-
1511 *paRight = aLeft;-
1512 *pnRight = iOut;-
1513 memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut);-
1514}
executed 422257 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
422257
1515-
1516/*-
1517** Sort the elements in list aList using aContent[] as the sort key.-
1518** Remove elements with duplicate keys, preferring to keep the-
1519** larger aList[] values.-
1520**-
1521** The aList[] entries are indices into aContent[]. The values in-
1522** aList[] are to be sorted so that for all J<K:-
1523**-
1524** aContent[aList[J]] < aContent[aList[K]]-
1525**-
1526** For any X and Y such that-
1527**-
1528** aContent[aList[X]] == aContent[aList[Y]]-
1529**-
1530** Keep the larger of the two values aList[X] and aList[Y] and discard-
1531** the smaller.-
1532*/-
1533static void walMergesort(-
1534 const u32 *aContent, /* Pages in wal */-
1535 ht_slot *aBuffer, /* Buffer of at least *pnList items to use */-
1536 ht_slot *aList, /* IN/OUT: List to sort */-
1537 int *pnList /* IN/OUT: Number of elements in aList[] */-
1538){-
1539 struct Sublist {-
1540 int nList; /* Number of elements in aList */-
1541 ht_slot *aList; /* Pointer to sub-list content */-
1542 };-
1543-
1544 const int nList = *pnList; /* Size of input list */-
1545 int nMerge = 0; /* Number of elements in list aMerge */-
1546 ht_slot *aMerge = 0; /* List to be merged */-
1547 int iList; /* Index into input list */-
1548 u32 iSub = 0; /* Index into aSub array */-
1549 struct Sublist aSub[13]; /* Array of sub-lists */-
1550-
1551 memset(aSub, 0, sizeof(aSub));-
1552 assert( nList<=HASHTABLE_NPAGE && nList>0 );-
1553 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );-
1554-
1555 for(iList=0; iList<nList; iList++){
iList<nListDescription
TRUEevaluated 427396 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 5139 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139-427396
1556 nMerge = 1;-
1557 aMerge = &aList[iList];-
1558 for(iSub=0; iList & (1<<iSub); iSub++){
iList & (1<<iSub)Description
TRUEevaluated 420456 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 427396 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
420456-427396
1559 struct Sublist *p;-
1560 assert( iSub<ArraySize(aSub) );-
1561 p = &aSub[iSub];-
1562 assert( p->aList && p->nList<=(1<<iSub) );-
1563 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );-
1564 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);-
1565 }
executed 420456 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
420456
1566 aSub[iSub].aList = aMerge;-
1567 aSub[iSub].nList = nMerge;-
1568 }
executed 427396 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
427396
1569-
1570 for(iSub++; iSub<ArraySize(aSub); iSub++){
iSub<((int)(si...eof(aSub[0])))Description
TRUEevaluated 56487 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 5139 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139-56487
1571 if( nList & (1<<iSub) ){
nList & (1<<iSub)Description
TRUEevaluated 1801 times by 6 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
FALSEevaluated 54686 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
1801-54686
1572 struct Sublist *p;-
1573 assert( iSub<ArraySize(aSub) );-
1574 p = &aSub[iSub];-
1575 assert( p->nList<=(1<<iSub) );-
1576 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );-
1577 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);-
1578 }
executed 1801 times by 6 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
1801
1579 }
executed 56487 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
56487
1580 assert( aMerge==aList );-
1581 *pnList = nMerge;-
1582-
1583#ifdef SQLITE_DEBUG-
1584 {-
1585 int i;-
1586 for(i=1; i<*pnList; i++){-
1587 assert( aContent[aList[i]] > aContent[aList[i-1]] );-
1588 }-
1589 }-
1590#endif-
1591}
executed 5139 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139
1592-
1593/* -
1594** Free an iterator allocated by walIteratorInit().-
1595*/-
1596static void walIteratorFree(WalIterator *p){-
1597 sqlite3_free(p);-
1598}
executed 7346 times by 13 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
7346
1599-
1600/*-
1601** Construct a WalInterator object that can be used to loop over all -
1602** pages in the WAL following frame nBackfill in ascending order. Frames-
1603** nBackfill or earlier may be included - excluding them is an optimization-
1604** only. The caller must hold the checkpoint lock.-
1605**-
1606** On success, make *pp point to the newly allocated WalInterator object-
1607** return SQLITE_OK. Otherwise, return an error code. If this routine-
1608** returns an error, the value of *pp is undefined.-
1609**-
1610** The calling routine should invoke walIteratorFree() to destroy the-
1611** WalIterator object when it has finished with it.-
1612*/-
1613static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){-
1614 WalIterator *p; /* Return value */-
1615 int nSegment; /* Number of segments to merge */-
1616 u32 iLast; /* Last frame in log */-
1617 int nByte; /* Number of bytes to allocate */-
1618 int i; /* Iterator variable */-
1619 ht_slot *aTmp; /* Temp space used by merge-sort */-
1620 int rc = SQLITE_OK; /* Return Code */-
1621-
1622 /* This routine only runs while holding the checkpoint lock. And-
1623 ** it only runs if there is actually content in the log (mxFrame>0).-
1624 */-
1625 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );-
1626 iLast = pWal->hdr.mxFrame;-
1627-
1628 /* Allocate space for the WalIterator object. */-
1629 nSegment = walFramePage(iLast) + 1;-
1630 nByte = sizeof(WalIterator) -
1631 + (nSegment-1)*sizeof(struct WalSegment)-
1632 + iLast*sizeof(ht_slot);-
1633 p = (WalIterator *)sqlite3_malloc64(nByte);-
1634 if( !p ){
!pDescription
TRUEnever evaluated
FALSEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-5064
1635 return SQLITE_NOMEM_BKPT;
never executed: return 7;
0
1636 }-
1637 memset(p, 0, nByte);-
1638 p->nSegment = nSegment;-
1639-
1640 /* Allocate temporary space used by the merge-sort routine. This block-
1641 ** of memory will be freed before this function returns.-
1642 */-
1643 aTmp = (ht_slot *)sqlite3_malloc64(-
1644 sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)-
1645 );-
1646 if( !aTmp ){
!aTmpDescription
TRUEnever evaluated
FALSEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-5064
1647 rc = SQLITE_NOMEM_BKPT;-
1648 }
never executed: end of block
0
1649-
1650 for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
rc==0Description
TRUEevaluated 10203 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
i<nSegmentDescription
TRUEevaluated 5139 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-10203
1651 WalHashLoc sLoc;-
1652-
1653 rc = walHashGet(pWal, i, &sLoc);-
1654 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 5139 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
0-5139
1655 int j; /* Counter variable */-
1656 int nEntry; /* Number of entries in this segment */-
1657 ht_slot *aIndex; /* Sorted index for this segment */-
1658-
1659 sLoc.aPgno++;-
1660 if( (i+1)==nSegment ){
(i+1)==nSegmentDescription
TRUEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 75 times by 1 test
Evaluated by:
  • Self test (438)
75-5064
1661 nEntry = (int)(iLast - sLoc.iZero);-
1662 }else{
executed 5064 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5064
1663 nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);-
1664 }
executed 75 times by 1 test: end of block
Executed by:
  • Self test (438)
75
1665 aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];-
1666 sLoc.iZero++;-
1667 -
1668 for(j=0; j<nEntry; j++){
j<nEntryDescription
TRUEevaluated 427396 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 5139 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139-427396
1669 aIndex[j] = (ht_slot)j;-
1670 }
executed 427396 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
427396
1671 walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry);-
1672 p->aSegment[i].iZero = sLoc.iZero;-
1673 p->aSegment[i].nEntry = nEntry;-
1674 p->aSegment[i].aIndex = aIndex;-
1675 p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;-
1676 }
executed 5139 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139
1677 }
executed 5139 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5139
1678 sqlite3_free(aTmp);-
1679-
1680 if( rc!=SQLITE_OK ){
rc!=0Description
TRUEnever evaluated
FALSEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-5064
1681 walIteratorFree(p);-
1682 p = 0;-
1683 }
never executed: end of block
0
1684 *pp = p;-
1685 return rc;
executed 5064 times by 8 tests: return rc;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5064
1686}-
1687-
1688/*-
1689** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and-
1690** n. If the attempt fails and parameter xBusy is not NULL, then it is a-
1691** busy-handler function. Invoke it and retry the lock until either the-
1692** lock is successfully obtained or the busy-handler returns 0.-
1693*/-
1694static int walBusyLock(-
1695 Wal *pWal, /* WAL connection */-
1696 int (*xBusy)(void*), /* Function to call when busy */-
1697 void *pBusyArg, /* Context argument for xBusyHandler */-
1698 int lockIdx, /* Offset of first byte to lock */-
1699 int n /* Number of bytes to lock */-
1700){-
1701 int rc;-
1702 do {-
1703 rc = walLockExclusive(pWal, lockIdx, n);-
1704 }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );
executed 12304 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
xBusyDescription
TRUEevaluated 890 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 11414 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
rc==5Description
TRUEevaluated 504 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 386 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
xBusy(pBusyArg)Description
TRUEevaluated 432 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 72 times by 1 test
Evaluated by:
  • Self test (438)
72-12304
1705 return rc;
executed 11872 times by 8 tests: return rc;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
11872
1706}-
1707-
1708/*-
1709** The cache of the wal-index header must be valid to call this function.-
1710** Return the page-size in bytes used by the database.-
1711*/-
1712static int walPagesize(Wal *pWal){-
1713 return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
executed 14521 times by 13 tests: return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
14521
1714}-
1715-
1716/*-
1717** The following is guaranteed when this function is called:-
1718**-
1719** a) the WRITER lock is held,-
1720** b) the entire log file has been checkpointed, and-
1721** c) any existing readers are reading exclusively from the database-
1722** file - there are no readers that may attempt to read a frame from-
1723** the log file.-
1724**-
1725** This function updates the shared-memory structures so that the next-
1726** client to write to the database (which may be this one) does so by-
1727** writing frames into the start of the log file.-
1728**-
1729** The value of parameter salt1 is used as the aSalt[1] value in the -
1730** new wal-index header. It should be passed a pseudo-random value (i.e. -
1731** one obtained from sqlite3_randomness()).-
1732*/-
1733static void walRestartHdr(Wal *pWal, u32 salt1){-
1734 volatile WalCkptInfo *pInfo = walCkptInfo(pWal);-
1735 int i; /* Loop counter */-
1736 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */-
1737 pWal->nCkpt++;-
1738 pWal->hdr.mxFrame = 0;-
1739 sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0]));-
1740 memcpy(&pWal->hdr.aSalt[1], &salt1, 4);-
1741 walIndexWriteHdr(pWal);-
1742 pInfo->nBackfill = 0;-
1743 pInfo->nBackfillAttempted = 0;-
1744 pInfo->aReadMark[1] = 0;-
1745 for(i=2; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
executed 13023 times by 4 tests: pInfo->aReadMark[i] = 0xffffffff;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
i<(8 -3)Description
TRUEevaluated 13023 times by 4 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 4341 times by 4 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
4341-13023
1746 assert( pInfo->aReadMark[0]==0 );-
1747}
executed 4341 times by 4 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
4341
1748-
1749/*-
1750** Copy as much content as we can from the WAL back into the database file-
1751** in response to an sqlite3_wal_checkpoint() request or the equivalent.-
1752**-
1753** The amount of information copies from WAL to database might be limited-
1754** by active readers. This routine will never overwrite a database page-
1755** that a concurrent reader might be using.-
1756**-
1757** All I/O barrier operations (a.k.a fsyncs) occur in this routine when-
1758** SQLite is in WAL-mode in synchronous=NORMAL. That means that if -
1759** checkpoints are always run by a background thread or background -
1760** process, foreground threads will never block on a lengthy fsync call.-
1761**-
1762** Fsync is called on the WAL before writing content out of the WAL and-
1763** into the database. This ensures that if the new content is persistent-
1764** in the WAL and can be recovered following a power-loss or hard reset.-
1765**-
1766** Fsync is also called on the database file if (and only if) the entire-
1767** WAL content is copied into the database file. This second fsync makes-
1768** it safe to delete the WAL since the new content will persist in the-
1769** database file.-
1770**-
1771** This routine uses and updates the nBackfill field of the wal-index header.-
1772** This is the only routine that will increase the value of nBackfill. -
1773** (A WAL reset or recovery will revert nBackfill to zero, but not increase-
1774** its value.)-
1775**-
1776** The caller must be holding sufficient locks to ensure that no other-
1777** checkpoint is running (in any other thread or process) at the same-
1778** time.-
1779*/-
1780static int walCheckpoint(-
1781 Wal *pWal, /* Wal connection */-
1782 sqlite3 *db, /* Check for interrupts on this handle */-
1783 int eMode, /* One of PASSIVE, FULL or RESTART */-
1784 int (*xBusy)(void*), /* Function to call when busy */-
1785 void *pBusyArg, /* Context argument for xBusyHandler */-
1786 int sync_flags, /* Flags for OsSync() (or 0) */-
1787 u8 *zBuf /* Temporary buffer to use */-
1788){-
1789 int rc = SQLITE_OK; /* Return code */-
1790 int szPage; /* Database page-size */-
1791 WalIterator *pIter = 0; /* Wal iterator context */-
1792 u32 iDbpage = 0; /* Next database page to write */-
1793 u32 iFrame = 0; /* Wal frame containing data for iDbpage */-
1794 u32 mxSafeFrame; /* Max frame that can be backfilled */-
1795 u32 mxPage; /* Max database page to write */-
1796 int i; /* Loop counter */-
1797 volatile WalCkptInfo *pInfo; /* The checkpoint status information */-
1798-
1799 szPage = walPagesize(pWal);-
1800 testcase( szPage<=32768 );-
1801 testcase( szPage>=65536 );-
1802 pInfo = walCkptInfo(pWal);-
1803 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
pInfo->nBackfi...l->hdr.mxFrameDescription
TRUEevaluated 6936 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 410 times by 9 tests
Evaluated by:
  • Self test (104)
  • Self test (438)
  • Self test (73)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
410-6936
1804-
1805 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked-
1806 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */-
1807 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );-
1808-
1809 /* Compute in mxSafeFrame the index of the last frame of the WAL that is-
1810 ** safe to write into the database. Frames beyond mxSafeFrame might-
1811 ** overwrite database pages that are in use by active readers and thus-
1812 ** cannot be backfilled from the WAL.-
1813 */-
1814 mxSafeFrame = pWal->hdr.mxFrame;-
1815 mxPage = pWal->hdr.nPage;-
1816 for(i=1; i<WAL_NREADER; i++){
i<(8 -3)Description
TRUEevaluated 27744 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 6936 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
6936-27744
1817 /* Thread-sanitizer reports that the following is an unsafe read,-
1818 ** as some other thread may be in the process of updating the value-
1819 ** of the aReadMark[] slot. The assumption here is that if that is-
1820 ** happening, the other client may only be increasing the value,-
1821 ** not decreasing it. So assuming either that either the "old" or-
1822 ** "new" version of the value is read, and not some arbitrary value-
1823 ** that would never be written by a real client, things are still -
1824 ** safe. */-
1825 u32 y = pInfo->aReadMark[i];-
1826 if( mxSafeFrame>y ){
mxSafeFrame>yDescription
TRUEevaluated 6553 times by 6 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
FALSEevaluated 21191 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
6553-21191
1827 assert( y<=pWal->hdr.mxFrame );-
1828 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);-
1829 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 4642 times by 6 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
FALSEevaluated 1911 times by 1 test
Evaluated by:
  • Self test (438)
1911-4642
1830 pInfo->aReadMark[i] = (i==1 ? mxSafeFrame : READMARK_NOT_USED);
i==1Description
TRUEevaluated 4607 times by 5 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (75)
FALSEevaluated 35 times by 2 tests
Evaluated by:
  • Self test (438)
  • Self test (72)
35-4607
1831 walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);-
1832 }else if( rc==SQLITE_BUSY ){
executed 4642 times by 6 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
rc==5Description
TRUEevaluated 1911 times by 1 test
Evaluated by:
  • Self test (438)
FALSEnever evaluated
0-4642
1833 mxSafeFrame = y;-
1834 xBusy = 0;-
1835 }else{
executed 1911 times by 1 test: end of block
Executed by:
  • Self test (438)
1911
1836 goto walcheckpoint_out;
never executed: goto walcheckpoint_out;
0
1837 }-
1838 }-
1839 }
executed 27744 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
27744
1840-
1841 /* Allocate the iterator */-
1842 if( pInfo->nBackfill<mxSafeFrame ){
pInfo->nBackfill<mxSafeFrameDescription
TRUEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 1872 times by 1 test
Evaluated by:
  • Self test (438)
1872-5064
1843 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);-
1844 assert( rc==SQLITE_OK || pIter==0 );-
1845 }
executed 5064 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5064
1846-
1847 if( pIter
pIterDescription
TRUEevaluated 5064 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 1872 times by 1 test
Evaluated by:
  • Self test (438)
1872-5064
1848 && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0),1))==SQLITE_OK
(rc = walBusyL...(3+(0)),1))==0Description
TRUEevaluated 5060 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 4 times by 1 test
Evaluated by:
  • Self test (438)
4-5060
1849 ){-
1850 u32 nBackfill = pInfo->nBackfill;-
1851-
1852 pInfo->nBackfillAttempted = mxSafeFrame;-
1853-
1854 /* Sync the WAL to disk */-
1855 rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));-
1856-
1857 /* If the database may grow as a result of this checkpoint, hint-
1858 ** about the eventual size of the db file to the VFS layer.-
1859 */-
1860 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 5060 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
0-5060
1861 i64 nReq = ((i64)mxPage * szPage);-
1862 i64 nSize; /* Current size of database file */-
1863 rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);-
1864 if( rc==SQLITE_OK && nSize<nReq ){
rc==0Description
TRUEevaluated 5060 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
nSize<nReqDescription
TRUEevaluated 603 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 4457 times by 4 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
0-5060
1865 sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq);-
1866 }
executed 603 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
603
1867 }
executed 5060 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5060
1868-
1869-
1870 /* Iterate through the contents of the WAL, copying data to the db file */-
1871 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
rc==0Description
TRUEevaluated 361376 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
0==walIterator...page, &iFrame)Description
TRUEevaluated 356328 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 5048 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-361376
1872 i64 iOffset;-
1873 assert( walFramePgno(pWal, iFrame)==iDbpage );-
1874 if( db->u1.isInterrupted ){
db->u1.isInterruptedDescription
TRUEevaluated 11 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 356317 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
11-356317
1875 rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
db->mallocFailedDescription
TRUEnever evaluated
FALSEevaluated 11 times by 1 test
Evaluated by:
  • Self test (438)
0-11
1876 break;
executed 11 times by 1 test: break;
Executed by:
  • Self test (438)
11
1877 }-
1878 if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ){
iFrame<=nBackfillDescription
TRUEevaluated 63 times by 2 tests
Evaluated by:
  • Self test (438)
  • Self test (72)
FALSEevaluated 356254 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
iFrame>mxSafeFrameDescription
TRUEevaluated 75 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 356179 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
iDbpage>mxPageDescription
TRUEevaluated 403 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 355776 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
63-356254
1879 continue;
executed 541 times by 2 tests: continue;
Executed by:
  • Self test (438)
  • Self test (72)
541
1880 }-
1881 iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;-
1882 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */-
1883 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);-
1884 if( rc!=SQLITE_OK ) break;
never executed: break;
rc!=0Description
TRUEnever evaluated
FALSEevaluated 355776 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
0-355776
1885 iOffset = (iDbpage-1)*(i64)szPage;-
1886 testcase( IS_BIG_INT(iOffset) );-
1887 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);-
1888 if( rc!=SQLITE_OK ) break;
executed 1 time by 1 test: break;
Executed by:
  • Self test (438)
rc!=0Description
TRUEevaluated 1 time by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 355775 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
1-355775
1889 }
executed 355775 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
355775
1890-
1891 /* If work was actually accomplished... */-
1892 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 5048 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 12 times by 1 test
Evaluated by:
  • Self test (438)
12-5048
1893 if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
mxSafeFrame==w...pWal)->mxFrameDescription
TRUEevaluated 5011 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEevaluated 37 times by 1 test
Evaluated by:
  • Self test (438)
37-5011
1894 i64 szDb = pWal->hdr.nPage*(i64)szPage;-
1895 testcase( IS_BIG_INT(szDb) );-
1896 rc = sqlite3OsTruncate(pWal->pDbFd, szDb);-
1897 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 5011 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
0-5011
1898 rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));-
1899 }
executed 5011 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5011
1900 }
executed 5011 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5011
1901 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 5048 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
FALSEnever evaluated
0-5048
1902 pInfo->nBackfill = mxSafeFrame;-
1903 }
executed 5048 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5048
1904 }
executed 5048 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5048
1905-
1906 /* Release the reader lock held while backfilling */-
1907 walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);-
1908 }
executed 5060 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
5060
1909-
1910 if( rc==SQLITE_BUSY ){
rc==5Description
TRUEevaluated 1876 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 5060 times by 8 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
1876-5060
1911 /* Reset the return code so as not to report a checkpoint failure-
1912 ** just because there are active readers. */-
1913 rc = SQLITE_OK;-
1914 }
executed 1876 times by 1 test: end of block
Executed by:
  • Self test (438)
1876
1915 }
executed 6936 times by 8 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (75)
  • Self test (84)
  • Self test (89)
6936
1916-
1917 /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the-
1918 ** entire wal file has been copied into the database file, then block -
1919 ** until all readers have finished using the wal file. This ensures that -
1920 ** the next process to write to the database restarts the wal file.-
1921 */-
1922 if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
rc==0Description
TRUEevaluated 7334 times by 13 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
FALSEevaluated 12 times by 1 test
Evaluated by:
  • Self test (438)
eMode!=0Description
TRUEevaluated 132 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 7202 times by 13 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
12-7334
1923 assert( pWal->writeLock );-
1924 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
pInfo->nBackfi...l->hdr.mxFrameDescription
TRUEevaluated 16 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 116 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
16-116
1925 rc = SQLITE_BUSY;-
1926 }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){
executed 16 times by 1 test: end of block
Executed by:
  • Self test (438)
eMode>=2Description
TRUEevaluated 91 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 25 times by 1 test
Evaluated by:
  • Self test (438)
16-91
1927 u32 salt1;-
1928 sqlite3_randomness(4, &salt1);-
1929 assert( pInfo->nBackfill==pWal->hdr.mxFrame );-
1930 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);-
1931 if( rc==SQLITE_OK ){
rc==0Description
TRUEevaluated 61 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 30 times by 1 test
Evaluated by:
  • Self test (438)
30-61
1932 if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){
eMode==3Description
TRUEevaluated 38 times by 3 tests
Evaluated by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
FALSEevaluated 23 times by 1 test
Evaluated by:
  • Self test (438)
23-38
1933 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as-
1934 ** SQLITE_CHECKPOINT_RESTART with the addition that it also-
1935 ** truncates the log file to zero bytes just prior to a-
1936 ** successful return.-
1937 **-
1938 ** In theory, it might be safe to do this without updating the-
1939 ** wal-index header in shared memory, as all subsequent reader or-
1940 ** writer clients should see that the entire log file has been-
1941 ** checkpointed and behave accordingly. This seems unsafe though,-
1942 ** as it would leave the system in a state where the contents of-
1943 ** the wal-index header do not match the contents of the -
1944 ** file-system. To avoid this, update the wal-index header to-
1945 ** indicate that the log file contains zero valid frames. */-
1946 walRestartHdr(pWal, salt1);-
1947 rc = sqlite3OsTruncate(pWal->pWalFd, 0);-
1948 }
executed 38 times by 3 tests: end of block
Executed by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
38
1949 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);-
1950 }
executed 61 times by 3 tests: end of block
Executed by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
61
1951 }
executed 91 times by 3 tests: end of block
Executed by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
91
1952 }
executed 132 times by 3 tests: end of block
Executed by:
  • Self test (104)
  • Self test (105)
  • Self test (438)
132
1953-
1954 walcheckpoint_out:
code before this statement executed 7346 times by 13 tests: walcheckpoint_out:
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
7346
1955 walIteratorFree(pIter);-
1956 return rc;
executed 7346 times by 13 tests: return rc;
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (72)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (84)
  • Self test (85)
  • Self test (89)
  • Self test (90)
7346
1957}-
1958-
1959/*-
1960** If the WAL file is currently larger than nMax bytes in size, truncate-
1961** it to exactly nMax bytes. If an error occurs while doing so, ignore it.-
1962*/-
1963static void walLimitSize(Wal *pWal, i64 nMax){-
1964 i64 sz;-
1965 int rx;-
1966 sqlite3BeginBenignMalloc();-
1967 rx = sqlite3OsFileSize(pWal->pWalFd, &sz);-
1968 if( rx==SQLITE_OK && (sz > nMax ) ){
rx==0Description
TRUEevaluated 19 times by 1 test
Evaluated by:
  • Self test (438)
FALSEnever evaluated
(sz > nMax )Description
TRUEevaluated 14 times by 1 test
Evaluated by:
  • Self test (438)
FALSEevaluated 5 times by 1 test
Evaluated by:
  • Self test (438)
0-19
1969 rx = sqlite3OsTruncate(pWal->pWalFd, nMax);-
1970 }
executed 14 times by 1 test: end of block
Executed by:
  • Self test (438)
14
1971 sqlite3EndBenignMalloc();-
1972 if( rx ){
rxDescription
TRUEnever evaluated
FALSEevaluated 19 times by 1 test
Evaluated by:
  • Self test (438)
0-19
1973 sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);-
1974 }
never executed: end of block
0
1975}
executed 19 times by 1 test: end of block
Executed by:
  • Self test (438)
19
1976-
1977/*-
1978** Close a connection to a log file.-
1979*/-
1980int sqlite3WalClose(-
1981 Wal *pWal, /* Wal to close */-
1982 sqlite3 *db, /* For interrupt flag */-
1983 int sync_flags, /* Flags to pass to OsSync() (or 0) */-
1984 int nBuf,-
1985 u8 *zBuf /* Buffer of at least nBuf bytes */-
1986){-
1987 int rc = SQLITE_OK;-
1988 if( pWal ){
pWalDescription
TRUEevaluated 1379 times by 38 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
FALSEevaluated 93926 times by 48 tests
Evaluated by:
  • Self test (101)
  • Self test (102)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (24)
  • Self test (25)
  • Self test (26)
  • Self test (27)
  • Self test (30)
  • Self test (31)
  • Self test (32)
  • Self test (33)
  • Self test (34)
  • Self test (35)
  • Self test (36)
  • Self test (37)
  • Self test (38)
  • Self test (39)
  • Self test (40)
  • Self test (41)
  • Self test (42)
  • Self test (43)
  • Self test (438)
  • Self test (44)
  • ...
1379-93926
1989 int isDelete = 0; /* True to unlink wal and wal-index files */-
1990-
1991 /* If an EXCLUSIVE lock can be obtained on the database file (using the-
1992 ** ordinary, rollback-mode locking methods, this guarantees that the-
1993 ** connection associated with this log file is the only connection to-
1994 ** the database. In this case checkpoint the database and unlink both-
1995 ** the wal and wal-index files.-
1996 **-
1997 ** The EXCLUSIVE lock is not released before returning.-
1998 */-
1999 if( zBuf!=0
zBuf!=0Description
TRUEevaluated 1377 times by 38 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (73)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • ...
FALSEevaluated 2 times by 1 test
Evaluated by:
  • Self test (438)
2-1377
2000 && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
0==(rc = sqlit...al->pDbFd, 4))Description
TRUEevaluated 882 times by 10 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
FALSEevaluated 495 times by 35 tests
Evaluated by:
  • Self test (101)
  • Self test (103)
  • Self test (104)
  • Self test (105)
  • Self test (28)
  • Self test (29)
  • Self test (37)
  • Self test (41)
  • Self test (438)
  • Self test (50)
  • Self test (51)
  • Self test (62)
  • Self test (63)
  • Self test (65)
  • Self test (66)
  • Self test (67)
  • Self test (68)
  • Self test (69)
  • Self test (70)
  • Self test (71)
  • Self test (72)
  • Self test (74)
  • Self test (75)
  • Self test (76)
  • Self test (78)
  • ...
495-882
2001 ){-
2002 if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
pWal->exclusiveMode==0Description
TRUEevaluated 868 times by 10 tests
Evaluated by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
FALSEevaluated 14 times by 1 test
Evaluated by:
  • Self test (438)
14-868
2003 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;-
2004 }
executed 868 times by 10 tests: end of block
Executed by:
  • Self test (101)
  • Self test (104)
  • Self test (105)
  • Self test (438)
  • Self test (73)
  • Self test (75)
  • Self test (80)
  • Self test (82)
  • Self test (85)
  • Self test (90)
868
2005 rc = sqlite3WalCheckpoint(pWal, db, -
2006