Yet another Hacker News

UUIDv7 doesn't have the properties you think it does

50 points ibobev 2 hours ago 30 comments

pphysch 1 hour ago | parent

> My mental model for UUIDv7 is that it’s a mash-up of a bunch of different ideas which implementations are free to choose as they see fit. There’s a wide variance of properties that UUIDv7 implementations can provide, with varying degrees of certainty they can successfully provide those properties.

I think this is good. A proper UUID that has specific significant bits dedicated to (approximately) monotonic values is useful. I don't want it over-specified beyond that, and I don't want to just use UUIDv8.

sedatk 1 hour ago | parent

You probably don't need a UUID: https://ssg.dev/you-probably-dont-need-a-uuid/

kune 55 minutes ago | parent

I support this. I wrote a Sqlite plugin for KSUIDs, but at the end I never used them, since all I do can be handled by integer primary keys, which sqlite maps to the rowid automatically. Autoincrement is only required, if you want to prevent the reuse of ids in deleted rows.

mahboi 36 minutes ago | parent

For a database primary key, yeah. Just use serial.

esafak 11 minutes ago | parent

That depends on your database. Serial keys can create hot spots in distributed databases because new writes are consistently directed to the same partition.

nodamage 31 minutes ago | parent

...if you work specifically on web applications with a centralized database.

Some of us don't, so these types of universal proclamations are rather unhelpful.

woogle 7 minutes ago | parent

another benefit of not using UUID:

for AI heavy apps/agent they are token expensive

jefecoon 1 hour ago | parent

Great article.

I assume I'm oblivious and naive, but it seems theoretically possible these issues could -- theoretically -- result in TOCTOU or similar issues.

Any thoughts about relying on:

- central time service, with message-queue of inbound requests, resulting in correctly timed + sequenced events [ albeit with hopefully small lag tradeoffs ]?

- know of any databases that implement this type of logic around their own minting of time-stamped UUIDs?

Prior efforts implementing event-driven backend service with UUID7s minted in client-code seemed perfectly fine at low usage/scale. However, as clients + usage + event-volume scaled, team became more curious about time/timestamp/related issues, and any minting client-side quickly fell out of favor.

Any insights greatly appreciated -- thanks

