Database Go Modern

import "github.com/jackc/pgx/v5/pgxpool"

func buatPool(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
    cfg, err := pgxpool.ParseConfig(dsn)
    if err != nil {
        return nil, err
    }

    cfg.MaxConns        = 25
    cfg.MinConns        = 5
    cfg.MaxConnLifetime = 30 * time.Minute
    cfg.MaxConnIdleTime = 5 * time.Minute
    cfg.HealthCheckPeriod = 1 * time.Minute

    pool, err := pgxpool.NewWithConfig(ctx, cfg)
    if err != nil {
        return nil, err
    }
    if err := pool.Ping(ctx); err != nil {
        return nil, fmt.Errorf("ping database: %w", err)
    }
    return pool, nil
}

// Satu baris
var p Pesanan
err := pool.QueryRow(ctx,
    "SELECT id, total, status FROM pesanan WHERE id = $1", id,
).Scan(&p.ID, &p.Total, &p.Status)

if errors.Is(err, pgx.ErrNoRows) {
    return nil, ErrTidakDitemukan
}

// Banyak baris dengan pemindaian otomatis ke struct
baris, err := pool.Query(ctx,
    "SELECT id, total, status FROM pesanan WHERE pengguna_id = $1", uid)
if err != nil {
    return nil, err
}
pesanan, err := pgx.CollectRows(baris, pgx.RowToStructByName[Pesanan])

// Tipe PostgreSQL yang ditangani langsung
var tag []string                    // text[]
var meta map[string]any             // jsonb
err = pool.QueryRow(ctx,
    "SELECT tag, metadata FROM produk WHERE id = $1", pid,
).Scan(&tag, &meta)

_, err := pool.Exec(ctx,
    "INSERT INTO pengguna (email) VALUES ($1)", email)

var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
    switch pgErr.Code {
    case "23505":   // unique_violation
        return ErrEmailSudahDipakai
    case "23503":   // foreign_key_violation
        return ErrReferensiTidakSah
    case "23514":   // check_violation
        return ErrMelanggarAturan
    case "40001":   // serialization_failure
        return ErrCobaLagi     // aman untuk diulang
    case "40P01":   // deadlock_detected
        return ErrCobaLagi
    }
}

func (r *Repo) BuatPesanan(ctx context.Context, p Pesanan) error {
    tx, err := r.pool.BeginTx(ctx, pgx.TxOptions{
        IsoLevel: pgx.ReadCommitted,
    })
    if err != nil {
        return err
    }
    // Aman dipanggil setelah Commit -- akan diabaikan
    defer tx.Rollback(ctx)

    var idPesanan string
    err = tx.QueryRow(ctx,
        "INSERT INTO pesanan (pengguna_id, total) VALUES ($1,$2) RETURNING id",
        p.PenggunaID, p.Total,
    ).Scan(&idPesanan)
    if err != nil {
        return fmt.Errorf("sisipkan pesanan: %w", err)
    }

    for _, it := range p.Item {
        _, err = tx.Exec(ctx,
            "UPDATE stok SET jumlah = jumlah - $1 WHERE produk_id = $2 AND jumlah >= $1",
            it.Jumlah, it.ProdukID)
        if err != nil {
            return fmt.Errorf("kurangi stok: %w", err)
        }
    }

    return tx.Commit(ctx)
}

batch := &pgx.Batch{}
for _, it := range item {
    batch.Queue("INSERT INTO item_pesanan (pesanan_id, produk_id, jumlah) VALUES ($1,$2,$3)",
        idPesanan, it.ProdukID, it.Jumlah)
}

hasil := tx.SendBatch(ctx, batch)
defer hasil.Close()

for range item {
    if _, err := hasil.Exec(); err != nil {
        return err
    }
}

jumlah, err := pool.CopyFrom(ctx,
    pgx.Identifier{"item_pesanan"},
    []string{"pesanan_id", "produk_id", "jumlah"},
    pgx.CopyFromSlice(len(item), func(i int) ([]any, error) {
        return []any{idPesanan, item[i].ProdukID, item[i].Jumlah}, nil
    }),
)
// Untuk 100 ribu baris, COPY bisa puluhan kali lebih cepat
// daripada INSERT satu per satu.

