$ show cberner/redb
redb is a high-performance, ACID-compliant embedded key-value store library written in Rust. It provides a B-tree-based storage engine with copy-on-write semantics, MVCC concurrency control, and support for typed tables, multimaps, savepoints (ephemeral and persistent), compaction, and crash recovery. The library exposes a clean public API centered around `Database`, `TableDefinition`, `WriteTransaction`, `ReadTransaction`, and `ReadableTable` traits, with optional derive macros for user-defined key/value types. It is designed for single-writer, multiple-reader access and supports multi-process concurrency via byte-range file locking (experimental). The codebase is extensively tested with integration tests, fuzzing, and benchmarks comparing against LMDB, RocksDB, SQLite, and fjall. Architecturally, redb uses a copy-on-write B+tree for all tables (data, system, freed pages) with a buddy allocator for page management and a region-based file layout. The page store includes a striped LRU read cache, write buffer, and dynamic cache partitioning. Commit strategies range from non-durable (no fsync) to 1PC+C (default) and 2PC (secure). Crash recovery relies on XXH3-128 checksums and optional quick-repair via persistent allocator state. The library is `no_std`-compatible with feature-gated std-dependent parts, and includes a custom spin-lock synchronization module for embedded targets. Key entry points include the `Database::builder()` and `Database::open()` methods, `TableDefinition::new()` for schema definition, and transaction methods like `WriteTransaction::commit()` and `ReadTransaction::open_table()`. The `StorageBackend` trait allows pluggable storage (file, in-memory, custom) and is used extensively in tests for fault injection and crash simulation. External dependencies are minimal (standard library, optional chrono/uuid), with benchmark crates depending on heed, rocksdb, fjall, and rusqlite for comparison. The repository demonstrates strong engineering craftsmanship with clean abstractions, careful handling of edge cases (max keys, large values, corruption), and a well-documented design document (`docs/design.md`). The codebase is actively maintained with a stable file format and backward compatibility guarantees.
The LLM identified 4 files worth highlighting for reuse:
Implements a buddy allocator for variable-size pages using a BtreeBitmap per order. Supports serialization/deserialization, resize, and consistency checks. The allocator is self-contained and could be extracted for use in other projects requiring efficient page allocation with coalescing.
A custom LRU cache with a second-chance flag (clock-like algorithm) used for page caching. It provides atomic byte accounting, dynamic partitioning between read cache and write buffer, and best-effort vs required writeback. The implementation is isolated and demonstrates a non-trivial caching strategy suitable for embedded storage systems.
Implements a BtreeBitmap, a 64-way bit tree for tracking free pages. Used in the buddy allocator and region tracker. The data structure is self-contained, efficient for sparse bitmaps, and could be reused in any project requiring compact free-space tracking with fast search.
Defines the core `Key` and `Value` traits with fixed-width optimization, zero-copy access via `SelfType`/`AsBytes`, and a `TypeName` registry for backward compatibility. Includes separator generation and `min_encoded_key` logic for B-tree keys. The trait system is well-designed, generic, and could be extracted as a standalone serialization framework for embedded databases.