Should I rollback a transaction with only COPY inside? - postgresql

Question

I use postgres COPY in my Go backend. Copy is the only operation inside transaction. Should I roll it back if it failed?
func (pc *Postgres) Copy(records [][]interface{}) error {
tx, err := pc.db.Begin()
if err != nil {
return errors.Wrap(err, "can't open transaction")
}
stmt, err := tx.Prepare(pq.CopyIn(pc.table, pc.columns...))
if err != nil {
return errors.Wrap(err, "can't prepare stmt")
}
for _, record := range records {
if _, err := stmt.Exec(record...); err != nil {
return errors.Wrap(err, "error exec record")
}
}
if _, err = stmt.Exec(); err != nil {
return errors.Wrap(err, "error exec stmt")
}
if err = stmt.Close(); err != nil {
return errors.Wrap(err, "error close stmt")
}
if err = tx.Commit(); err != nil {
return errors.Wrap(err, "error commit transaction")
}
return nil
}
As far as I understand if \copy fails transaction will be aborted(link) and rolled back.
However in officials lib/pq examples I see they always use rollback(but they have more than one operation).
Could somebody please guide me through these nuances?

Answer 1

It looks like part of the confusion is because \COPY is not the same thing as COPY.
\COPY (as referenced in this question) is a command in psql that "Performs a frontend (client) copy". In simple terms you run psql (a terminal-based front-end to PostgreSQL) on a computer and can \COPY data between the database and a file stored locally (or accessible from your machine). This command is part of psql and not something you can use via lib/pq.
COPY is a Postgres SQL command that runs on the server; the file you are copying "must be accessible by PostgreSQL user (the user ID the server runs as) and the name must be specified from the viewpoint of the server". This is what you are calling in your application (from the pq docs "CopyIn uses COPY FROM internally" implementation here and here)
So, as the answer referenced by #mh-cbon states:
the deferred rollback is there to ensure that the transaction is rolled back in case of an early return.
Consider:
tx, err := pc.db.Begin()
if err != nil {
return errors.Wrap(err, "can't open transaction")
}
stmt, err := tx.Prepare(pq.CopyIn(pc.table, pc.columns...))
if err != nil {
return errors.Wrap(err, "can't prepare stmt")
}
If the Prepare fails you have created a transaction and then return without closing it; this leaves the transaction open which is not a good thing. Adding a defer tx.Rollback() ensures that does not happen.