What Goes Around

• 2005: What Goes Around Comes Around — 35 years surveyed.
• 2024 sequel with Pavlo, SIGMOD Record 53(2).
• Extends through MapReduce, NoSQL, document, graph.
• Finding: the cycle is still turning.

• New workload exposes a real relational weakness.
• Rebellion declares SQL dead, ships new model + language.
• Spends a decade rediscovering transactions, schemas, optimization.
• SQL absorbs the one new thing — a type and an index.
• Rebellion survives as niche engine or Postgres column.

• IMS (1968) = trees; CODASYL (1969) = pointer networks.
• Programmers navigate: GET NEXT WITHIN PARENT loops.
• Change the layout → rewrite the application.
• Codd 1970: data independence — name data, system navigates.
• Scoring question ever since: did you give up data independence?

• OODB wave: GemStone, ObjectStore, O2; ODMG standard 1993.
• Persist C++ objects directly — skip the tables.
• Gave up declarative queries and the schema boundary.
• Database now breaks when you refactor.
• Verdict by 2000: a rounding error; SQL:1999 added structured types.

• Had everything vectors have now: mandates, W3C stack, VC engines.
• Claim: this time the data really is different.
• Counter-move: SQL/XML (2003) type + XML indexes.
• The type survived; the universal data model did not.
• JSON re-ran the loop fast-forward: SQL:2016 operators, SQL:2023 type.

• Google 2004: no schema, no indexes, no optimizer — just scale.
• DeWitt & Stonebraker 2008: “major step backwards.” Mostly correct.
• Within five years: Hive, Impala, Presto, SparkSQL rebuilt SQL.
• Residue: shared-nothing scale-out, storage/compute split.

• MongoDB 2009: no joins, no transactions, no schema.
• 2012: aggregation pipeline. 2015: $lookup join.
• 2018: multi-document ACID in 4.0, plus schema validation.
• Google’s answer to Bigtable: Spanner — serializable, SQL by 2017.
• The rebels did not lose; they converged.

a rebellion needs ~ten years to rebuild recovery, concurrency, statistics, drivers, a planner — the incumbent bolts the one good idea into a socket in ~two release cycles.

• 2003: Fortune-500 insurer — “our documents will never fit tables.”
• 2009: same team migrating to DB2 pureXML — a column.
• Total app change: connection strings and namespaces.
• The rebellion’s value was one type and one index.
• Cost: six years without point-in-time recovery.

• Two teams, twenty minutes a side.
• Argue the strongest version of the position you draw.
• If absorption wins: go write Postgres extensions and optimizer rules.
• If exception wins: write the System R paper of the agentic era.

pgvector 0.5 shipped HNSW in 2023; within a year Oracle, SQL Server, MySQL, DuckDB, and the cloud warehouses all had a vector type and an ANN index — the XML choreography, executed in eighteen months instead of ten years.

-- 2026, one engine, one statement
SELECT p.sku, p.meta->>'title' AS title,
       embedding <=> :query_vec AS dist
FROM   products p
WHERE  p.meta @> '{"status":"active"}'   -- the JSON rebellion
ORDER  BY embedding <=> :query_vec        -- the vector rebellion
LIMIT  20;                                -- HNSW scan, costed like any other

Agents speak SQL through MCP — we taught the new client the old language.

• B-tree lookup and hash join return the same tuples.
• HNSW: recall@10 ≈ 0.95 at one ef_search, ≈ 0.99 at another.
• The higher setting costs 3–5× the latency.
• The answer itself is now a knob. XML never did this.
• SQL has no syntax for “95% of the right rows is fine.”

one semantic join over a 10⁴ × 10⁴ pair space = 10⁸ model calls ≈ $7,500 for a single query. Plan choice is now a procurement decision.

• Conventional predicate: ~10 ns CPU ≈ 10⁻¹² dollars.
• Semantic predicate: ~300 tokens × $0.25/M ≈ $7.5×10⁻⁵ per row.
• Gap: seven to eight orders of magnitude, before latency.
• Not “an expensive predicate” — cost avoidance under a budget.
• Different problem, different APIs: budgets, previews, partial results.

• Classical rewrites are sound: change cost, never answers.
• Semantic operator: (relation, prompt, model-version, temperature) → distribution.
• Push a predicate below a semantic filter → the model sees different rows.
• The rewrite changes the answer, not just the cost.
• Every optimizer rule now needs an accuracy-preservation proof.

a silent model-version bump flipped 4% of cached semantic-filter verdicts — and a downstream aggregate a procurement agent acted on. The fix: pin model versions like schema versions; treat an upgrade as a migration with a backfill.

• SQL grows WITH RECALL 0.95 CONFIDENCE 0.9 → absorption.
• That would be its biggest concession since windows in SQL:2003.
• Agent traffic moves to beliefs + provenance → exception.
• Then relational ends like navigational: underneath, not the interface.
• Neither happens → the cycle turns; you teach lap eight.

• Agents are the dominant clients; workloads change, not physics.
• Physics held: B-trees, ARIES, MVCC, buffer pool, optimizer.
• Workloads changed everywhere we measured.
• What’s scarce: agreement on meaning, not throughput.
• Fifty years of agreement on values; the frontier is meaning.

• Agent-native TPC: correct-task-completions per dollar, under retry storms.
• Derived-belief isolation: name the anomalies, then the protocols.
• Recall-aware compaction: lossy forgetting with stated recall guarantees.
• All systems problems; none needs a new model architecture.
• Durable contributions are contracts and machinery, not models.

• MongoDB 2009→2018: did the document rebellion win, lose, or converge?
• When does reordering a semantic filter change the result, not the cost?
• Agent-native TPC: defend a primary metric — and how vendors game it.

• Stonebraker & Pavlo, What Goes Around Comes Around… And Around…, SIGMOD Record 53(2), 2024.
• Abadi et al., The Seattle Report on Database Research, CACM 65(8), 2022.
• Stonebraker & Hellerstein, What Goes Around Comes Around, Readings in Database Systems, 4th ed., 2005.