Enum WalCheckpointPolicy 

#[non_exhaustive]
pub enum WalCheckpointPolicy {
    Default,
    Disabled,
    EveryPages(u32),
}

When SQLite should checkpoint the WAL on its own, for Tuning::wal_autocheckpoint (0.12.14, W5.3, D-157).

Why this is not Option<u32>

The same reason CadencePolicy is not Option<SnapshotCadence>, and the plan for this wave specified Option<u32> here too. In a struct that derives Default, a field whose None means turn the mechanism off is a field that turns the mechanism off for everyone who did not mention it. Absence means “leave it alone” everywhere in Tuning, and disabling the automatic checkpointer — which is not safe without an explicit Database::checkpoint to replace it — has to be asked for by name.

The default does not change. 1,000 pages is SQLite’s default and stays SQLite’s default; F-30 is a control-loop perturbation, not a correctness bug, and changing a default is a behaviour change for every existing caller.

What disabling it actually buys, measured (0.12.14, W5.3, D-157)

F-30 says the automatic checkpointer is an unbudgeted hold inside 0.12.0’s adaptive chunk controller: a checkpoint firing during a chunk transaction is charged to that chunk, and since D-146 made the measured hold the input to next_chunk_size, the controller shrinks in response to work the chunk did not do. Three rounds, 6,000 concepts of 1 KB each through write_concepts, release build:

	longest chunk hold	mean	chunks	over budget	wall
autocheckpoint on (default)	9.3–10.3 ms	2.40–2.44 ms	125–130	24–28	304–321 ms
autocheckpoint off	4.50 ms	2.08–2.20 ms	142–153	18–27	298–339 ms

The tail is the finding, and it is real and reproducible. The longest hold roughly halves, and the >10 ms histogram bucket is populated only with the checkpointer on — that bucket is the checkpoint, landing inside somebody else’s transaction and being charged to it. Every round agrees.

What it does not buy is a calmer controller. over_budget overlaps between the arms, and total wall time is the same within noise. The controller works near the budget boundary either way, because D-090’s ~0.8 ms per-transaction floor and the convergence cost do not go anywhere. So the honest statement is that disabling autocheckpoint removes an outlier, not an oscillation.

And the cost is deferred, not removed. The explicit Database::checkpoint at the end of the same fixture moved 8,400–9,100 frames in 41–45 ms with the checkpointer off, against ~860 frames in 5.5–6.2 ms with it on. That is the whole trade in one line: the same work, moved out of the latency-bounded path and into one hold the caller chose the moment for. It is a good trade for a bulk importer and a bad one for an interactive process, which is why this is a knob and not a new default.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Default

SQLite’s own default: checkpoint once the WAL passes 1,000 pages.

Disabled

No automatic checkpointing.

Only correct if you call Database::checkpoint yourself. Without one, the WAL grows for the life of the process and the database file is never brought up to date.

EveryPages(u32)

Checkpoint once the WAL passes this many pages.

0 is not special-cased to Self::Disabled even though SQLite treats it that way, because a caller who computed a threshold and got zero has a bug, and inheriting SQLite’s overload would turn it into a silently unbounded WAL.

Trait Implementations

impl Clone for WalCheckpointPolicy

fn clone(&self) -> WalCheckpointPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for WalCheckpointPolicy

impl Debug for WalCheckpointPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for WalCheckpointPolicy

fn default() -> WalCheckpointPolicy

Returns the “default value” for a type.

impl Eq for WalCheckpointPolicy

impl PartialEq for WalCheckpointPolicy

fn eq(&self, other: &WalCheckpointPolicy) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for WalCheckpointPolicy