pgx VS sqlx

The way it parses dates using Unix time causes issues when you compare the values returned due to Go setting the location property:

https://github.com/jackc/pgx/issues/863

pgx doesn't seem to handle reconnects the same way lib/pg does, but I haven't tested this recently: https://github.com/jackc/pgx/issues/672

String manipulation could lead to nasty SQL injections and really because you're using pgx there's no need to do that either, see the Conn.SendBatch method, it should allow you to achieve what you're trying to do: execute multiple queries in a transaction and still get their results. (test example)

pgx

In the process of trying to get better with Go, I have been trying to create a program that will scrape a subreddit and then save some info into a Postgres table. In this case, I decided to use r/frugalmalefashion and save the title and flair of recent posts into the table. I am using Colly to scrape data, and pgx as the database driver.

Connecting from my golang app via pgx database driver inside Docker (Alpine linux image) on my windows dev system: < 1s -> fast

> What kind of language recommends[0] with a straight face that you just duplicate your entire codebase into a v2/ subdirectory?

Not Go at least. You misunderstood the post completely.

Here is an example of how you are supposed to change the import path for subsequent major versions (that is, backwards incompatible versions): https://github.com/jackc/pgx/blob/3599f646293c1b0d381214ab26...

A one-line change to your modfile and the import path is changed.

Pass on the frameworks at first. just use the std library's net/http package and maybe a really basic router like julien schmidt's httprouter(https://github.com/julienschmidt/httprouter) to do your requests and use pgx(https://github.com/jackc/pgx) for postrgres.

postgres in go I've mostly seen done with pgx which kind of skates around the typical database/sql method. It's better maintained and faster than the more 'official' postgres driver, but I kind of hated using it.

In this article let's try to create closer to real world CQRS microservices with tracing and monitoring using: 🚀 Kafka as messages broker gRPC Go implementation of gRPC PostgreSQL as database Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus MongoDB Web and API based SMTP testing Redis Type-safe Redis client for Golang swag Swagger for Go Echo web framework

There are ORMs available for Golang, but my experience has been better with packages like sqlx [1] or dat [2]. We've since been using SQLX for pretty much all DBMS related work, and regret nothing. In my experience SQLX gave us the right balance between abstraction and control.

[1] http://jmoiron.github.io/sqlx/

[2] https://github.com/mgutz/dat

Line 44 in: https://github.com/jmoiron/sqlx/blob/a1d5e64734233358bc4e0a54beddc18509071a95/reflectx/reflect_test.go

Say we want to insert the following data using INSERT query to a mysql database - say SampleDatabase (using sqlx - https://github.com/jmoiron/sqlx) type Sample struct { A int64 B string Data interface{} } Data can be type C struct{} or type D struct{} or nil type C struct{} and type D struct{} have fields defined within them like type C struct{ E int64 F string }

sqlx which make working with database painless. It's really vital for my job since as an ordinary developer my jobs often revolved on creating CRUD apps. It also uses SQL query, so I don't have to learn any ORMs.

Maybe most efficient guide: http://jmoiron.github.io/sqlx/

https://github.com/jmoiron/sqlx : Great extension of the standard database/sql package, but 100% compatible with it

For the simplest of operations, like just writing stuff to your DB and then retrieving it again, they work a charm. Especially in Go, the ability to automatically marshal things into structs is a blessing.

BUT, then you try to start doing things with many2many relationships, or retrieving sorted data in a very specific, nested query and things to sideways quickly.

I ended up finding it much harder to try to figure out how to do some pretty obvious things. Endless hours on Stackoverflow fighting the ORM and its shockingly bad documentation...

Eventually I just bit the bullet and learned how to write Postgres queries, along with a small Go library called sqlx (https://jmoiron.github.io/sqlx/) which massively outperformed GORM (https://medium.com/@rocketlaunchr.cloud/how-to-benchmark-dbq...) and it's much more straight forward to reason about the relationship between my application layer and the DB.

One of the things I remember was differences in NULL/empty handling of SQL values between Python (Peewee) and Go. I didn't use an ORM on the Go side, just straight database/sql. If doing it again today I'd probably still avoid an ORM in Go, but I might use sqlx as it makes unpacking into structs much simpler.