[ edited b/c i don't know how to format... ]

awesome_dude 10 minutes ago | parent

See: NTP, Lamport and Vector clocks. Spanner (Google) does make a good job of using atomic clocks, but it takes a hang of a lot of money.

saagarjha 1 hour ago | parent

Just use UUIDs as they were meant to be used, as a random identifier. Don't shove random other junk into it!

cpburns2009 21 minutes ago | parent

The point of shoving the timestamp into it is to make it work well with database indexes. UUIDv4 is awful in that regard.

saagarjha 9 minutes ago | parent

Sounds like the problem here is that databases need to index on more than one thing at once

phoronixrly 1 hour ago | parent

Wow... That is some nitpicking... The major issue these UUIDs solve for me is the fact that using a random UUID as a primary key of a relational database leads to horrible performance...

It has never crossed my mind to decode the timestamp from them so I save myself a 12-byte column, neither has it crossed my mind to have them monotonic in a distributed system...

alexchamberlain 25 minutes ago | parent

The author is in DevSecOps (i understand the Sec part...) - nitpicking is in the job description.

mahboi 22 minutes ago | parent

Serial PK solves this too, better actually cause it's smaller

phoronixrly 12 minutes ago | parent

Why would I ever use a UUID PK if I had the option to use a serial one instead?

hackingonempty 1 hour ago | parent

> If you need to list things ordered by creation time very often, it’s useful if the primary index gives that behavior, removing the need for another index.

I thought the main reason UUIDv7 was created with a time component is to keep temporally related rows together in the index pages. Randomly distributed row ids seem OK until the entire index no longer fits in RAM.

pkulak 19 minutes ago | parent

Yeah, this is 99% of the benefit for me. And it's not theoretical. My company saw performance issues using pure random IDs with MySQL way back in 2015; and consequently rolled our own UUIDv7 that we're still using to this day.

zeendo 8 minutes ago | parent

Yeah, same.

I suppose it's a problem if the spec actually says they're monotonically incrementing because it's clear that isn't guaranteed. But that was never a property I wanted or expected out of them anyway.

All of the other issues here sound like misunderstandings or misuses of ids, IMHO

skrebbel 1 hour ago | parent

I feel like this article way downplays the entire point of UUIDv7s, which is that it lets you sort (and store!) your data kinda sorta by creation time, no overlap ever. That's great for cursors, for streaming data, for twitter clones, for chat messages, for player moves, and so on and so forth. Nearly everything that's vaguely realtimey that you might like to both persist and broadcast live to other clients, and displayed in a stable & reasonable order, benefits from a property like this.

In fairness, he does mention this, but squeezes it into a single sentence near the end. But eg the fact that you can't reliably extract the precise timestamp from the UUIDv7 is a feature, not a bug. It's either that or collisions and you don't want the collisions.

roughly 45 minutes ago | parent

Yeah, I think the key here is that you have to know what the limitations are. UUIDv7 does _not_ provide you with sorted and ordered IDs by creation time, it provides you with _kinda sorta_ sorted and ordered IDs by creation time. That's probably fine for a lot of use cases, but if it's not OK for yours (forensic accounting, risk mitigation for banks, whatever), you can't use it for that. You're right it's not a technical problem necessarily, but when the marketing material describes something without an asterisk, people who are unaware that what's being described is impossible at the limits can make bad system design decisions based on that promise.

ForHackernews 1 hour ago | parent

Most (all?) of these are also true of UUIDv1. Devs in 2026 should be well versed in using UUIDv4 if they really truly can never leak anything.

0x20cowboy 59 minutes ago | parent

As others have said, I don’t think the time was meant to be something you relied on for the object time, but more the help with indexing and sharding.

mahboi 24 minutes ago | parent

Yeah this was odd: "Superficially, it seems that embedding a timestamp in the ID can remove the need to track the creation time in a separate database column" Who actually tried to do this?

I didn't assume uuid7 was guaranteed monotonic either. Of course not if you have different clocks. That's not the point of it.

nitwit005 45 minutes ago | parent

The Python version simply forces the timestamp forward if needed to preserve ordering:

  if timestamp_ms < _last_timestamp_v7:
    timestamp_ms = _last_timestamp_v7 + 1

https://github.com/python/cpython/blob/8d119208074fef0f652f1...

But if you did want "monotonically increasing IDs", as the article suggests, that is what you want.

taylorbuley 40 minutes ago | parent

> the problem is that system clocks cannot be synchronized to a suitable precision.

There are fun conditions under which a quasicrystalline clock could coordinate this in a distributed way. https://en.wikipedia.org/wiki/Time_crystal

adityaathalye 36 minutes ago | parent

alexsci destroyed one of my core assumptions in a bitemporal data system project I've been noodling on. Namely, this oh-so-confident presumption:

Realities are arrows. Time marks flight. UUIDv7 is Time.

(Yes. Yes. No, hell no, not after what Robert just told ya.)

https://www.evalapply.org/posts/poor-mans-time-oriented-data....

The small saving grace for me is that, despite my broken mental model of UUIDv7's time and monotonicity properties, I get to also use SQLite's automatic rowid for ordering and disambiguation. That too, only because I can (still think I can) get away with a "DB per tenant" architecture. Nevertheless, the same breakage potential will return when (not if, when) I have to mix / remix records from two or more DB files.

brb, investigating whether I can reliably construct UUIDv7s using db-time...

mahboi 35 minutes ago | parent

I've never bothered with anything but uuid4. Yes there are special circumstances where a public uuid7 helps because you're sure the timestamp leakage is ok, and you made sure it's not guessable, and you're sure some index performs better with it in a way that matters. There are also certain distributed systems where it has helpful properties. The amount of times blanket advice is given to use uuid7 far outweighs how often I've been in that situation, especially when people are talking about Postgres primary keys.