stat := pool.Stat()
slog.Info("statistik pool",
    "total",          stat.TotalConns(),
    "menganggur",     stat.IdleConns(),
    "digunakan",      stat.AcquiredConns(),
    "menunggu",       stat.EmptyAcquireCount(),
    "durasi_tunggu",  stat.AcquireDuration())

proyek/
├── sqlc.yaml
├── db/
│   ├── skema/
│   │   └── 001_awal.sql          <-- definisi tabel
│   ├── kueri/
│   │   └── pesanan.sql           <-- kueri yang Anda tulis
│   └── gen/                      <-- hasil bangkitan, JANGAN disunting
│       ├── db.go
│       ├── models.go
│       └── pesanan.sql.go

version: "2"
sql:
  - engine: "postgresql"
    schema: "db/skema"
    queries: "db/kueri"
    gen:
      go:
        package: "gen"
        out: "db/gen"
        sql_package: "pgx/v5"
        emit_json_tags: true
        emit_pointers_for_null_types: true
        emit_interface: true          # untuk memudahkan pembuatan mock

-- name: AmbilPesanan :one
SELECT * FROM pesanan WHERE id = $1;

-- name: DaftarPesananPengguna :many
SELECT * FROM pesanan
WHERE pengguna_id = $1
ORDER BY dibuat_pada DESC
LIMIT $2 OFFSET $3;

-- name: BuatPesanan :one
INSERT INTO pesanan (pengguna_id, total, status)
VALUES ($1, $2, $3)
RETURNING *;

-- name: PerbaruiStatus :exec
UPDATE pesanan SET status = $2, diubah_pada = now()
WHERE id = $1;

-- name: HitungPerStatus :many
SELECT status, COUNT(*) AS jumlah
FROM pesanan
WHERE dibuat_pada >= $1
GROUP BY status;

-- name: PesananDenganItem :many
SELECT
  p.id, p.total, p.status,
  i.produk_id, i.jumlah, i.harga
FROM pesanan p
JOIN item_pesanan i ON i.pesanan_id = p.id
WHERE p.pengguna_id = $1;

// db/gen/pesanan.sql.go -- dibangkitkan otomatis

type BuatPesananParams struct {
    PenggunaID int64       `json:"pengguna_id"`
    Total      int64       `json:"total"`
    Status     StatusPesanan `json:"status"`
}

func (q *Queries) BuatPesanan(ctx context.Context, arg BuatPesananParams) (Pesanan, error) {
    baris := q.db.QueryRow(ctx, buatPesanan, arg.PenggunaID, arg.Total, arg.Status)
    var i Pesanan
    err := baris.Scan(&i.ID, &i.PenggunaID, &i.Total, &i.Status, &i.DibuatPada)
    return i, err
}

kueri := gen.New(pool)

p, err := kueri.BuatPesanan(ctx, gen.BuatPesananParams{
    PenggunaID: 55,
    Total:      250000,
    Status:     gen.StatusPesananMenunggu,
})
// p bertipe gen.Pesanan -- sepenuhnya aman tipe.
// Salah ketik nama field ditangkap compiler.

func (s *Layanan) BuatPesananLengkap(ctx context.Context, req Request) error {
    tx, err := s.pool.Begin(ctx)
    if err != nil {
        return err
    }
    defer tx.Rollback(ctx)

    // Ikat Queries ke transaksi ini
    q := s.kueri.WithTx(tx)

    p, err := q.BuatPesanan(ctx, gen.BuatPesananParams{...})
    if err != nil {
        return err
    }

    for _, it := range req.Item {
        if err := q.TambahItem(ctx, gen.TambahItemParams{
            PesananID: p.ID,
            ProdukID:  it.ProdukID,
            Jumlah:    it.Jumlah,
        }); err != nil {
            return err
        }
    }

    return tx.Commit(ctx)
}

// Dengan ORM -- terlihat tak berbahaya, padahal 101 kueri
var pesanan []Pesanan
db.Find(&pesanan)                    // 1 kueri
for _, p := range pesanan {
    db.Model(&p).Related(&p.Item)    // 100 kueri lagi!
}

// Dengan sqlc -- Anda MELIHAT SQL-nya, jadi masalahnya kentara
// name: PesananDenganItem :many
SELECT p.*, i.* FROM pesanan p
JOIN item_pesanan i ON i.pesanan_id = p.id
WHERE p.pengguna_id = $1;            // 1 kueri saja