Postgres on

Lesson 10: Redis, MongoDB, and Non-Relational Stores — Beyond SQL

Sun, 10 Nov 2024 15:37:00 +0000

I spent a week optimizing a Postgres query that powered a leaderboard. It involved a complex window function over millions of rows, and no amount of indexing got it under 200ms. Then a senior engineer walked over, looked at the query, and said “Why isn’t this in Redis?” He was right. I replaced 30 lines of SQL with a sorted set and the response time dropped to 2ms.

Not every data problem is a SQL problem. Sometimes you need the right tool, not a better query plan.

Lesson 9: N+1 Queries, Indexes, and EXPLAIN — Database performance in Rust

Wed, 06 Nov 2024 07:52:00 +0000

A coworker asked me to look at an endpoint that was taking 8 seconds to return 50 orders. The table had 200K rows — not big by any standard. I opened the code, and the pattern was immediately obvious: fetch 50 orders, then for each order, fetch its items in a separate query. Fifty-one database round trips where one would do.

The N+1 query problem is the most common performance mistake in database-backed applications, and Rust doesn’t magically prevent it. You need to know what to look for.

Lesson 8: Testing with Real Databases — No more mocking SQL

Sun, 03 Nov 2024 13:15:00 +0000

I spent two days debugging a production issue where a query returned duplicate rows. The unit tests all passed — every mock returned exactly the expected data. The problem was a missing DISTINCT in a JOIN query that only manifested with real data containing multiple matching rows. The mocks were too perfect. They never produced the messy data that real databases contain.

That was when I stopped mocking SQL.

The Problem with Mocking Database Calls

Mocking databases is popular because it’s convenient. You don’t need Docker, you don’t need a test database, your tests run in milliseconds. But you’re testing the wrong thing.

Lesson 7: Building Type-Safe Query Builders — Queries that can't be wrong

Fri, 01 Nov 2024 09:28:00 +0000

I was reviewing a PR that had a search endpoint with 12 optional filters. The handler was a 200-line function full of if let Some(...) blocks, each appending a different SQL fragment to a String. It worked — until someone forgot a space between AND and a column name, and the query silently returned zero results instead of erroring. No compile error. No test failure. Just a missing space in a string.

Lesson 6: The Repository Pattern in Rust — Abstracting persistence

Wed, 30 Oct 2024 16:40:00 +0000

I once inherited a codebase where every HTTP handler had raw SQL queries inline — sqlx::query! calls scattered through 80+ route handlers. Changing a table name meant grep-and-replace across the entire project. Adding a cache layer meant touching every handler. Testing a handler meant spinning up a real database. It worked, technically, but nobody wanted to touch it.

The repository pattern fixes this. It puts a wall between your business logic and your database, and that wall pays for itself fast.

Lesson 5: Transactions and Error Rollback — Atomic operations

Mon, 28 Oct 2024 10:05:00 +0000

A payment service I worked on had a subtle bug: it deducted money from the user’s wallet, then tried to create an order record. If the order insert failed — constraint violation, timeout, anything — the money was already gone. The user’s balance was decremented but they had no order. We called these “ghost charges” internally, and customers called them something less polite.

The fix was embarrassingly simple: wrap both operations in a transaction.

Lesson 4: Schema Migrations in Rust Projects — Evolving your database

Sat, 26 Oct 2024 19:12:00 +0000

A teammate once ran ALTER TABLE orders DROP COLUMN status on the production database because he’d tested it locally and “it worked fine.” What he didn’t realize was that three other services depended on that column, and they all started throwing errors simultaneously. We spent the evening restoring from a backup.

Schema migrations exist to prevent exactly this — they’re version control for your database.

The Problem

Your database schema isn’t static. Features get added, requirements change, data models evolve. You need a way to:

Lesson 3: Connection Pooling with deadpool and bb8 — Managing database connections

Thu, 24 Oct 2024 14:35:00 +0000

I once watched a Rust service fall over under modest load — maybe 200 concurrent requests — because every request opened a new Postgres connection, used it for one query, and dropped it. The database was spending more time on TLS handshakes and connection setup than on actual queries. CPU was fine, memory was fine, but pg_stat_activity showed 200+ connections churning constantly. The fix took ten lines of code: add a connection pool.

Lesson 2: Diesel — The ORM approach

Tue, 22 Oct 2024 08:47:00 +0000

I was two weeks into a project where I had to write about 40 CRUD endpoints for an admin panel. Each one needed the same pattern: validate input, build a query, map results to a struct, handle errors. By endpoint number six, I was copy-pasting SQLx queries and changing column names. That’s when a colleague asked, “Why aren’t you using Diesel?”

He was right. Sometimes you don’t want to write SQL. Sometimes you want the boilerplate to disappear.

Lesson 1: SQLx — Compile-time checked queries

Sun, 20 Oct 2024 11:23:00 +0000

I shipped a typo in a SQL column name to production last year. The column was user_nme instead of user_name. The Go service compiled fine, the tests passed (they used mocks), and the bug sat in production for three hours before a customer reported it. Three hours of silent failures because the query returned zero rows instead of erroring out.

That was the day I started using SQLx in Rust. I haven’t shipped a SQL typo since.