mvcc
This skill documents Turso's experimental Multi-Version Concurrency Control system, which allows readers and writers to operate simultaneously without blocking through row-level snapshot isolation. It covers enabling MVCC via pragma, the versioning model tracking begin/end timestamps, and the architecture built on lock-free data structures. The guide also details checkpointing behavior, current limitations like garbage collection and recovery gaps, and testing patterns for MVCC-enabled code.
MVCC enables concurrent reads and writes without blocking by maintaining multiple row versions with snapshot isolation.
AI-generated summary based on this skill's SKILL.md
Install
tursodatabase/turso/mvcc · repository language: Rust
git clone https://github.com/tursodatabase/turso
cp -r turso/.claude/skills/mvcc ~/.claude/skills/mvccFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How to enable MVCC in SQLite?
MVCC (Multi-Version Concurrency Control) is enabled in SQLite through pragma configuration. Set `PRAGMA journal_mode = mvcc` to activate the experimental feature. Once enabled, MVCC allows concurrent readers and writers to operate without blocking each other by maintaining row-level snapshot isolation. The skill documents the exact pragma syntax and configuration steps needed to activate MVCC in your database.
How does MVCC work in databases?
MVCC enables concurrent reads and writes without blocking by maintaining multiple versions of rows with begin/end timestamps. When a transaction starts, it receives a snapshot of the database at that moment. Readers see their snapshot version while writers create new versions, and both operate simultaneously without locks. MVCC uses lock-free data structures to track these versions efficiently, allowing high concurrency while maintaining isolation guarantees.
What is MVCC snapshot isolation and how does it compare to WAL?
MVCC snapshot isolation provides each transaction with a consistent view of the database at a specific point in time, preventing dirty reads and phantom reads. Unlike WAL (Write-Ahead Logging), which serializes writes, MVCC allows true concurrent writes through versioning. The skill compares both concurrency models, explaining that MVCC offers better parallelism for mixed read-write workloads, while WAL remains simpler for write-heavy scenarios.
What are MVCC limitations and known issues before production use?
MVCC has several documented limitations: garbage collection for old versions is incomplete, recovery from logical logs has gaps, and checkpointing can block transactions under certain conditions. Memory usage concerns arise from maintaining multiple row versions. The skill identifies these production readiness gaps, helping teams assess whether MVCC suits their workload or if they should wait for maturation of the experimental feature.
How do you configure MVCC checkpoint threshold and memory usage?
MVCC checkpoint behavior is controlled through pragma settings that determine when old versions are cleaned up. The skill documents configuration options for checkpoint thresholds, though garbage collection remains incomplete in the current implementation. Understanding these settings helps balance memory usage against concurrency benefits, though the skill notes that memory concerns persist as a known limitation requiring careful monitoring in deployments.
How can you test MVCC-specific functionality in database code?
MVCC testing patterns are documented using Turso macros and test frameworks that verify concurrent read-write scenarios. The skill provides testing approaches to validate snapshot isolation behavior, confirm that readers and writers don't block each other, and detect edge cases in version management. These patterns help developers verify MVCC correctness before deploying to production environments.
SKILL.md
rendered from the published skill — quoted content, verbatim
MVCC Guide (Experimental)
Multi-Version Concurrency Control. Work in progress, not production-ready.
CRITICAL: Ignore MVCC when debugging unless the bug is MVCC-specific.
Enabling MVCC
PRAGMA journal_mode = 'mvcc';
Runtime configuration, not a compile-time feature flag. Per-database setting.
How It Works
Standard WAL: single version per page, readers see snapshot at read mark time.
MVCC: multiple row versions, snapshot isolation. Each transaction sees consistent snapshot at begin time.
Key Differences from WAL
| Aspect | WAL | MVCC |
|---|---|---|
| Write granularity | Every commit writes full pages | Affected rows only |
| Readers/Writers | Don't block each other | Don't block each other |
| Persistence | .db-wal |
.db-log (logical log) |
| Isolation | Snapshot (page-level) | Snapshot (row-level) |
Versioning
Each row version tracks:
- begin - timestamp when visible
- end - timestamp when deleted/replaced
- btree_resident - existed before MVCC enabled
Architecture
``` Database └─ mv_store:
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
.claude/skills/mvcc/SKILL.md