ORM & Data Access — Cross-Language Comparison

This note compares the data-access models a programmer actually picks between when wiring an application to a database — raw drivers vs query builders vs full ORMs vs document/KV clients vs graph drivers vs CDC/ETL vs type-safe Rust-style — across the 53 deep language notes plus the major DB engines. Each section has a unified table mapping libraries onto the axes (query complexity, type safety, migration story, async support, learning curve). The closing decision tree picks the right tool from query complexity + database type + team familiarity.

See also

• _compare_type_systems
• _compare_async-models
• _compare_error-handling
• _compare_build_tools
• sql
• query

1. The six layers

Every application’s data-access lives on a layered spectrum from raw protocol to high-abstraction ORM. Most apps mix layers — raw driver for hot paths, ORM for CRUD admin.

Layer	What you write	Abstraction	Type safety	Latency overhead
Raw driver	SQL strings + parameter binding	very low	none at compile time	~zero
Query builder	fluent API → SQL	low	partial (sometimes; depends on lang)	low
Code-first ORM (Active Record)	User.find(1)	high	partial	medium
Code-first ORM (Data Mapper)	repository + entity manager	high	partial-to-full	medium
DB-first / schema-first ORM	scan DB → generate types	high	full at compile time	medium
Type-safe SQL builder	compile-time-checked SQL	high	full	low

The 2018+ trend is toward layer 6 — compile-time-checked SQL (Diesel, jOOQ, sqlx, Drizzle, Prisma SQL queries) — combining ORM ergonomics with raw-driver performance and full type safety.

2. Raw database drivers

The protocol-level libraries. Hot-path code, ETL workers, and ops scripts often stop here.

Driver	Database	Language	Sync/Async	Notes	Linked note
libpq	PostgreSQL	C	sync	the reference; everything binds to it	c
psycopg2 / psycopg3	PostgreSQL	Python	psycopg2: sync; psycopg3: both	psycopg3 (2021+) is canonical; supports async + connection pool	python
asyncpg	PostgreSQL	Python	async	direct protocol implementation; ~2× faster than psycopg3 async	python
node-postgres (pg)	PostgreSQL	Node.js	async	de facto Node Postgres client	javascript
postgres.js	PostgreSQL	Node.js	async	newer; tagged-template SQL, faster than pg	javascript
JDBC	universal	Java	sync (Loom virtual threads enable scaling)	the standard JVM database API	java
HikariCP	universal	Java	sync	the dominant JVM connection pool	java
JDBI	universal	Java	sync	thin layer atop JDBC; row-mapper convenience	java
R2DBC	universal	Java	async (Reactive Streams)	reactive JDBC alternative; mostly displaced by virtual threads	java
ADO.NET	universal	C# / VB.NET	sync + async	the .NET DB API; SqlClient, Npgsql, MySqlConnector	csharp
Npgsql	PostgreSQL	.NET	async	high-quality .NET Postgres driver	csharp
pq	PostgreSQL	Go	sync (Go-style “sync”)	deprecated for pgx in 2023+	go
pgx (jackc/pgx)	PostgreSQL	Go	sync	the modern Go Postgres driver; high performance	go
database/sql	universal	Go	sync	stdlib interface; drivers register	go
postgres crate / tokio-postgres	PostgreSQL	Rust	both	sync + tokio async	rust
mysql / mysql_async crate	MySQL	Rust	both	similar	rust
mysql-connector-python	MySQL	Python	sync	Oracle’s official client	python
PyMySQL / aiomysql	MySQL	Python	sync / async	community alternatives	python
pymongo / motor	MongoDB	Python	sync / async	motor is asyncio wrapper	python
mongo-go-driver	MongoDB	Go	sync	official Mongo Go driver	go
mongoose (driver underlying)	MongoDB	JS	async	typical Node Mongo path	javascript
redis-py / aioredis (now redis-py 4.5+)	Redis	Python	sync / async	merged into redis-py 4.5+	python
ioredis / node-redis	Redis	JS	async	Node Redis clients	javascript
jedis / lettuce	Redis	Java	sync / async	Java clients; lettuce is reactive	java
sqlx (Rust)	universal	Rust	async	also a query-builder; compile-time SQL checking	rust
DBI	universal	Perl	sync	Perl’s standard DB API	perl
DBD::* drivers	universal	Perl	sync	DBI driver layer	perl
DBI / DBD	universal	Ruby	sync	older Ruby pattern (mostly replaced by AR)	ruby
pg / mysql2	universal	Ruby	sync	low-level Ruby drivers (used by AR)	ruby
Tcl Tdbc	universal	Tcl	sync	Tcl DB API	tcl
Database Toolbox	universal	MATLAB	sync	MATLAB DB connectivity	matlab
LibPQ.jl / SQLite.jl / MySQL.jl	universal	Julia	sync	Julia low-level drivers	julia

