I wrote MQDB, an MQTT broker with an embedded reactive database, built on Fjall

[fabracht]

I've been building MQDB, a Rust MQTT 5.0 broker that embeds a reactive database directly into the broker process. Every write produces an MQTT event, and every MQTT topic can be a query or a CRUD endpoint. Fjall is the storage engine behind it on native targets.

I just wanted to share how Fjall is being used in case it's interesting, and to say thanks for the library.

Where Fjall fits

Storage in MQDB is behind a StorageBackend trait so the same code runs on:

• Native — Fjall (fjall = "3.0")
• WASM — an in-memory backend
• Encrypted — a wrapper around Fjall that does PBKDF2 + AES-256-GCM envelope encryption per value

The Fjall backend is one file (crates/mqdb-core/src/storage/fjall_backend.rs) and uses a single Database with one Keyspace called "main". Everything in MQDB — entities, secondary indexes, subscriptions, sessions, retained messages, dedup cache, Raft log, partition state — lives in that one keyspace, separated by key prefixes:

data/{entity}/{id}
idx/{entity}/{field}/{value}/{id}
sub/{subscription_id}
dedup/{correlation_id}
meta/{key}

Single keyspace + prefix encoding turned out to be a really comfortable model to build on. Prefix scans are the workhorse: listing entities, walking an index, paginating, counting — they're all prefix(...) or range(start..) over db.snapshot().

What I lean on Fjall for

• Snapshots for reads. Every read path (get, prefix_scan, prefix_count, range_scan) takes a fresh db.snapshot() and iterates. This gives me consistent reads while writes happen concurrently, without me having to think about it.

• Atomic batches with preconditions. This is the most useful primitive for me. MQDB needs optimistic concurrency for things like unique constraints and CAS-style updates, so the batch wrapper exposes an expect_value(key, expected) method. On commit it re-reads each precondition under a fresh snapshot and bails out with a Conflict if any value has changed; otherwise it submits the batched insert/remove operations through db.batch(). Single API, no locks above the storage layer.

• Configurable durability. MQDB has three modes: Immediate (call persist(PersistMode::SyncAll) after every write), PeriodicMs(n), and None. Immediate mode is what you want for the Raft log; periodic is enough for most user data.

• Cheap iteration. Pagination uses range(start..) with a sentinel-byte trick (after_key + 0x00) and breaks out as soon as the prefix no longer matches. Counting is a key-only scan. Both have been fast enough that I haven't had to add caching anywhere.

Things I appreciated as a user of Fjall

• The API surface is small. The whole backend fits comfortably in one screen and there's nothing surprising in it.
• Slice returning by reference from snapshot.get made the precondition check a one-liner.
• Switching between TCP/in-memory tests and a real on-disk Fjall instance is just Storage::memory() vs Storage::open(path, durability). No conditional logic anywhere upstream.
• I haven't had to look inside Fjall's internals once. That's the highest compliment I can give a storage library. Bravo

Numbers

On a single node, sync-on-every-write disabled, MQDB does roughly:

• inserts: ~12k ops/s
• gets: ~30k ops/s
• list (100 records, indexed): ~3k ops/s

These are end-to-end through MQTT (parse, route, write, ack), so the storage layer is comfortably faster than what the broker can feed it. I've never seen Fjall be the bottleneck.

What MQDB itself is, briefly

A single binary that speaks MQTT 5.0 and exposes a reactive database over it. You publish to $DB/users/create with a JSON payload, you subscribe to $DB/users/events/# to watch changes, you query with filters and indexes. Schemas, unique constraints, foreign keys with cascade, secondary indexes, TTLs, consumer groups, persistent wildcard subscriptions. Agent edition is open source (AGPL); there's also a clustered edition with Raft + QUIC + 256 partitions on top of the same Fjall-backed core.

Repo: MQDB repo here
Storage backend file: crates/mqdb-core/src/storage/fjall_backend.rs

Thanks for Fjall — it's been a really pleasant dependency to live with.