News for hackers. Stuff that matters.

transactional

Re:To fsync or not, that is a question on Monday May 04, 2026 @09:45PM (#48017129)
I strongly hope that the authors are actually using O_DSYNC|O_DIRECT, and not just the O_DIRECT they discuss. The post seems to conflate the 4KB atomicity (support for which is still hit or miss from drives I’ve checked) with 4KB writes being assuredly durable. If there is a write cache on the SSD/NVMe, which is common, one must either issue a FLUSH via fsync or have FUA set on the write via O_SYNC/O_DSYNC. Relying only on O_DIRECT is not a correct solution, as it assumes a drive with sufficient capacitors to always write out all cached data on failure, and that’s not a part of the required drive contract.
Re:Benchmarking Postgres on Friday July 04, 2025 @03:05PM (#44467049)
percona/sysbench-tpcc has been subsequently updated to include a stronger disclaimer that it's "TPC-C-like" and doesn't comply with multiple TPC-C requirements. Fingers crossed that this helps stop vendors from doing non-TPC-C benchmarking without realizing it.
...but are they enforceable?
Re:Decomposing Transactional Systems on Monday April 21, 2025 @03:30AM (#43749253)
(Hi! Post author here.)

It is written with a lean towards serializable, partly because there's a wide variety of easy examples to pull which all implement serializable, but the ideas mostly extend to non-serializable as well. Non-serializable but still MVCC will also place all of their writes as having happened at a single commit timestamp, they just don't try to serialize the reads there, and that's fine. When looking at non-serializable not MVCC databases, it's still useful to just try to answer how the system does each of the four parts in isolation. Maybe I should have been more direct that you're welcome to bend/break the mental model in whatever ways are helpful to understand some database.

The line specifically about MySQL running at serializable was because it was in the Spanner section, and Spanner is a (strictly) serializable database.

Re:Userland Disk I/O: Filesystems, file IO, and durability on Sunday November 10, 2024 @08:49PM (#42103969)
I'll rephrase the line sometime, but the intention is to communicate that it's the default choice to go with if you're making this decision in 2024. Most of the projects which aren't using some form of direct IO are doing it because they predate O_DIRECT (e.g. postgres), didn't architect for using async IO (e.g. mongo), or have excessive portability concerns which means they only offer it as an option (e.g. innodb).
Re:How do databases execute expressions? on Thursday September 21, 2023 @05:48PM (#37604880)
A recent blog post about MongoDB's SBE detailed that the purpose behind their VM is that it serves as a way to re-use an execution component between two different query languages. SQLite's claim was just that the strong separation between compilation and execution makes issues easier to debug.

I wouldn't expect VMs to become the default design in databases, but it seems like it's getting increasingly common as an IR for query compilation. The ability to have a (comparatively simpler) interpreter for the VM also means you can apply simple fuzzing to great effect: if the results of interpretation vs compilation ever diverge, there's a bug.

Re:The Secret Life of Fsync on Monday April 03, 2023 @04:37AM (#35420344)
It’s interesting to me that in the original proposal for fixing fsync to actually be durable (https://lwn.net/Articles/270891/), there was thought given to the desire for a non-flushing write barrier (ctrl-f SYNC_FILE_RANGE_NO_FLUSH), but it appears that it never got implemented.
Re:Show HN: Distributed SQLite on FoundationDB on Monday August 08, 2022 @10:53PM (#32393791)
There's one set of folk working on a btree, and another set of folk are now working on a RocksDB storage engine.

The original preference away from RocksDB was that it doesn't play well with deterministic simulation. Any code included into FDB needs to be able to be able to run with coroutines (strongly preferably stackless ones, though sqlite's btree has a stackful coroutine shimmed under it). RocksDB is definitely not written to support coroutines, and thus trying to use it anyway results in sacrificing developers' abilities to dig into failures.

Redwood has a couple design decisions that would make it a poor general purpose btree, but a great one for FoundationDB. But RocksDB will still have write and space amplification advantages.

If you don’t like being told what to do, boy do I have bad news about PhDs for you...
(Disclaimer: affiliated)

Redwood isn't "completed", but it's not unavailable. Evaluating it via `fdbcli> configure ssd-redwood-1-experimental ` is encouraged, but it hasn't seen sufficiently deep evaluation and verification that it's been set as the default ssd storage engine yet.

Not all releases got blog posts. Which ones did honestly had far more to do with the people involved in the releases at the time than any technical merits. This is the first feedback that I've seen where the blog posts were used as a signal of worthiness or stability, so we'll see if we can try to be a bit more responsible about making release posts.

Releases that are posted to the downloads page are all equally considered "ready to go". They appear a bit slower than what gets tagged on github, as the production environments in the core set of companies supporting FDB development are used as the last stage of QA before an official release. (Though this distinction might be less clear as the downloads page was recently redirected to the github release artifacts page.)

You can find the 7.0 release notes at https://github.com/apple/foundationdb/blob/main/documentatio..., which will appear in the documentation once the public site is updated to 7.0 (which happens once the first official, public release is blessed).

All that said, the regular release cadence so far has been about every 6 months, which I think still does qualify as "glacial".

I understand nothing of helm, but https://github.com/FoundationDB/fdb-kubernetes-operator/pull... seems to suggest yes?