3. Query builders

A composable fluent API that generates SQL. Less abstraction than an ORM; more ergonomics than raw strings.

Builder	Language	Database	Notes	Linked note
Knex.js	Node.js (JS/TS)	universal	the OG JS query builder; pluggable migration system	javascript
SQLAlchemy Core	Python	universal	the bottom half of SQLAlchemy without ORM	python
Diesel	Rust	PG/MySQL/SQLite	compile-time-checked schema → DSL; type-safe results	rust
sqlx	Rust	PG/MySQL/SQLite/MSSQL	inline SQL with query! macro compile-time checked against DB schema	rust
sea-orm / sea-query	Rust	PG/MySQL/SQLite/MSSQL	dynamic query builder + Active Record-style ORM	rust
ent	Go	universal	code-generated from schema; type-safe relations	go
squirrel	Go	universal	fluent SQL builder	go
goqu	Go	universal	similar	go
jOOQ	Java	universal	DB-first; type-safe SQL DSL; gold standard for typed SQL on JVM	java
Slick	Scala	universal	functional-relational mapping; query is FP-composed	scala
Quill	Scala	universal	quoted DSL; compile-time SQL generation; supports cats-effect / ZIO	scala
Doobie	Scala	universal	functional JDBC, no ORM; FS2 streams for results	scala
persistent + esqueleto	Haskell	universal	typed Haskell DSL; esqueleto for joins	haskell
opaleye / rel8	Haskell	PostgreSQL	type-safe relational algebra	haskell
Beam	Haskell	universal	type-safe ORM + builder	haskell
kysely	Node.js (TS)	universal	strongly-typed query builder (compile-time schema)	typescript
drizzle-orm	Node.js (TS)	universal	TS-first; schema-as-types; lighter than Prisma	typescript
dbatools	PowerShell	SQL Server	management toolkit	powershell

The Knex → Drizzle / Kysely shift in the TS world (2023–2025) reflects industry preference for compile-time-typed query builders over heavy ORMs. Drizzle in particular has eaten Prisma’s mindshare for greenfield TS projects.

4. Full ORMs

Object-Relational Mappers — your domain objects are persistence-aware (Active Record) or kept ignorant via a repository (Data Mapper).

4.1 Active Record style (objects = rows, no repository)

ORM	Language	Pattern	Notes	Linked note
Rails ActiveRecord	Ruby	Active Record	the canonical AR pattern; Rails 7.2+	ruby
Sequel	Ruby	Active Record (lighter)	alternative to ActiveRecord; thinner	ruby
Eloquent	PHP	Active Record	Laravel ORM	php
Django ORM	Python	Active Record + manager pattern	Django framework	python
Peewee	Python	Active Record	smaller framework-independent	python
GORM	Go	Active Record	the popular Go ORM	go
TypeORM	Node.js (TS/JS)	Active Record or Data Mapper	decorators + entities; struggling for maintenance	typescript
Sequelize	Node.js (JS)	Active Record	older Node ORM; large community	javascript
Mikro-ORM	Node.js (TS)	Data Mapper + Unit of Work	TypeScript-first; identity map	typescript
Diesel-AR	Rust	not really AR; closer to query builder	(Diesel is hybrid)	rust
CakePHP ORM	PHP	Active Record	CakePHP framework	php

4.2 Data Mapper style (repository + entity manager)

