DATABASES Signal 417
sqlc-generated Go code now automatically invalidates distributed caches on database writes
↗
exe.dev modified sqlc to track database reads and writes, enabling proxies to clear stale cache entries without manual logic
Engineers building distributed systems often face the trade-off between cache efficiency and correctness. This approach eliminates hand-written invalidation code while maintaining cache coherence. It shifts the complexity from application logic to tooling, reducing the risk of stale data in globally distributed proxies
Written by elseif from the cluster below · every claim links back to a sourceThe three things worth knowing
sqlc hooks record which tables and rows each proxy reads, storing the mapping in Go context
Database writes trigger cache invalidation messages to proxies that previously accessed the affected rows
Proxies discard entire cache entries for modified VMs rather than attempting precise field-level invalidation
THE READ
What the cluster adds up to.
The change embeds cache invalidation logic directly into sqlc-generated database access functions. Every read operation now records which tables and rows were accessed, while write operations trigger invalidation messages for any proxies that previously read those rows. This happens automatically without requiring developers to manually specify which cache keys might be affected by a database change.
The implementation relies on a centralized writer process that all database modifications must pass through. This single choke point allows the system to track every change and broadcast invalidation messages to affected proxies. The approach trades some architectural flexibility for cache coherence, as all writes must funnel through this process rather than allowing direct database access from multiple services.
Cache invalidation is deliberately coarse-grained. When a proxy receives an invalidation message, it discards all cached information for the affected VM rather than attempting to update only the changed fields. This simplifies the implementation and avoids complex field-level dependency tracking, at the cost of potentially unnecessary cache misses when only minor fields change.
The solution leverages Go's context mechanism to accumulate read operations across multiple database calls within a single request. This allows the system to track which data was accessed even when the information comes from multiple tables or requires several queries to assemble. The context-based approach means the cache invalidation logic remains accurate even as the application evolves and database schemas change.
Written by elseif from the cluster below · checked for specifics the sources never containedTHE CLUSTER