How to Implement the Unit of Work Pattern in Go

Implement the Unit of Work pattern in Go by creating an interface to track changes and a struct to manage a single database transaction for atomic commits.

Implement the Unit of Work pattern in Go by defining an interface for tracking changes and a concrete struct that manages a transactional context.

package repository

type UnitOfWork interface {
    Commit() error
    Rollback() error
    Save(entity Entity) error
}

type unitOfWork struct {
    db *sql.DB
    tx *sql.Tx
    changes []Entity
}

func NewUnitOfWork(db *sql.DB) UnitOfWork {
    return &unitOfWork{db: db}
}

func (u *unitOfWork) Save(entity Entity) error {
    u.changes = append(u.changes, entity)
    return nil
}

func (u *unitOfWork) Commit() error {
    if u.tx == nil {
        var err error
        u.tx, err = u.db.Begin()
        if err != nil { return err }
    }
    for _, e := range u.changes {
        if err := e.Save(u.tx); err != nil { return err }
    }
    return u.tx.Commit()
}

func (u *unitOfWork) Rollback() error {
    if u.tx != nil { return u.tx.Rollback() }
    return nil
}

The Unit of Work pattern acts like a shopping cart for database changes, collecting all your updates in memory before saving them all at once. It ensures that either every change succeeds together or none of them happen, preventing partial data updates. You use it when you need to perform multiple related database operations that must be treated as a single atomic transaction.