ORM	Language	Pattern	Notes	Linked note
SQLAlchemy ORM	Python	Data Mapper + Unit of Work	2.0+ async; the de facto Python ORM	python
Hibernate	Java	Data Mapper + Unit of Work	the JVM gold standard since 2001; JPA reference	java
JPA (Jakarta Persistence)	Java	Data Mapper spec	spec; implemented by Hibernate, EclipseLink, OpenJPA	java
Spring Data JPA	Java	repository + JPA	Spring Boot integration	java
EclipseLink	Java	JPA impl	alternative to Hibernate	java
Doctrine	PHP	Data Mapper + Unit of Work	Symfony’s ORM; identity map	php
Entity Framework Core (EF Core)	C# / .NET	Data Mapper + Unit of Work	EF Core 8/9 ships native AOT support	csharp
Dapper	C# / .NET	micro-ORM (closer to query)	StackOverflow-built; SQL + map	csharp
Prisma	TS / Node.js	data mapper-ish (custom)	schema.prisma → generated client	typescript
Drizzle	TS / Node.js	query builder + light mapper	(overlaps query-builder)	typescript

4.3 Schema-first / code-gen

Tool	Language	Notes	Linked note
Prisma	TS / JS	schema.prisma → typed client + migrations; v5+	typescript
ent	Go	Go schema as code → ORM	go
EdgeDB / EdgeQL	universal client (Python, JS/TS, Go, Rust)	new DB + ORM hybrid; schema-first	n/a
sqlc	Go	write SQL + sqlc generates type-safe Go	go
Atlas	universal	schema-as-code migrations	n/a
dbml + dbmate	universal	schema description language	n/a

5. Document and key-value clients

NoSQL has its own access pattern — direct client libraries, not ORMs (sometimes ODM — Object Document Mapper).

Library	DB	Language	Notes	Linked note
PyMongo	MongoDB	Python	sync	python
Motor	MongoDB	Python	async wrapper around PyMongo	python
Beanie	MongoDB	Python	async ODM atop Motor + Pydantic	python
Mongoose	MongoDB	Node.js	the canonical Mongo ODM	javascript
MongoDB.NET Driver	MongoDB	C#	official	csharp
mongo-go-driver	MongoDB	Go	official	go
mongo-rust-driver	MongoDB	Rust	official	rust
redis-py	Redis	Python	merged sync + async (since 4.5)	python
node-redis / ioredis	Redis	JS	community + popular	javascript
jedis / lettuce	Redis	Java	sync + reactive	java
StackExchange.Redis	Redis	C#	the .NET Redis client	csharp
go-redis	Redis	Go	github.com/redis/go-redis	go
Dynamoose	DynamoDB	Node.js	Mongoose-style ODM for DynamoDB	javascript
boto3 (DynamoDB)	DynamoDB	Python	low-level AWS SDK	python
PynamoDB	DynamoDB	Python	Pythonic ODM	python
aws-sdk DynamoDB	DynamoDB	JS/TS/Go/Java/Rust	official AWS SDKs	n/a
Couchbase SDK	Couchbase	universal	official SDKs in 10+ languages	n/a
DataStax driver	Cassandra	universal	DataStax C# / Java / Python / Go drivers	n/a
gocql	Cassandra	Go	community	go
ScyllaDB drivers	ScyllaDB	universal	Cassandra-protocol-compatible	n/a
Aerospike SDK	Aerospike	universal	low-latency KV	n/a
etcd client / clientv3	etcd	Go	official Go client	go
consul client	Consul	universal	for service discovery	n/a

6. Graph database clients

Graph DBs use their own query languages (Cypher, Gremlin, SPARQL, GQL, AQL). Clients usually expose those directly rather than offering a graph ORM.

Library	DB	Language	Notes	Linked note
Neo4j Driver	Neo4j	Python / JS / Java / Go / .NET	official Neo4j Bolt drivers; Cypher queries	sql / query
neo4j-python-driver	Neo4j	Python	bolt protocol	python
Spring Data Neo4j	Neo4j	Java	repository-style atop driver	java
Gremlin Tinkerpop	Gremlin servers (JanusGraph, Neptune, Cosmos DB Gremlin)	JVM, Python (gremlin-python), JS	the Tinkerpop API	java
Dgraph clients	Dgraph	Go / Python / JS	DQL queries (Dgraph Query Language)	go
JanusGraph	JanusGraph	JVM	Tinkerpop-compatible; Cassandra/HBase backend	java
AWS Neptune drivers	Neptune	Gremlin / SPARQL / openCypher	multi-protocol	n/a
ArangoDB drivers (arangojs, python-arango, go-arangodb)	ArangoDB	universal	AQL queries	n/a
TigerGraph driver	TigerGraph	universal	GSQL	n/a
Memgraph driver	Memgraph	universal	Bolt + Cypher	n/a
CozoDB	CozoDB	Rust + Python	Datalog flavor	rust
Neo4j GraphQL Toolbox	Neo4j	API	Neo4j + GraphQL bridge	n/a
GQL (ISO/IEC 39075:2024)	universal	spec	the first ISO graph-query standard, published 2024-04	n/a

