SQLC + pgx for Production

nellfs · January 27, 2026, 2:12pm

Hi folks,

I’ve been using GORM for 1/2 years, but I keep seeing some people in the community talking about SQLC + SQLX and how good it is, I’m using this space to ask your experiences with it

Also, what tool you folks use for migrations?

Karl · January 27, 2026, 4:29pm

I use SQLC and Goose.

Definetely Production ready. This does just help you with boiler plate.

Thus I do believe it is actually more production ready than gorm

Dean_Davidson · January 27, 2026, 5:01pm

I haven’t used them in production. But - I have a few thoughts. First off: I’m wondering why you would combine them? I generally want a few things to make my life easier when writing simple queries:

Queries to structs. Both SQLX and SQLC support this; though with SQLC you will need to add a select * from my_table to get it to generate the boilerplate. Also - pgx supports this without a 3rd party and I use that quite frequently.
Something to reduce boilerplate for simple CRUD operations. Again - both libraries support this.
Something to actually run my migrations and keep track of what was run. Neither libraries support this. I often roll my own because it’s honestly not rocket science. But there are many libraries out there for this.

Anyway, I’m wondering how you’re planning on combining them. They seem like two pretty opinionated tools that have similar goals.

Second: do we know how actively-maintained sqlx is? Check the repository out:

Last commit was 2 years ago. It seems the original maintainer is mostly gone. And there have been open pull requests hanging out for a while:

github.com/jmoiron/sqlx

Update reflectx to allow for optional nested structs

master ← geeeeeeeeek:master

opened 07:47PM - 01 Nov 23 UTC

geeeeeeeeek

+303 -5

Based on https://github.com/jmoiron/sqlx/pull/847, but fixed an issue that optio…nal pointer fields are not handled correctly. > Nested structs are now only instantiated when one of the database columns in that nested struct is not nil. This allows objects scanned in left/outer joins to keep their natural types (instead of setting everything to NullableX). > > Example: > > ```sql > select house.id, owner.*, > from house > left join owner on owner.id = house.owner > ``` > > ### Before > ```go > type House struct { > ID int > Owner *Person // if left join gives nulls, Owner is set > } > > type Owner struct { > ID sql.NullInt64 // make nullable columns even tho if table doesn't have those columns nullable > } > ``` > > ### After > ```go > type House struct { > ID int > Owner *Person // if left join gives nulls, Owner will be nil > } > > type Owner struct { > ID int // no need to set this to sql.NullInt > } > ```

Something to consider! And just trying to get a feel for how you’re planning on using these libraries.

All that having been said, gorm gets a lot of hate but it’s plenty fast for simple CRUD operations in my experience. And anytime I’m doing something advanced, I invariably end up writing my own hand-tuned queries. So - gorm for simple stuff hand-written SQL for hard stuff isn’t a terrible way to go.

Also - like I mentioned, I often just “start with pgx” and end up needing not much else. They added utility functions to scan to structs by name, etc.:

github.com/jackc/pgx

Does pgx support scanning into structs?

opened 08:25AM - 27 May 20 UTC

closed 07:47AM - 05 May 23 UTC

mrdulin

question

something like: https://godoc.org/github.com/jmoiron/sqlx#StructScan And stru…ct tags like this: ```go type TenantModule struct { Id string `db:"id"` Name string `db:"type"` Channels Channel `json:"channels"` } type Channel struct { Channels []string } ``` Or this: ```go type TenantModule struct { Id string `sql:"id"` Name string `sql:"type"` } ``` I didn't find any information on https://github.com/jackc/pgx/blob/master/query_test.go file and documentation. There are only examples which scan into the basic data type like `int`, `float` Please give an example of how to scan rows into a struct. Thanks

nellfs · January 27, 2026, 5:34pm

I actually meant SQLC + pgx, not sure why I wrote SQLX lol, I’ll update the title

That said, I will give SQLC a try, with Goose for migrations, thank you folks @Karl @Dean_Davidson

Dean_Davidson · January 27, 2026, 7:40pm

Ahhh. That makes sense! Yeah - pgx is great and a no-brainer IMO. Especially if you need to do bulk imports of data (it supports COPY).

I’ve used goose. It’s OK. I generally prefer to use config files/env vars and it previously didn’t support that (it does now). Also - it’s supported by sqlc:

Karl · January 27, 2026, 8:39pm

I mean I do not see any reason why SQL should be outdated soon.
This is constant since many years.

you can run savely a relatively old db version as well. Especially if you do not expose it directly.

What should change and break?

Even if you have an extreme edge case where your SQLC does not work. - Which is highly unlikely, then you have to write that one query by hand.

Dean_Davidson · January 28, 2026, 12:44am

Karl, I was noting that SQLX seems to not be actively maintained, not SQLC.