Overview

leveldb wraps Google's LevelDB — the original LSM-tree key-value store that later inspired RocksDB. It stores key-value pairs on disk, keeps keys in sorted order, and is optimized for write-heavy workloads. No SQL, no server, no configuration file — just open a path and start reading and writing.

LevelDB compresses data with Snappy by default, supports consistent read snapshots, and can apply many operations atomically through write batches. It is a foundational building block for databases, caches, and append-heavy storage systems.

Key Characteristics

Comparison

Quick Start

Open, write, read, close

uses leveldb;

{ Open (or create) a database at the given path }
var db := Open('/var/data/mydb');

Put(db, 'user:1001:name', 'Alice');
Put(db, 'user:1001:email', 'alice@example.com');

var name := Get(db, 'user:1001:name');
WriteLn('Name: ' + name);

Delete(db, 'user:1001:email');

Close(db);

Write batch (atomic multi-key update)

uses leveldb;

var db := Open('/var/data/mydb');
var b  := NewBatch;

BatchPut(b, 'account:42:balance', '1500');
BatchPut(b, 'account:42:updated', '2026-03-13');
BatchDelete(b, 'account:42:pending');

WriteBatch(db, b);  { all three ops are applied atomically }
FreeBatch(b);
Close(db);

Prefix-range iteration with snapshot

uses leveldb;

var db   := Open('/var/data/mydb');
var snap := NewSnapshot(db);

var ropts: TLevelReadOptions;
ropts.VerifyChecksums := False;
ropts.FillCache       := False;
ropts.Snapshot        := snap;  { read against frozen state }

var it := NewIteratorEx(db, ropts);
IterSeek(it, 'user:');  { jump to first key >= 'user:' }

while IterValid(it) do
begin
  var k := IterKey(it);
  if Copy(k, 1, 5) <> 'user:' then Break;
  WriteLn(k + ' = ' + IterValue(it));
  IterNext(it);
end;

FreeIterator(it);
FreeSnapshot(db, snap);
Close(db);

Types

type
  TLevelDB    = Integer;  { database handle returned by Open/OpenEx }
  TLevelIter  = Integer;  { iterator handle returned by NewIterator/NewIteratorEx }
  TLevelSnap  = Integer;  { snapshot handle returned by NewSnapshot }
  TLevelBatch = Integer;  { write batch handle returned by NewBatch }

  TLevelOptions = record
    CreateIfMissing   : Boolean;  { create DB if it doesn't exist }
    ErrorIfExists     : Boolean;  { fail if DB already exists }
    ParanoidChecks    : Boolean;  { verify checksums on every read }
    WriteBufferSize   : Integer;  { bytes, default 4 MB }
    MaxOpenFiles      : Integer;  { default 1000 }
    BlockSize         : Integer;  { bytes per block, default 4 KB }
    BlockCacheSize    : Integer;  { bytes, 0 = no LRU block cache }
    BloomFilterBits   : Integer;  { bits per key, 0 = disabled, 10 recommended }
    CompressionSnappy : Boolean;  { enable Snappy compression, default True }
  end;

  TLevelWriteOptions = record
    Sync : Boolean;  { fsync after write — slower but durable across crashes }
  end;

  TLevelReadOptions = record
    VerifyChecksums : Boolean;     { check block checksums on reads }
    FillCache       : Boolean;     { populate block cache from reads }
    Snapshot        : TLevelSnap;  { 0 = read current state }
  end;

Open / Close API

Open creates or opens a LevelDB database at the given filesystem path. Only one process may hold the database open at a time.

Basic Read / Write API

All keys and values are strings. Binary data is supported — use any encoding you like; LevelDB treats keys and values as opaque byte sequences.

Write Batch API

A write batch groups multiple puts and deletes into one atomic operation applied in a single disk write. This is both safer (all-or-nothing) and faster (one fsync) than issuing individual writes.

Iterator API

Iterators traverse keys in sorted lexicographic order. Because LevelDB stores keys sorted, a seek to a prefix followed by sequential IterNext calls is the canonical way to scan a range.

Snapshots API

A snapshot captures the state of the database at the moment it is created. All reads performed against a snapshot return consistent results regardless of concurrent writes, making snapshots ideal for backups and long-running scans.

Maintenance API

These functions expose LevelDB's internal maintenance and diagnostic operations.

uses leveldb;

var db := Open('/var/data/mydb');

{ Print internal stats }
WriteLn(GetProperty(db, 'leveldb.stats'));

{ Compact entire DB after a bulk delete pass }
CompactRange(db, '', '');

var sz := ApproximateSize(db, 'user:', 'user;');
WriteLn('User prefix ~' + IntToStr(sz) + ' bytes on disk');

Close(db);

Key Concepts

LSM-tree write path

Writes land first in an in-memory buffer (the MemTable). When full, the MemTable is flushed to a sorted on-disk file (an SSTable) at level 0. Background compaction threads merge and re-sort SSTables across levels, reclaiming space from deleted or overwritten keys. This design makes sequential writes very fast at the cost of read amplification on older data.

Key design for prefix scans

Because LevelDB keeps keys sorted, you can model relational-style access with structured key prefixes such as entity:id:field. A seek to 'user:1001:' followed by sequential IterNext calls will visit all fields of that user in one pass, reading from a contiguous range of the sorted file.

Sync writes

By default, Put and WriteBatch write to the OS page cache and may be lost if the process crashes before the OS flushes to disk. Set TLevelWriteOptions.Sync = True to call fsync after each write. This is roughly 100× slower but guarantees durability across power failures.