LMDB

LMDB (Lightning Memory-Mapped Database) is a embedded database for key-value data based on B+trees. It is fully ACID transactional. The key features of LMDB are that it uses a single-level store based on memory-map files, which means that the OS is responsible for managing the pages (like caching frequently uses pages). It uses shared memory copy-on-write semantics with a single writer; readers do not block writers, writers do not block readers, and readers do not block readers. The system allows as many versions of data at any time as there are transactions (many read, one write). It also maintains a free list of pages to track and reuse pages instead of allocating memory each time.

History

LMDB was developed and maintained by the Symas Corporation to replace [Berkeley DB](/db/berkeley-db) in the OpenLDAP project.

Query Interface

Custom API

LMDB has no SQL layer but applications can directly access the database using API calls provided by LMDB. API support is not just in C but many wrappers for other languages have been developed by open-source contributors. All key-value store operations can be performed using these API calls.

Concurrency Control

Multi-version Concurrency Control (MVCC)

Locking overhead avoided by using MVCC, readers don't block at all and writers don't block readers. Deleted versions are reclaimed by the free space management module of LMDB (essentially stored into a B+ tree for later use).

Logging

Shadow Paging

No logging procedures are implemented here, using copy-on-write semantics (with shadow paging) provides durability without any need for logging. Shadow paging allows new writes to a different location and not directly replace the existing pages, hence avoids data-corruption: the root page changing to the new data is only updated *after* the new tree is saved. Also the shadow root page reference update is atomic. Combined, this entirely avoids the need for logging. As a result, data loss on a power loss event is only up to the point where the last root page was saved, as long as fsync (or fdatasync on GNU/Linux OSes) is used. Reliability of the underlying storage hardware (SSD, HDD, NAS) is out of scope of LMDB's design.

Storage Model

Custom

They use a memory-map to store the database with copy-on-write semantics, hence no specific storage model but the semantics are left to the operating system. The on-disk representation is similar to the memory representation of the database.

Isolation Levels

Serializable

LMDB provides Serializable isolation with MVCC, this is possible because of the single-writer semantics. Only a single write transaction can can be alive at a single point of time, hence no races among multiple writers modifying the database.

Query Execution

Tuple-at-a-Time Model

There is no query planning or query execution options as this is an embedded database, since we operate at individual key level, the closest we can classify it is under tuple-at-a-time. The user can program custom querying models on top this embeddded database, which can support other query execution options.

Stored Procedures

Not Supported

Indexes

B+Tree

LMDB uses a modified design of B+ Tree with an append-only enhancement, and it uses 2 B+ trees : one for maintaining the regular user data pages and one for maintaining the free pages obtained after deletes. LMDB is optimized for read transactions. Due to use of Copy-on-Write, readers never block writers, therefore read transactions, by using older pages, may live indefinitely without affecting write performance.

Storage Architecture

In-Memory

LMDB uses mmap, hence it reliquishes most of the caching control to the OS. Memory map allows zero-copies for read/write and no additional buffers for the transaction control. Supports larger-than memory databases, it is bounded by the size of the virtual memory since they use a memory map.

Data Model

Key/Value

This embedded database is a key-value in the backend, which is stored in the memory-map. The keys are indexed in a B+ tree. LMDB provides transactional guarantees on top of this key-value store. It is not a relational database.

System Architecture

Shared-Memory

LMDB uses shared-memory model i.e. it handles the memory as a single address space and all the threads access this in parallel. It uses copy-on-write semantics.

Query Compilation

Not Supported

Parallel Execution

Intra-Operator (Horizontal) Inter-Operator (Vertical)

LMDB employs "Multi-version Concurrency Control". Multiple threads in multiple processes are permitted, whilst at the same time limiting write transactions to only one (via a mutex). There is however no limit on the number of readers, which scale linearly (resources permitting), including when a write transaction is in progress, and are "wait-free".

LMDB Logo
Website

https://symas.com/lmdb/technical/

Source Code

http://www.openldap.org/software/repo.html

Tech Docs

http://www.lmdb.tech/doc/

Former Name

LightningDB

Developer

Howard Chu

Country of Origin

IE

Start Year

2011

Project Type

Commercial, Open Source

Written in

C

Supported languages

C, C++, Clojure, Erlang, Go, Haskell, JavaScript, Julia, Lisp, Lua, Matlab, Nim, Objective-C, Ocaml, Perl, PHP, Python, R, Ruby, Rust, Swift, Tcl

Inspired By

Berkeley DB

Operating Systems

AIX, Android, BSD, iOS, Linux, OS X, Solaris, Windows

Licenses

OpenLDAP Public License

Wikipedia

https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database