7. CDC, ETL, and stream-processing

For data movement (DB → DB, DB → warehouse, DB → search index). Decoupled from app code.

Tool	Type	Notes	Linked note
Debezium	CDC (change data capture)	Postgres / MySQL / Mongo / SQL Server / Cassandra → Kafka	java
Maxwell	CDC	MySQL → Kafka/Kinesis	java
Airbyte	ELT	open-source EL connector hub	java
Fivetran	ELT	commercial managed ELT	n/a
Stitch	ELT	older managed ELT (Talend)	n/a
Materialize	streaming materialized views	Postgres-wire-compatible streaming DB	n/a
Estuary Flow	streaming	newer CDC + transformation	n/a
Apache Kafka Connect	streaming framework	source + sink connectors	java
Apache Flink	stream processing	stateful streaming; SQL + DataStream API	java
Apache Beam	unified batch + stream	runs on Flink, Spark, Dataflow	java
Apache Spark Structured Streaming	stream processing	Spark API for streaming	scala
dbt	analytics ELT	SQL transformations in warehouse	n/a
SQLMesh	newer analytics ELT	virtual environments, model-as-code	n/a
Trino / Presto	federated query	query across multiple DBs	java
Apache Iceberg / Delta Lake / Hudi	lakehouse table format	metadata layer atop Parquet	scala

8. Type-safe SQL — the convergence

The 2020+ shift: pull type safety as far left (closer to schema definition) as possible.

Tool	Language	Mechanism	Compile-time SQL checked?	Notes	Linked note
Diesel	Rust	schema gen → DSL	yes (via schema.rs)	type-safe joins	rust
sqlx	Rust	query! macro hits live DB during compile	yes (with DATABASE_URL set at build)	works with raw SQL	rust
jOOQ	Java	DB-first code-gen	yes (DSL types from schema)	the JVM gold standard; commercial license for some DBs	java
sqlc	Go	write SQL → generates typed Go	yes (parser + schema)	popular in greenfield Go	go
Prisma	TS	schema.prisma → typed client	yes (codegen)	most popular TS option	typescript
Drizzle	TS	TS schema → typed builder	yes (TS types)	lighter than Prisma	typescript
kysely	TS	TS schema → typed builder	yes	similar	typescript
EdgeDB / EdgeQL	multi	schema → typed client per lang	yes	new DB with first-class typed access	n/a
SurrealDB SDK	multi	schema → typed access	partial	multi-model	n/a
PostgREST + OpenAPI	universal	DB → REST → typed client	indirect	”DB IS the API” pattern	n/a
Hasura GraphQL Engine	universal	DB → GraphQL → typed client	indirect	similar	n/a

The pattern is DB schema as the source of truth → type-safe client at every level. Type errors at compile time, not 3 am production page. The tradeoff: schema migrations are still hard, and breaking-change compatibility matters more (now your TS types break too).

9. Database migrations

Migrations are a separate concern that’s often bundled with the ORM/builder.

Tool	Language	Notes	Linked note
Alembic	Python	SQLAlchemy ecosystem; auto-generate from model diff	python
Django migrations	Python	built into Django; auto-generate from model	python
Flyway	universal (Java)	SQL-first, version-numbered files	java
Liquibase	universal (Java)	XML/YAML/JSON/SQL changelogs	java
Atlas (ariga.io)	universal	declarative schema-as-code; HCL or SQL; Terraform-style plan/apply	go
Goose	universal (Go)	simple SQL migrations	go
Knex migrations	JS/TS	knex.js migration runner	javascript
Prisma Migrate	TS	tied to Prisma schema	typescript
Drizzle Kit	TS	drizzle migration toolkit	typescript
Diesel migrations	Rust	tied to Diesel schema	rust
EF Core Migrations	C#	tied to EF Core	csharp
DbUp	C#	imperative SQL script runner	csharp
FluentMigrator	C#	fluent C# DSL	csharp
migrate	Go	golang-migrate; SQL files	go
dbmate	universal	language-agnostic, SQL-based	n/a
sqlx migrate	Rust	sqlx CLI migrations	rust
ActiveRecord migrations	Ruby	built into Rails	ruby
Doctrine Migrations	PHP	Doctrine-bundled	php
Laravel migrations	PHP	Laravel-bundled	php
Phinx	PHP	framework-agnostic	php
Ecto Migrations	Elixir	Phoenix-bundled	elixir
SchemaSpy / pgmodeler	universal	DB visualization	n/a

