db_conn_pool.go

package sqlwrapper

import (
	"context"
	"database/sql"

	"github.com/pkg/errors"
	"go.uber.org/multierr"
)

func OpenDBConnection(ctx context.Context, driverName, dsn string) (DBConnPool, error) {
	conn, err := sql.Open(driverName, dsn)
	if err != nil {
		return nil, errors.Wrap(err, "failed to open database connection")
	}

	if pingErr := conn.PingContext(ctx); pingErr != nil {
		return nil, errors.Wrap(err, "failed to ping database")
	}

	return &dbConnPool{
		connPool: conn,
	}, nil
}

type dbConnPool struct {
	connPool *sql.DB
}

func (p *dbConnPool) Close() error {
	return p.connPool.Close()
}

func (p *dbConnPool) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) {
	if opts == nil {
		opts = &sql.TxOptions{
			Isolation: sql.LevelDefault,
			ReadOnly:  false,
		}
	}

	txSql, err := p.connPool.BeginTx(ctx, opts)
	if err != nil {
		return nil, err
	}

	return &tx{txSql: txSql}, nil
}

func (p *dbConnPool) RunInTx(ctx context.Context, callback func(ctx context.Context, tx Tx) error) error {
	tx, err := p.BeginTx(ctx, &sql.TxOptions{
		Isolation: sql.LevelDefault,
		ReadOnly:  false,
	})
	if err != nil {
		return errors.Wrap(err, "failed to  begin transaction")
	}

	err = callback(ctx, tx)
	if err != nil {
		if rollbackErr := tx.Rollback(); rollbackErr != nil {
			return multierr.Combine(err, rollbackErr)
		}
		return err
	}

	if commitErr := tx.Commit(); commitErr != nil {
		return errors.Wrap(commitErr, "failed to  commit transaction")
	}

	return nil
}

func (p *dbConnPool) Exec(ctx context.Context, queryBuilder SQLBuilder) (sql.Result, error) {
	return exec(ctx, p.connPool, queryBuilder)
}

func (p *dbConnPool) Get(ctx context.Context, dest any, queryBuilder SQLBuilder) error {
	return get(ctx, p.connPool, dest, queryBuilder)
}

func (p *dbConnPool) GetOne(ctx context.Context, dest any, queryBuilder SQLBuilder) error {
	return getOne(ctx, p.connPool, dest, queryBuilder)
}

func (p *dbConnPool) ExecRaw(ctx context.Context, query string, args ...any) (sql.Result, error) {
	return execRaw(ctx, p.connPool, query, args...)
}
func (p *dbConnPool) GetRaw(ctx context.Context, dest any, query string, args ...any) error {
	return getRaw(ctx, p.connPool, dest, query, args...)
}
func (p *dbConnPool) GetOneRaw(ctx context.Context, dest any, query string, args ...any) error {
	return getOneRaw(ctx, p.connPool, dest, query, args...)
}