When using psql, append `\gset` to a query, and after execution, it stores each column as a psql variable. Use the variables in the same session.
The column name (or alias) becomes the variable name. Integer and boolean values are referenced with `:varname`. String values need `:'varname'` (the single quotes make them safe to interpolate into SQL literals).
Object storage is great for cheap durable archival, but a poor fit as the commit path for low-latency OLTP (high PUT latency + cost for small writes)
What’s missing is a public, reusable primitive that adds low-latency durable appends (SSD quorum / 1 RTT) & cheap async archival
There is a lot of hype around putting the WAL on object storage.
However, for low-latency systems, e.g. OLTP databases, object storage is a suboptimal primitive for the WAL:
(1) PUTs are expensive for small WAL writes [bytes/$].
(2) Object stores are optimized for throughput, not latency, with write latencies often around 10-50 ms.
Because every transaction must wait for its WAL record to become durable, every transaction inherits that latency.
This points to a missing storage primitive.
In our (@maxikuschewski@melhindiCS@viktor_leis) latest accepted research paper at VLDB, we looked at how to close that gap.
PostgreSQL 19 wins the AI era 🐘
Not because it’s trendy. Because AI agents need more than a database. They need programmable infra:
→ Database-per-agent
→ Agent-safe permissions
→ MCP + database tools
→ pgvector + hybrid search
→ Ephemeral databases
→ OAuth + workload identity
→ Graph + SQL queries
The AI era doesn’t need another vector database.
It needs one programmable database that can power the entire agent stack.
PostgreSQL is becoming that database.
https://t.co/MSqiOKqMI7
@kellyfj1@kellabyte File under: famous last words.
It's certainly much *easier* than scaling writes, because, transactional anisotrophy. But there's also no free lunch when you need those reads to be C + A (and not stale) across many many nodes in real time.
@kellyfj1@kellabyte It actually makes a perverted kind of sense bc global write availability is a red herring for this workload. It goes against infra ideology but it's a good match for the actual shape of their traffic.
If you are writing complex nested subqueries, you might be better off using CTEs (common table expressions) to improve the readability!
CTE enables you to define a query and treat its output as a new table, allowing you to organize your queries in a hierarchical structure.
we’re about to release a feature that I think is a big deal for postgres
we created a rust framework to query external databases/warehouses from inside postgres. it’s about to get streaming support :
"The DrizzleORM discourse looks like developers nitpicking edge cases, but Drizzle is winning adoption because its type inference is good enough that AI coding assistants can generate correct code without human supervision."
https://t.co/ozL239fcfb @DrizzleORM