The 2023+ shift: Atlas-style declarative schema-as-code is rising. You write the desired schema, the tool diffs against the live DB, generates an idempotent migration plan. Inspired by Terraform’s plan/apply.

10. Per-language data-access summary

Language	Idiomatic stack	Notes	Linked note
Python	SQLAlchemy 2.0 (sync+async) + Alembic; or asyncpg + raw SQL	SQLAlchemy 2.0 (2023) unified sync/async API; Pydantic 2 integration	python
JavaScript	knex.js + raw SQL; Sequelize legacy; Mongoose for Mongo	older Node stack	javascript
TypeScript	Drizzle / Kysely (type-safe); Prisma (popular); TypeORM legacy	new projects → Drizzle/Kysely	typescript
Java	Spring Data JPA + Hibernate; jOOQ for typed SQL; HikariCP pool; Flyway/Liquibase migrations	virtual threads J21+ enable blocking JDBC at scale	java
C	libpq, libmysqlclient, sqlite3	rare in modern app code	c
C++	libpqxx (Postgres), MySQL Connector/C++, ODBC, sqlpp11 (typed)	sqlpp11 is C++ jOOQ-style	cpp
[[Languages/csharp|C#]]	EF Core + LINQ; Dapper for hot paths; Npgsql; Atlas/EF migrations	EF Core 9 AOT	csharp
Go	sqlc + pgx; or GORM (Active Record); ent for schema-first	sqlc + pgx dominant in 2024+	go
Rust	sqlx (compile-time checked) or Diesel; sea-orm	sqlx most popular	rust
Swift	GRDB (SQLite-focused); Vapor Fluent ORM; SwiftData (Apple); CoreData (legacy)	mostly SQLite + GRDB on app side	swift
Kotlin	Exposed (JetBrains DSL); Spring Data + Hibernate (server); Ktorm	Exposed is Kotlin-idiomatic DSL	kotlin
Ruby	ActiveRecord (canonical); Sequel; ROM (Repository pattern)	Rails 7+	ruby
PHP	Eloquent (Laravel) or Doctrine (Symfony)	the two dominant	php
Scala	Doobie (FP); Slick; Quill; ScalikeJDBC; Magnum (newer)	FP-effect stacks dominate	scala
Dart	Drift (SQLite); Floor (Room-inspired); Isar; SQLDelight	mostly mobile-local	dart
Elixir	Ecto (the de-facto ORM)	Ecto is widely admired for changesets + composable queries	elixir
Haskell	persistent + esqueleto; opaleye / rel8; Beam; Hasql	many options; rel8 + opaleye for typed PG	haskell
Clojure	next.jdbc (the modern API); HoneySQL (data → SQL); Toucan2	next.jdbc + HoneySQL pair common	clojure
[[Languages/fsharp|F#]]	SQLProvider type provider; Dapper.FSharp; FSharp.Data.SqlClient	type providers do compile-time DB schema	fsharp
Lua	LuaSQL; lapis.db; pgmoon (cosocket-friendly)	OpenResty-friendly	lua
R	DBI + dplyr + dbplyr; RPostgres; data.table for analytics	dbplyr translates dplyr to SQL	r
Julia	LibPQ.jl; SQLite.jl; SearchLight (Genie ORM); ODBC.jl	small ecosystem	julia
Zig	manual; bindings to libpq + sqlite3	tooling early	zig
Nim	db_postgres + db_sqlite stdlib; norm ORM	small ecosystem	nim
Crystal	db.cr + pg.cr/mysql.cr; Granite ORM	small ecosystem	crystal
OCaml	Caqti (driver abstraction); Petrol; pgocaml (typed PG); Macaque	typed PPX-based options	ocaml
Perl	DBI + DBIx::Class; Mojo::Pg / Mojo::mysql	DBIx::Class is the Perl ORM	perl
Erlang	epgsql; emysql; mnesia (built-in distributed DB)	mnesia is unique — distributed RAM/disk DB	erlang
Racket	db library (universal)	thin layer	racket
Common Lisp	CL-DBI; Mito ORM; cl-postgres	small ecosystem	common-lisp
Scheme	impl-specific (Chicken, Racket)	varies	scheme
Fortran	rare — typically calls libpq via ISO_C_BINDING	scientific code more than enterprise	fortran
COBOL	embedded SQL (EXEC SQL); CICS+DB2; IMS DLI	massive enterprise install base	cobol
Ada	GNATCOLL.SQL + GNATCOLL.Postgres; ODBC	small ecosystem	ada
Pascal	FireDAC (Delphi); IBX; SQLdb	mostly Delphi-centric	pascal
Prolog	ODBC (SWI); proSQL	research	prolog
Tcl	Tdbc	thin	tcl
Groovy	Spring Data + Hibernate; GORM (Groovy ORM)	JVM ecosystem	groovy
Bash	psql / mysql clients + heredocs; sqlite3 CLI	ops + reporting	bash
PowerShell	dbatools (SQL Server); Invoke-Sqlcmd	DBA-heavy	powershell
SQL	the query language itself; stored procedures + functions	PL/pgSQL, T-SQL, PL/SQL, PL/Tcl	sql
V	vsql (built-in)	early	v
Odin	manual bindings	small ecosystem	odin
Roc	platform-supplied	platform-defined	roc
Gleam	gleam_pgo; Cake (typed query)	BEAM ecosystem	gleam
Pony	bindings	small ecosystem	pony
Idris	research	rare	idris
Lean	research	n/a	lean
Coq (Rocq)	research	n/a	coq
Agda	research	n/a	agda
Smalltalk	Glorp; image-based persistence; native object DB (Magma, GemStone)	image-based persistence is unique	smalltalk
MATLAB	Database Toolbox	scientific	matlab
Mojo	calls Python; native bindings early	early	mojo

11. Recent shifts (2022–2026)

• Type-safe queries → mainstream: Drizzle, Kysely (TS); sqlx, Diesel (Rust); sqlc (Go); jOOQ (Java); Prisma. The bar for “ORM” is rising — pure runtime ORMs without compile-time type checking feel obsolete.
• Migration tools → declarative: Atlas (Go), schema-as-code, plan/apply. Inspired by Terraform.
• Lakehouse table formats: Iceberg + Delta Lake + Hudi formalized the metadata layer atop Parquet (S3/GCS/ADLS object storage). Iceberg won the open standard war by 2024 (Snowflake + Databricks + AWS all back it).
• CDC + streaming: Debezium + Kafka + Flink became the standard “DB → everything else” pattern.
• Postgres extensions explode: pg_vector (RAG), pg_cron, pg_partman, pg_search, pgvectorscale (Timescale), TimescaleDB, PostGIS, PostgreSQL FDW for federation. “Postgres for everything” gained ground 2023–2025.
• NewSQL distributed databases: CockroachDB (Postgres-wire), TiDB (MySQL-wire), Yugabyte, Spanner. Most expose existing drivers transparently.
• DuckDB rise: in-process columnar analytics DB; the “SQLite of analytics”. Eats into Spark + small-warehouse use cases.
• EdgeDB + SurrealDB: novel DBs with schema-first typed access built in from day one.
• Hasura / PostgREST / Supabase: DB → REST/GraphQL auto-API pattern matured; smaller projects skip the backend layer entirely.
• Vector DBs: Pinecone, Weaviate, Qdrant, Chroma, Milvus, Vald, LanceDB; pgvector also competes in this niche.
• Java virtual threads make blocking JDBC scale — partial undoing of the R2DBC reactive push.
• Async/await unification: SQLAlchemy 2.0 (Python), EF Core 8+ (C#), Hibernate Reactive (JVM).

Adjacent

• sql — the SQL language itself.
• query — graph + log + event query languages.
• _compare_type_systems — type providers + type-level schema.
• _compare_async-models — async drivers + Reactive Streams + virtual threads.
• _compare_error-handling — DB errors, retries, dead-letter.
• _compare_build_tools — codegen workflows for sqlc / Prisma / jOOQ / EF migrations.

When to pick what

Need ?
├─ Hot path / low latency / well-known queries
│   ├─ Rust → sqlx (compile-time checked) + tokio-postgres
│   ├─ Go → pgx + sqlc (generated typed Go)
│   ├─ Java → JDBC + HikariCP, or jOOQ; with virtual threads
│   ├─ C# → Dapper + ADO.NET
│   ├─ Python → asyncpg directly
│   └─ Node → postgres.js (tagged-template SQL)
├─ CRUD app with simple domain
│   ├─ Python → SQLAlchemy 2.0 + Alembic; or Django ORM
│   ├─ TS → Drizzle (light) or Prisma (popular)
│   ├─ Ruby → Rails + ActiveRecord
│   ├─ PHP → Laravel + Eloquent
│   ├─ Java → Spring Data JPA + Hibernate
│   ├─ C# → EF Core + LINQ
│   ├─ Elixir → Phoenix + Ecto
│   └─ Go → ent or GORM
├─ Complex queries (joins, CTEs, window functions, recursive)
│   ├─ JVM → jOOQ
│   ├─ Scala → Doobie or Quill
│   ├─ Haskell → opaleye/rel8 or persistent+esqueleto
│   ├─ Python → SQLAlchemy 2.0 (Core or ORM) for composition
│   ├─ Rust → Diesel or sqlx with raw SQL
│   ├─ TS → kysely or Drizzle with .with() / .with-recursive()
│   └─ Go → sqlc with raw SQL files
├─ Document DB (Mongo, Couchbase, DynamoDB)
│   ├─ Python → Beanie (Mongo, async); PynamoDB (Dynamo)
│   ├─ JS/TS → Mongoose (Mongo); Dynamoose (Dynamo)
│   ├─ Go → mongo-go-driver
│   └─ Native protocol clients (no ORM) for hot paths
├─ KV store (Redis, etcd, DynamoDB)
│   └─ Use the official driver; ORMs add little value
├─ Graph DB (Neo4j, Dgraph, Neptune, ArangoDB)
│   └─ Use the driver + Cypher / Gremlin / SPARQL / AQL / DQL directly
├─ Reactive / streaming app
│   ├─ JVM → R2DBC or virtual threads (now competitive)
│   ├─ Scala → Cats Effect + Doobie + FS2 streams
│   └─ Node → postgres-pubsub + LISTEN/NOTIFY
├─ Multi-DB federation
│   ├─ Trino / Presto for query
│   └─ Postgres FDW for read federation
├─ Real-time view / materialized stream
│   └─ Materialize, RisingWave, Estuary Flow
├─ Time-series
│   ├─ TimescaleDB (Postgres extension)
│   ├─ InfluxDB v3 (Iox)
│   ├─ ClickHouse (columnar OLAP also great for TS)
│   └─ Prometheus (metrics; not for app data)
├─ Vector / embedding
│   ├─ Pinecone / Weaviate / Qdrant / Milvus (purpose-built)
│   ├─ pgvector + pgvectorscale (Postgres native, simplest)
│   └─ Chroma (lightweight, dev)
├─ Lakehouse / data warehouse
│   ├─ Iceberg + Spark / Trino / Snowflake / Databricks
│   ├─ Delta Lake + Spark
│   └─ DuckDB for in-process analytics
├─ Migrations
│   ├─ Declarative schema-as-code → Atlas
│   ├─ Version-numbered SQL → Flyway, Goose, dbmate
│   ├─ Tied to ORM → Alembic, Prisma Migrate, Drizzle Kit, Diesel, EF Migrations, Rails AR
│   └─ DBA-managed → Liquibase changelogs (XML/YAML/JSON)
└─ CDC / pipelines
     ├─ Debezium + Kafka + Flink (stream)
     ├─ Airbyte / Fivetran (batch ELT)
     ├─ dbt / SQLMesh (warehouse SQL transformations)
     └─ Kafka Connect (universal sinks/sources)

The single biggest practical lesson 2018–2026: the layer that matters is type safety at the schema boundary, not which ORM you picked. The cost of getting a column name wrong in 2026 should be a compile-time error, not a 3 am page. Choose a stack — sqlc + pgx + Atlas (Go); Drizzle + Atlas (TS); SQLAlchemy 2.0 + Alembic (Python); jOOQ + Flyway (JVM); EF Core + EF Migrations (C#) — that surfaces schema diffs as type errors. Heavy runtime ORMs (TypeORM, Sequelize, JPA without jOOQ, GORM, Eloquent) remain fine for simple CRUD, but every team that scales past ~50k lines of data-access logic eventually moves to typed SQL builders + schema codegen. Save the ORM for the CRUD admin; reach for typed SQL at the hot path.