Go: ефективна робота з SQL

package migrations

import (
	"database/sql"
	"github.com/pressly/goose"
)

func init() {
	goose.AddMigration(upYaawsInit, downYaawsInit)
}

func upYaawsInit(tx *sql.Tx) error {
	// This code is executed when the migration is applied.
	return nil
}

func downYaawsInit(tx *sql.Tx) error {
	// This code is executed when the migration is rolled back.
	return nil
}

const (
	CmdExec       = ":exec"
	CmdExecResult = ":execresult"
	CmdExecRows   = ":execrows"
	CmdMany       = ":many"
	CmdOne        = ":one"
)

// Code generated by sqlc. DO NOT EDIT.

package dbs

import (
	"context"
	"database/sql"
)

type DBTX interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	PrepareContext(context.Context, string) (*sql.Stmt, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

func New(db DBTX) *Queries {
	return &Queries{db: db}
}

type Queries struct {
	db DBTX
}

func (q *Queries) WithTx(tx *sql.Tx) *Queries {
	return &Queries{
		db: tx,
	}
}

// Code generated by sqlc. DO NOT EDIT.

package dbs

import (
	"time"
)

type User struct {
	ID       int32
	Username string
	Created  time.Time
}

// Code generated by sqlc. DO NOT EDIT.
// source: users.sql

package dbs

import (
	"context"
	"time"
)

const userGetByID = `-- name: UserGetByID :one
SELECT id, username, created
FROM users
WHERE id = $1
`

func (q *Queries) UserGetByID(ctx context.Context, id int32) (User, error) {
	row := q.db.QueryRowContext(ctx, userGetByID, id)
	var i User
	err := row.Scan(&i.ID, &i.Username, &i.Created)
	return i, err
}

const userNew = `-- name: UserNew :exec
INSERT INTO users (username, created)
VALUES ($1, $2)
`

type UserNewParams struct {
	Username string
	Created  time.Time
}

func (q *Queries) UserNew(ctx context.Context, arg UserNewParams) error {
	_, err := q.db.ExecContext(ctx, userNew, arg.Username, arg.Created)
	return err
}

const userNewAndGet = `-- name: UserNewAndGet :one
INSERT INTO users (username, created)
VALUES ($1, $2)
RETURNING id, username, created
`

type UserNewAndGetParams struct {
	Username string
	Created  time.Time
}

func (q *Queries) UserNewAndGet(ctx context.Context, arg UserNewAndGetParams) (User, error) {
	row := q.db.QueryRowContext(ctx, userNewAndGet, arg.Username, arg.Created)
	var i User
	err := row.Scan(&i.ID, &i.Username, &i.Created)
	return i, err
}

const users = `-- name: Users :many
SELECT id, username, created
FROM users
LIMIT $2 OFFSET $1
`

type UsersParams struct {
	SqlOffset int32
	SqlLimit  int32
}

func (q *Queries) Users(ctx context.Context, arg UsersParams) ([]User, error) {
	rows, err := q.db.QueryContext(ctx, users, arg.SqlOffset, arg.SqlLimit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(&i.ID, &i.Username, &i.Created); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const usersCount = `-- name: UsersCount :one
SELECT COUNT(*) FROM users
`

func (q *Queries) UsersCount(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, usersCount)
	var count int64
	err := row.Scan(&count)
	return count, err
}

package tests

import (
	"context"
	"database/sql"
	_ "github.com/lib/pq"
	"github.com/stretchr/testify/require"
	"gitlab.com/go-yp/go-sqlc-example/storage/dbs"
	"testing"
	"time"
)

const (
	dataSourceName = "postgresql://yaroslav:[email protected]:5432/yaaws?sslmode=disable&timezone=UTC"
)

func TestUsers(t *testing.T) {
	connection, err := sql.Open("postgres", dataSourceName)
	require.NoError(t, err)
	defer connection.Close()

	require.NoError(t, connection.Ping())

	// clear users
	{
		const (
			// language=PostgreSQL
			query = "TRUNCATE TABLE users RESTART IDENTITY CASCADE"
		)

		_, err := connection.Exec(query)
		require.NoError(t, err)
	}

	var queries = dbs.New(connection)

	// db.go
	_ = queries.WithTx

	// models.go
	var _ dbs.User

	// users.sql.go
	_ = queries.UserNew
	_ = queries.UserNewAndGet
	_ = queries.UserGetByID
	_ = queries.UsersCount
	_ = queries.Users

	var ctx = context.Background()

	{
		count, err := queries.UsersCount(ctx)
		require.NoError(t, err)
		require.Equal(t, int64(0), count)
	}

	var now = time.Now().UTC().Truncate(time.Second)

	var (
		expected = dbs.User{
			ID:       1,
			Username: "System",
			Created:  now,
		}
	)

	// create
	{
		actual, err := queries.UserNewAndGet(ctx, dbs.UserNewAndGetParams{
			Username: "System",
			Created:  now,
		})

		require.NoError(t, err)
		require.Equal(t, expected, actual)
	}

	// get by id
	{

		actual, err := queries.UserGetByID(ctx, 1)
		require.NoError(t, err)
		require.Equal(t, expected, actual)
	}

	// get count
	{
		count, err := queries.UsersCount(ctx)
		require.NoError(t, err)
		require.Equal(t, int64(1), count)
	}

	// get users
	{
		users, err := queries.Users(ctx, dbs.UsersParams{
			SqlOffset: 0,
			SqlLimit:  32,
		})
		require.NoError(t, err)
		require.Equal(t, []dbs.User{expected}, users)
	}
}

// Code generated by sqlc. DO NOT EDIT.

package dbs

import (
	"context"
	"database/sql"
)

type DBTX interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	PrepareContext(context.Context, string) (*sql.Stmt, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

func New(db DBTX) *Queries {
	return &Queries{db: db}
}

type Queries struct {
	db DBTX
}

func TestTransaction(t *testing.T) {
	connection, err := sql.Open("postgres", dataSourceName)
	require.NoError(t, err)
	defer connection.Close()

	{
		require.NoError(t, connection.Ping())

		var queries = dbs.New(connection)

		count, err := queries.UsersCount(context.Background())
		require.NoError(t, err)
		require.Equal(t, int64(1), count)
	}

	{
		tx, err := connection.Begin()
		require.NoError(t, err)
		defer func() {
			require.NoError(t, tx.Rollback())
		}()

		var queries = dbs.New(tx)

		count, err := queries.UsersCount(context.Background())
		require.NoError(t, err)
		require.Equal(t, int64(1), count)
	}
}

func WithTransaction(db *sql.DB, fn func(queries *dbs.Queries) error) (err error) {
	tx, err := db.Begin()
	if err != nil {
		return
	}

	defer func() {
		if p := recover(); p != nil {
			// a panic occurred, rollback and repanic
			tx.Rollback()
			panic(p)
		} else if err != nil {
			// something went wrong, rollback
			tx.Rollback()
		} else {
			// all good, commit
			err = tx.Commit()
		}
	}()

	err = fn(dbs.New(tx))
	return err
}