package main
 
import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "time"
 
    _ "github.com/lib/pq"
)
 
func main() {
    // sql.Open はコネクションプールを初期化するが、実際の接続は行わない
    db, err := sql.Open("postgres", "postgres://user:pass@localhost/mydb?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
 
    // 接続プール設定（本番環境では必ず設定する）
    db.SetMaxOpenConns(25)              // 最大同時接続数
    db.SetMaxIdleConns(5)               // アイドル接続の最大数
    db.SetConnMaxLifetime(5 * time.Minute) // 接続の最大生存時間
    db.SetConnMaxIdleTime(1 * time.Minute) // アイドル接続の最大生存時間
 
    // Ping で実際の接続を確認
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
 
    if err := db.PingContext(ctx); err != nil {
        log.Fatal("DB接続失敗:", err)
    }
 
    fmt.Println("DB接続成功")
}

package database
 
import (
    "database/sql"
    "fmt"
    "net/url"
 
    _ "github.com/go-sql-driver/mysql" // MySQL
    _ "github.com/lib/pq"              // PostgreSQL
    _ "github.com/mattn/go-sqlite3"    // SQLite
    _ "modernc.org/sqlite"             // SQLite (CGO不要)
)
 
// Config はDB接続設定を表す
type Config struct {
    Driver   string
    Host     string
    Port     int
    User     string
    Password string
    DBName   string
    SSLMode  string
    Params   map[string]string
}
 
// DSN はドライバごとのDSN文字列を生成する
func (c *Config) DSN() string {
    switch c.Driver {
    case "postgres":
        return fmt.Sprintf(
            "postgres://%s:%s@%s:%d/%s?sslmode=%s",
            url.QueryEscape(c.User),
            url.QueryEscape(c.Password),
            c.Host, c.Port, c.DBName, c.SSLMode,
        )
    case "mysql":
        // user:password@tcp(host:port)/dbname?param=value
        return fmt.Sprintf(
            "%s:%s@tcp(%s:%d)/%s?parseTime=true&loc=Asia%%2FTokyo",
            c.User, c.Password, c.Host, c.Port, c.DBName,
        )
    case "sqlite3", "sqlite":
        return c.DBName // ファイルパスまたは ":memory:"
    default:
        panic("unsupported driver: " + c.Driver)
    }
}
 
// Open はDB接続プールを初期化する
func Open(cfg Config) (*sql.DB, error) {
    db, err := sql.Open(cfg.Driver, cfg.DSN())
    if err != nil {
        return nil, fmt.Errorf("sql.Open: %w", err)
    }
 
    // ドライバに応じたプール設定
    switch cfg.Driver {
    case "postgres", "mysql":
        db.SetMaxOpenConns(25)
        db.SetMaxIdleConns(5)
        db.SetConnMaxLifetime(5 * time.Minute)
    case "sqlite3", "sqlite":
        // SQLiteは単一接続推奨
        db.SetMaxOpenConns(1)
    }
 
    return db, nil
}

package repository
 
import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "time"
)
 
// User はユーザーエンティティを表す
type User struct {
    ID        int64
    Name      string
    Email     string
    CreatedAt time.Time
    UpdatedAt time.Time
}
 
// ErrNotFound はリソースが見つからない場合のエラー
var ErrNotFound = errors.New("resource not found")
 
// UserRepository はユーザーデータへのアクセスを提供する
type UserRepository struct {
    db *sql.DB
}
 
// NewUserRepository は新しいUserRepositoryを作成する
func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}
 
// GetByID は指定IDのユーザーを取得する
func (r *UserRepository) GetByID(ctx context.Context, id int64) (*User, error) {
    var u User
    err := r.db.QueryRowContext(ctx,
        `SELECT id, name, email, created_at, updated_at
         FROM users WHERE id = $1`, id,
    ).Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)
 
    if errors.Is(err, sql.ErrNoRows) {
        return nil, fmt.Errorf("user id=%d: %w", id, ErrNotFound)
    }
    if err != nil {
        return nil, fmt.Errorf("GetByID(%d): %w", id, err)
    }
    return &u, nil
}
 
// GetByEmail はメールアドレスでユーザーを検索する
func (r *UserRepository) GetByEmail(ctx context.Context, email string) (*User, error) {
    var u User
    err := r.db.QueryRowContext(ctx,
        `SELECT id, name, email, created_at, updated_at
         FROM users WHERE email = $1`, email,
    ).Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)
 
    if errors.Is(err, sql.ErrNoRows) {
        return nil, fmt.Errorf("user email=%s: %w", email, ErrNotFound)
    }
    if err != nil {
        return nil, fmt.Errorf("GetByEmail(%s): %w", email, err)
    }
    return &u, nil
}
 
// List は全ユーザーを取得する（ページネーション付き）
func (r *UserRepository) List(ctx context.Context, limit, offset int) ([]User, error) {
    rows, err := r.db.QueryContext(ctx,
        `SELECT id, name, email, created_at, updated_at
         FROM users
         ORDER BY id
         LIMIT $1 OFFSET $2`, limit, offset,
    )
    if err != nil {
        return nil, fmt.Errorf("List: %w", err)
    }
    defer rows.Close()
 
    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt); err != nil {
            return nil, fmt.Errorf("List scan: %w", err)
        }
        users = append(users, u)
    }
    // rows.Err() で反復中のエラーを確認する（重要）
    if err := rows.Err(); err != nil {
        return nil, fmt.Errorf("List rows: %w", err)
    }
    return users, nil
}
 
// Search はキーワードでユーザーを検索する
func (r *UserRepository) Search(ctx context.Context, keyword string) ([]User, error) {
    // LIKE検索のワイルドカードをエスケープ
    escapedKeyword := "%" + keyword + "%"
 
    rows, err := r.db.QueryContext(ctx,
        `SELECT id, name, email, created_at, updated_at
         FROM users
         WHERE name ILIKE $1 OR email ILIKE $1
         ORDER BY name`, escapedKeyword,
    )
    if err != nil {
        return nil, fmt.Errorf("Search: %w", err)
    }
    defer rows.Close()
 
    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt); err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, rows.Err()
}
 
// Create は新しいユーザーを作成する
func (r *UserRepository) Create(ctx context.Context, u *User) error {
    err := r.db.QueryRowContext(ctx,
        `INSERT INTO users (name, email, created_at, updated_at)
         VALUES ($1, $2, NOW(), NOW())
         RETURNING id, created_at, updated_at`,
        u.Name, u.Email,
    ).Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt)
 
    if err != nil {
        return fmt.Errorf("Create user: %w", err)
    }
    return nil
}
 
// Update は既存ユーザーを更新する
func (r *UserRepository) Update(ctx context.Context, u *User) error {
    result, err := r.db.ExecContext(ctx,
        `UPDATE users SET name = $1, email = $2, updated_at = NOW()
         WHERE id = $3`,
        u.Name, u.Email, u.ID,
    )
    if err != nil {
        return fmt.Errorf("Update user: %w", err)
    }
 
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("Update RowsAffected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("user id=%d: %w", u.ID, ErrNotFound)
    }
    return nil
}
 
// Delete はユーザーを削除する
func (r *UserRepository) Delete(ctx context.Context, id int64) error {
    result, err := r.db.ExecContext(ctx,
        `DELETE FROM users WHERE id = $1`, id,
    )
    if err != nil {
        return fmt.Errorf("Delete user: %w", err)
    }
 
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("Delete RowsAffected: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("user id=%d: %w", id, ErrNotFound)
    }
    return nil
}
 
// BulkCreate は複数ユーザーを一括作成する
func (r *UserRepository) BulkCreate(ctx context.Context, users []User) error {
    // 大量データの場合は COPY プロトコルが高速だが、
    // ここでは INSERT ... VALUES の複数行挿入を使う
    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return fmt.Errorf("BulkCreate begin: %w", err)
    }
    defer tx.Rollback()
 
    stmt, err := tx.PrepareContext(ctx,
        `INSERT INTO users (name, email, created_at, updated_at)
         VALUES ($1, $2, NOW(), NOW())
         RETURNING id`)
    if err != nil {
        return fmt.Errorf("BulkCreate prepare: %w", err)
    }
    defer stmt.Close()
 
    for i := range users {
        err := stmt.QueryRowContext(ctx, users[i].Name, users[i].Email).Scan(&users[i].ID)
        if err != nil {
            return fmt.Errorf("BulkCreate insert %d: %w", i, err)
        }
    }
 
    return tx.Commit()
}

package repository
 
import (
    "context"
    "database/sql"
    "fmt"
)
 
// PreparedUserRepository はPrepared Statementを使ったリポジトリ
type PreparedUserRepository struct {
    db         *sql.DB
    stmtGetByID *sql.Stmt
    stmtList    *sql.Stmt
    stmtCreate  *sql.Stmt
    stmtUpdate  *sql.Stmt
    stmtDelete  *sql.Stmt
}
 
// NewPreparedUserRepository は事前にステートメントを準備する
func NewPreparedUserRepository(ctx context.Context, db *sql.DB) (*PreparedUserRepository, error) {
    r := &PreparedUserRepository{db: db}
    var err error
 
    r.stmtGetByID, err = db.PrepareContext(ctx,
        `SELECT id, name, email, created_at, updated_at FROM users WHERE id = $1`)
    if err != nil {
        return nil, fmt.Errorf("prepare GetByID: %w", err)
    }
 
    r.stmtList, err = db.PrepareContext(ctx,
        `SELECT id, name, email, created_at, updated_at FROM users ORDER BY id LIMIT $1 OFFSET $2`)
    if err != nil {
        return nil, fmt.Errorf("prepare List: %w", err)
    }
 
    r.stmtCreate, err = db.PrepareContext(ctx,
        `INSERT INTO users (name, email, created_at, updated_at)
         VALUES ($1, $2, NOW(), NOW()) RETURNING id, created_at, updated_at`)
    if err != nil {
        return nil, fmt.Errorf("prepare Create: %w", err)
    }
 
    r.stmtUpdate, err = db.PrepareContext(ctx,
        `UPDATE users SET name = $1, email = $2, updated_at = NOW() WHERE id = $3`)
    if err != nil {
        return nil, fmt.Errorf("prepare Update: %w", err)
    }
 
    r.stmtDelete, err = db.PrepareContext(ctx,
        `DELETE FROM users WHERE id = $1`)
    if err != nil {
        return nil, fmt.Errorf("prepare Delete: %w", err)
    }
 
    return r, nil
}
 
// Close はすべてのPrepared Statementを閉じる
func (r *PreparedUserRepository) Close() error {
    stmts := []*sql.Stmt{r.stmtGetByID, r.stmtList, r.stmtCreate, r.stmtUpdate, r.stmtDelete}
    for _, stmt := range stmts {
        if stmt != nil {
            stmt.Close()
        }
    }
    return nil
}
 
// GetByID はPrepared Statementを使って高速にユーザーを取得する
func (r *PreparedUserRepository) GetByID(ctx context.Context, id int64) (*User, error) {
    var u User
    err := r.stmtGetByID.QueryRowContext(ctx, id).
        Scan(&u.ID, &u.Name, &u.Email, &u.CreatedAt, &u.UpdatedAt)
    if err != nil {
        return nil, err
    }
    return &u, nil
}

package service
 
import (
    "context"
    "database/sql"
    "fmt"
)
 
// TxFunc はトランザクション内で実行する関数の型
type TxFunc func(tx *sql.Tx) error
 
// WithTransaction はトランザクション管理のヘルパー関数
// パニックからの回復、ロールバック、コミットを自動処理する
func WithTransaction(ctx context.Context, db *sql.DB, opts *sql.TxOptions, fn TxFunc) error {
    tx, err := db.BeginTx(ctx, opts)
    if err != nil {
        return fmt.Errorf("begin transaction: %w", err)
    }
 
    defer func() {
        if p := recover(); p != nil {
            // パニック時もロールバック
            _ = tx.Rollback()
            panic(p) // リパニック
        }
    }()
 
    if err := fn(tx); err != nil {
        if rbErr := tx.Rollback(); rbErr != nil {
            return fmt.Errorf("rollback failed: %v (original: %w)", rbErr, err)
        }
        return err
    }
 
    if err := tx.Commit(); err != nil {
        return fmt.Errorf("commit: %w", err)
    }
    return nil
}
 
// 使用例: 送金処理
func (s *AccountService) Transfer(ctx context.Context, fromID, toID int64, amount float64) error {
    return WithTransaction(ctx, s.db, &sql.TxOptions{
        Isolation: sql.LevelSerializable,
    }, func(tx *sql.Tx) error {
        // 送金元の残高確認
        var balance float64
        err := tx.QueryRowContext(ctx,
            "SELECT balance FROM accounts WHERE id = $1 FOR UPDATE", fromID,
        ).Scan(&balance)
        if err != nil {
            return fmt.Errorf("get balance: %w", err)
        }
 
        if balance < amount {
            return fmt.Errorf("insufficient funds: balance=%.2f, amount=%.2f", balance, amount)
        }
 
        // 送金元の引き落とし
        _, err = tx.ExecContext(ctx,
            "UPDATE accounts SET balance = balance - $1, updated_at = NOW() WHERE id = $2",
            amount, fromID)
        if err != nil {
            return fmt.Errorf("debit: %w", err)
        }
 
        // 送金先への入金
        _, err = tx.ExecContext(ctx,
            "UPDATE accounts SET balance = balance + $1, updated_at = NOW() WHERE id = $2",
            amount, toID)
        if err != nil {
            return fmt.Errorf("credit: %w", err)
        }
 
        // 取引履歴の記録
        _, err = tx.ExecContext(ctx,
            `INSERT INTO transactions (from_account_id, to_account_id, amount, created_at)
             VALUES ($1, $2, $3, NOW())`, fromID, toID, amount)
        if err != nil {
            return fmt.Errorf("record transaction: %w", err)
        }
 
        return nil
    })
}
 
// ReadOnlyTransaction は読み取り専用トランザクション
func ReadOnlyTransaction(ctx context.Context, db *sql.DB, fn TxFunc) error {
    return WithTransaction(ctx, db, &sql.TxOptions{
        ReadOnly: true,
    }, fn)
}
 
// トランザクション分離レベルの使い分け
// sql.LevelDefault          - ドライバのデフォルト（PostgreSQLはReadCommitted）
// sql.LevelReadUncommitted  - ダーティリード可能（ほぼ使わない）
// sql.LevelReadCommitted    - コミット済みデータのみ読取り
// sql.LevelRepeatableRead   - トランザクション内で同じ結果を保証
// sql.LevelSerializable     - 最も厳格（デッドロックリスクあり）

package model
 
import (
    "database/sql"
    "encoding/json"
    "time"
)
 
// NullableUser はNULL可能なフィールドを持つユーザー
type NullableUser struct {
    ID        int64
    Name      string
    Email     sql.NullString  // NULL可能
    Phone     sql.NullString  // NULL可能
    Age       sql.NullInt64   // NULL可能
    Score     sql.NullFloat64 // NULL可能
    IsActive  sql.NullBool    // NULL可能
    DeletedAt sql.NullTime    // NULL可能（ソフトデリート）
}
 
// UserJSON はJSONレスポンス用の構造体
type UserJSON struct {
    ID        int64   `json:"id"`
    Name      string  `json:"name"`
    Email     *string `json:"email,omitempty"`
    Phone     *string `json:"phone,omitempty"`
    Age       *int64  `json:"age,omitempty"`
    Score     *float64 `json:"score,omitempty"`
    IsActive  *bool   `json:"is_active,omitempty"`
    DeletedAt *time.Time `json:"deleted_at,omitempty"`
}
 
// ToJSON はNullableUserをJSONフレンドリーな構造体に変換する
func (u *NullableUser) ToJSON() UserJSON {
    j := UserJSON{
        ID:   u.ID,
        Name: u.Name,
    }
    if u.Email.Valid {
        j.Email = &u.Email.String
    }
    if u.Phone.Valid {
        j.Phone = &u.Phone.String
    }
    if u.Age.Valid {
        j.Age = &u.Age.Int64
    }
    if u.Score.Valid {
        j.Score = &u.Score.Float64
    }
    if u.IsActive.Valid {
        j.IsActive = &u.IsActive.Bool
    }
    if u.DeletedAt.Valid {
        j.DeletedAt = &u.DeletedAt.Time
    }
    return j
}
 
// カスタムNull型（よりGoらしいアプローチ）
// ジェネリクスを使ったNull表現（Go 1.18+）
type Nullable[T any] struct {
    Value T
    Valid bool
}
 
func NewNullableT any Nullable[T] {
    return Nullable[T]{Value: v, Valid: true}
}
 
func NullValue[T any]() Nullable[T] {
    return Nullable[T]{Valid: false}
}
 
func (n Nullable[T]) MarshalJSON() ([]byte, error) {
    if !n.Valid {
        return []byte("null"), nil
    }
    return json.Marshal(n.Value)
}

package repository
 
import (
    "context"
    "fmt"
    "time"
 
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)
 
// User はsqlxのdbタグを使った構造体
type User struct {
    ID        int64     `db:"id" json:"id"`
    Name      string    `db:"name" json:"name"`
    Email     string    `db:"email" json:"email"`
    Role      string    `db:"role" json:"role"`
    CreatedAt time.Time `db:"created_at" json:"created_at"`
    UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
}
 
// SqlxUserRepository はsqlxを使ったリポジトリ
type SqlxUserRepository struct {
    db *sqlx.DB
}
 
// NewSqlxUserRepository はsqlx接続を初期化する
func NewSqlxUserRepository(dsn string) (*SqlxUserRepository, error) {
    // sqlx.Connect は Open + Ping を行う
    db, err := sqlx.Connect("postgres", dsn)
    if err != nil {
        return nil, fmt.Errorf("sqlx.Connect: %w", err)
    }
 
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)
 
    return &SqlxUserRepository{db: db}, nil
}
 
// GetByID はsqlx.GetContextで単一行を取得する
func (r *SqlxUserRepository) GetByID(ctx context.Context, id int64) (*User, error) {
    var u User
    err := r.db.GetContext(ctx, &u,
        `SELECT id, name, email, role, created_at, updated_at
         FROM users WHERE id = $1`, id)
    if err != nil {
        return nil, fmt.Errorf("GetByID(%d): %w", id, err)
    }
    return &u, nil
}
 
// List はsqlx.SelectContextで複数行を取得する
func (r *SqlxUserRepository) List(ctx context.Context, limit, offset int) ([]User, error) {
    var users []User
    err := r.db.SelectContext(ctx, &users,
        `SELECT id, name, email, role, created_at, updated_at
         FROM users ORDER BY id LIMIT $1 OFFSET $2`, limit, offset)
    if err != nil {
        return nil, fmt.Errorf("List: %w", err)
    }
    return users, nil
}
 
// Create はNamedExecContextで名前付きパラメータを使って挿入する
func (r *SqlxUserRepository) Create(ctx context.Context, u *User) error {
    query := `INSERT INTO users (name, email, role, created_at, updated_at)
              VALUES (:name, :email, :role, NOW(), NOW())
              RETURNING id, created_at, updated_at`
    rows, err := r.db.NamedQueryContext(ctx, query, u)
    if err != nil {
        return fmt.Errorf("Create: %w", err)
    }
    defer rows.Close()
    if rows.Next() {
        if err := rows.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
            return fmt.Errorf("Create scan: %w", err)
        }
    }
    return nil
}
 
// Update はNamedExecContextで名前付きパラメータを使って更新する
func (r *SqlxUserRepository) Update(ctx context.Context, u *User) error {
    result, err := r.db.NamedExecContext(ctx,
        `UPDATE users SET name = :name, email = :email, role = :role, updated_at = NOW()
         WHERE id = :id`, u)
    if err != nil {
        return fmt.Errorf("Update: %w", err)
    }
    rowsAffected, _ := result.RowsAffected()
    if rowsAffected == 0 {
        return ErrNotFound
    }
    return nil
}
 
// ListByRole は特定ロールのユーザーリストを取得する
func (r *SqlxUserRepository) ListByRole(ctx context.Context, role string) ([]User, error) {
    var users []User
    err := r.db.SelectContext(ctx, &users,
        `SELECT id, name, email, role, created_at, updated_at
         FROM users WHERE role = $1 ORDER BY name`, role)
    return users, err
}
 
// SearchByNames はIN句を使った複数検索（sqlxのIn関数を使用）
func (r *SqlxUserRepository) SearchByNames(ctx context.Context, names []string) ([]User, error) {
    // sqlx.In はスライスをプレースホルダに展開する
    query, args, err := sqlx.In(
        `SELECT id, name, email, role, created_at, updated_at
         FROM users WHERE name IN (?) ORDER BY name`, names)
    if err != nil {
        return nil, fmt.Errorf("sqlx.In: %w", err)
    }
 
    // PostgreSQLの場合は$1形式にリバインド
    query = r.db.Rebind(query)
 
    var users []User
    err = r.db.SelectContext(ctx, &users, query, args...)
    return users, err
}

package repository
 
import (
    "context"
    "database/sql"
    "fmt"
 
    "github.com/jmoiron/sqlx"
)
 
// 動的クエリビルダ
type UserFilter struct {
    Name     *string
    Email    *string
    Role     *string
    MinAge   *int
    MaxAge   *int
    IsActive *bool
    OrderBy  string
    Limit    int
    Offset   int
}
 
// BuildQuery はフィルター条件に応じた動的クエリを構築する
func (f *UserFilter) BuildQuery() (string, map[string]interface{}) {
    query := `SELECT id, name, email, role, created_at, updated_at FROM users WHERE 1=1`
    args := make(map[string]interface{})
 
    if f.Name != nil {
        query += ` AND name ILIKE :name`
        args["name"] = "%" + *f.Name + "%"
    }
    if f.Email != nil {
        query += ` AND email ILIKE :email`
        args["email"] = "%" + *f.Email + "%"
    }
    if f.Role != nil {
        query += ` AND role = :role`
        args["role"] = *f.Role
    }
    if f.MinAge != nil {
        query += ` AND age >= :min_age`
        args["min_age"] = *f.MinAge
    }
    if f.MaxAge != nil {
        query += ` AND age <= :max_age`
        args["max_age"] = *f.MaxAge
    }
    if f.IsActive != nil {
        query += ` AND is_active = :is_active`
        args["is_active"] = *f.IsActive
    }
 
    // ORDER BY
    if f.OrderBy != "" {
        // SQLインジェクション防止: ホワイトリスト
        allowed := map[string]bool{
            "name": true, "email": true, "created_at": true, "id": true,
        }
        if allowed[f.OrderBy] {
            query += fmt.Sprintf(` ORDER BY %s`, f.OrderBy)
        }
    } else {
        query += ` ORDER BY id`
    }
 
    // LIMIT / OFFSET
    if f.Limit > 0 {
        query += ` LIMIT :limit`
        args["limit"] = f.Limit
    }
    if f.Offset > 0 {
        query += ` OFFSET :offset`
        args["offset"] = f.Offset
    }
 
    return query, args
}
 
// SearchWithFilter は動的フィルターでユーザーを検索する
func (r *SqlxUserRepository) SearchWithFilter(ctx context.Context, filter UserFilter) ([]User, error) {
    query, args := filter.BuildQuery()
 
    // sqlx.Named はnamed queryをプレースホルダ付きクエリに変換する
    rows, err := r.db.NamedQueryContext(ctx, query, args)
    if err != nil {
        return nil, fmt.Errorf("SearchWithFilter: %w", err)
    }
    defer rows.Close()
 
    var users []User
    for rows.Next() {
        var u User
        if err := rows.StructScan(&u); err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, rows.Err()
}
 
// StructScan vs Scan の比較
func demonstrateScanDifference(db *sqlx.DB) {
    // database/sql: 手動で各カラムをScan
    row := db.QueryRow("SELECT id, name, email FROM users WHERE id = $1", 1)
    var id int64
    var name, email string
    row.Scan(&id, &name, &email) // カラム順に注意が必要
 
    // sqlx: 構造体に自動マッピング
    var user User
    db.Get(&user, "SELECT id, name, email FROM users WHERE id = $1", 1)
    // db タグに基づいて自動的にマッピング
}

package repository
 
import (
    "context"
    "errors"
    "fmt"
    "time"
 
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
    "gorm.io/gorm/logger"
)
 
// GormUser はGORMモデル
type GormUser struct {
    ID        uint           `gorm:"primarykey" json:"id"`
    Name      string         `gorm:"size:100;not null;index" json:"name"`
    Email     string         `gorm:"uniqueIndex;not null;size:255" json:"email"`
    Role      string         `gorm:"size:50;default:'user'" json:"role"`
    Age       int            `gorm:"check:age >= 0" json:"age"`
    Profile   *GormProfile   `gorm:"foreignKey:UserID" json:"profile,omitempty"` // has one
    Orders    []GormOrder    `gorm:"foreignKey:UserID" json:"orders,omitempty"`  // has many
    CreatedAt time.Time      `json:"created_at"`
    UpdatedAt time.Time      `json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"index" json:"deleted_at,omitempty"` // ソフトデリート
}
 
// TableName はテーブル名をカスタマイズする
func (GormUser) TableName() string {
    return "users"
}
 
// GormProfile はユーザープロフィール
type GormProfile struct {
    ID     uint   `gorm:"primarykey"`
    UserID uint   `gorm:"uniqueIndex;not null"`
    Bio    string `gorm:"type:text"`
    Avatar string `gorm:"size:500"`
}
 
// GormOrder は注文
type GormOrder struct {
    ID        uint      `gorm:"primarykey"`
    UserID    uint      `gorm:"index;not null"`
    ProductID uint      `gorm:"index;not null"`
    Quantity  int       `gorm:"not null;check:quantity > 0"`
    Amount    float64   `gorm:"type:decimal(10,2);not null"`
    Status    string    `gorm:"size:20;default:'pending'"`
    CreatedAt time.Time
}
 
// InitGorm はGORM接続を初期化する
func InitGorm(dsn string) (*gorm.DB, error) {
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
        Logger: logger.Default.LogMode(logger.Info), // SQLログを出力
        NowFunc: func() time.Time {
            return time.Now().UTC()
        },
        // SQL実行前のDry Run モードを無効化
        DryRun: false,
        // PrepareStmt: trueにするとPrepared Statementをキャッシュ
        PrepareStmt: true,
    })
    if err != nil {
        return nil, fmt.Errorf("gorm.Open: %w", err)
    }
 
    // 接続プール設定
    sqlDB, err := db.DB()
    if err != nil {
        return nil, fmt.Errorf("get sql.DB: %w", err)
    }
    sqlDB.SetMaxOpenConns(25)
    sqlDB.SetMaxIdleConns(5)
    sqlDB.SetConnMaxLifetime(5 * time.Minute)
 
    return db, nil
}
 
// GormUserRepository はGORMを使ったリポジトリ
type GormUserRepository struct {
    db *gorm.DB
}
 
// Create はユーザーを作成する
func (r *GormUserRepository) Create(ctx context.Context, user *GormUser) error {
    result := r.db.WithContext(ctx).Create(user)
    if result.Error != nil {
        return fmt.Errorf("Create: %w", result.Error)
    }
    return nil
}
 
// GetByID はIDでユーザーを取得する（関連データも含む）
func (r *GormUserRepository) GetByID(ctx context.Context, id uint) (*GormUser, error) {
    var user GormUser
    result := r.db.WithContext(ctx).
        Preload("Profile").                           // プロフィールもロード
        Preload("Orders", "status = ?", "completed"). // 完了済み注文のみ
        First(&user, id)
 
    if errors.Is(result.Error, gorm.ErrRecordNotFound) {
        return nil, ErrNotFound
    }
    if result.Error != nil {
        return nil, fmt.Errorf("GetByID: %w", result.Error)
    }
    return &user, nil
}
 
// List はページネーション付きでユーザーリストを取得する
func (r *GormUserRepository) List(ctx context.Context, page, pageSize int) ([]GormUser, int64, error) {
    var users []GormUser
    var total int64
 
    // カウントクエリ
    r.db.WithContext(ctx).Model(&GormUser{}).Count(&total)
 
    // データ取得
    result := r.db.WithContext(ctx).
        Order("id ASC").
        Limit(pageSize).
        Offset((page - 1) * pageSize).
        Find(&users)
 
    return users, total, result.Error
}
 
// Search は条件検索する
func (r *GormUserRepository) Search(ctx context.Context, filter map[string]interface{}) ([]GormUser, error) {
    var users []GormUser
    query := r.db.WithContext(ctx)
 
    if name, ok := filter["name"]; ok {
        query = query.Where("name ILIKE ?", "%"+name.(string)+"%")
    }
    if role, ok := filter["role"]; ok {
        query = query.Where("role = ?", role)
    }
    if minAge, ok := filter["min_age"]; ok {
        query = query.Where("age >= ?", minAge)
    }
 
    result := query.Find(&users)
    return users, result.Error
}
 
// Update はユーザーを更新する
func (r *GormUserRepository) Update(ctx context.Context, user *GormUser) error {
    // Save は全フィールドを更新する
    result := r.db.WithContext(ctx).Save(user)
    return result.Error
}
 
// UpdatePartial は指定フィールドのみ更新する
func (r *GormUserRepository) UpdatePartial(ctx context.Context, id uint, updates map[string]interface{}) error {
    result := r.db.WithContext(ctx).
        Model(&GormUser{}).
        Where("id = ?", id).
        Updates(updates)
 
    if result.RowsAffected == 0 {
        return ErrNotFound
    }
    return result.Error
}
 
// Delete はソフトデリートする
func (r *GormUserRepository) Delete(ctx context.Context, id uint) error {
    result := r.db.WithContext(ctx).Delete(&GormUser{}, id)
    if result.RowsAffected == 0 {
        return ErrNotFound
    }
    return result.Error
}
 
// HardDelete は物理削除する
func (r *GormUserRepository) HardDelete(ctx context.Context, id uint) error {
    result := r.db.WithContext(ctx).Unscoped().Delete(&GormUser{}, id)
    return result.Error
}
 
// Upsert は存在すれば更新、なければ挿入する
func (r *GormUserRepository) Upsert(ctx context.Context, user *GormUser) error {
    result := r.db.WithContext(ctx).
        Clauses(clause.OnConflict{
            Columns:   []clause.Column{{Name: "email"}},
            DoUpdates: clause.AssignmentColumns([]string{"name", "role", "updated_at"}),
        }).
        Create(user)
    return result.Error
}

package service
 
import (
    "context"
    "fmt"
 
    "gorm.io/gorm"
)
 
// GormOrderService は注文サービス
type GormOrderService struct {
    db *gorm.DB
}
 
// CreateOrder はトランザクション内で注文を作成する
func (s *GormOrderService) CreateOrder(ctx context.Context, order *GormOrder) error {
    return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // 在庫確認
        var product Product
        if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
            First(&product, order.ProductID).Error; err != nil {
            return fmt.Errorf("product not found: %w", err)
        }
 
        if product.Stock < order.Quantity {
            return fmt.Errorf("insufficient stock: available=%d, requested=%d",
                product.Stock, order.Quantity)
        }
 
        // 在庫を減らす
        if err := tx.Model(&product).
            Update("stock", gorm.Expr("stock - ?", order.Quantity)).Error; err != nil {
            return fmt.Errorf("update stock: %w", err)
        }
 
        // 注文を作成
        order.Amount = product.Price * float64(order.Quantity)
        if err := tx.Create(order).Error; err != nil {
            return fmt.Errorf("create order: %w", err)
        }
 
        return nil
    })
}
 
// GORMフック（ライフサイクルコールバック）
func (u *GormUser) BeforeCreate(tx *gorm.DB) error {
    // バリデーション
    if u.Name == "" {
        return fmt.Errorf("name is required")
    }
    if u.Role == "" {
        u.Role = "user" // デフォルト値
    }
    return nil
}
 
func (u *GormUser) AfterCreate(tx *gorm.DB) error {
    // 監査ログの記録など
    tx.Exec("INSERT INTO audit_logs (action, entity, entity_id) VALUES (?, ?, ?)",
        "CREATE", "users", u.ID)
    return nil
}
 
func (u *GormUser) BeforeUpdate(tx *gorm.DB) error {
    // 更新時のバリデーション
    if u.Email != "" && !isValidEmail(u.Email) {
        return fmt.Errorf("invalid email format")
    }
    return nil
}

package migrations
 
import (
    "database/sql"
    "fmt"
    "log"
 
    "github.com/golang-migrate/migrate/v4"
    "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
)
 
// RunMigrations はマイグレーションを実行する
func RunMigrations(db *sql.DB, migrationsPath string) error {
    driver, err := postgres.WithInstance(db, &postgres.Config{})
    if err != nil {
        return fmt.Errorf("create driver: %w", err)
    }
 
    m, err := migrate.NewWithDatabaseInstance(
        "file://"+migrationsPath,
        "postgres",
        driver,
    )
    if err != nil {
        return fmt.Errorf("create migrate: %w", err)
    }
 
    // マイグレーション実行
    if err := m.Up(); err != nil && err != migrate.ErrNoChange {
        return fmt.Errorf("migrate up: %w", err)
    }
 
    version, dirty, err := m.Version()
    if err != nil {
        return fmt.Errorf("get version: %w", err)
    }
    log.Printf("Migration version: %d, dirty: %v", version, dirty)
 
    return nil
}
 
// RollbackMigration は1つ前のバージョンに戻す
func RollbackMigration(db *sql.DB, migrationsPath string) error {
    driver, err := postgres.WithInstance(db, &postgres.Config{})
    if err != nil {
        return err
    }
 
    m, err := migrate.NewWithDatabaseInstance(
        "file://"+migrationsPath,
        "postgres",
        driver,
    )
    if err != nil {
        return err
    }
 
    return m.Steps(-1)
}

-- migrations/000001_create_users.up.sql
CREATE TABLE IF NOT EXISTS users (
    id BIGSERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    role VARCHAR(50) NOT NULL DEFAULT 'user',
    age INTEGER CHECK (age >= 0),
    is_active BOOLEAN NOT NULL DEFAULT true,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
 
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_users_role ON users(role);
CREATE INDEX idx_users_created_at ON users(created_at);
 
-- migrations/000001_create_users.down.sql
DROP TABLE IF EXISTS users;
 
-- migrations/000002_create_orders.up.sql
CREATE TABLE IF NOT EXISTS orders (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    product_id BIGINT NOT NULL,
    quantity INTEGER NOT NULL CHECK (quantity > 0),
    amount DECIMAL(10,2) NOT NULL,
    status VARCHAR(20) NOT NULL DEFAULT 'pending',
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
 
CREATE INDEX idx_orders_user_id ON orders(user_id);
CREATE INDEX idx_orders_status ON orders(status);
CREATE INDEX idx_orders_created_at ON orders(created_at);
 
-- migrations/000002_create_orders.down.sql
DROP TABLE IF EXISTS orders;
 
-- migrations/000003_add_users_phone.up.sql
ALTER TABLE users ADD COLUMN phone VARCHAR(20);
CREATE INDEX idx_users_phone ON users(phone) WHERE phone IS NOT NULL;
 
-- migrations/000003_add_users_phone.down.sql
DROP INDEX IF EXISTS idx_users_phone;
ALTER TABLE users DROP COLUMN IF EXISTS phone;

package migrations
 
import (
    "database/sql"
    "fmt"
 
    "github.com/pressly/goose/v3"
)
 
// GooseMigrate はgooseを使ったマイグレーション
func GooseMigrate(db *sql.DB, dir string) error {
    goose.SetDialect("postgres")
 
    if err := goose.Up(db, dir); err != nil {
        return fmt.Errorf("goose up: %w", err)
    }
    return nil
}
 
// GooseStatus は現在のマイグレーション状態を表示する
func GooseStatus(db *sql.DB, dir string) error {
    goose.SetDialect("postgres")
    return goose.Status(db, dir)
}
 
// GooseRollback は1つ前に戻す
func GooseRollback(db *sql.DB, dir string) error {
    goose.SetDialect("postgres")
    return goose.Down(db, dir)
}
 
// Go関数マイグレーション（goose独自機能）
func init() {
    goose.AddMigration(upSeedData, downSeedData)
}
 
func upSeedData(tx *sql.Tx) error {
    _, err := tx.Exec(`
        INSERT INTO users (name, email, role) VALUES
        ('Admin', 'admin@example.com', 'admin'),
        ('User1', 'user1@example.com', 'user'),
        ('User2', 'user2@example.com', 'user')
    `)
    return err
}
 
func downSeedData(tx *sql.Tx) error {
    _, err := tx.Exec(`DELETE FROM users WHERE email IN ('admin@example.com', 'user1@example.com', 'user2@example.com')`)
    return err
}

package repository_test
 
import (
    "context"
    "database/sql"
    "fmt"
    "testing"
    "time"
 
    _ "github.com/lib/pq"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/wait"
)
 
// setupTestDB はテスト用のPostgreSQLコンテナを起動する
func setupTestDB(t *testing.T) (*sql.DB, func()) {
    t.Helper()
    ctx := context.Background()
 
    // PostgreSQLコンテナの起動
    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:        "postgres:16-alpine",
            ExposedPorts: []string{"5432/tcp"},
            Env: map[string]string{
                "POSTGRES_USER":     "test",
                "POSTGRES_PASSWORD": "test",
                "POSTGRES_DB":       "testdb",
            },
            WaitingFor: wait.ForListeningPort("5432/tcp").
                WithStartupTimeout(60 * time.Second),
        },
        Started: true,
    })
    if err != nil {
        t.Fatalf("コンテナ起動失敗: %v", err)
    }
 
    // DSN構築
    host, _ := container.Host(ctx)
    port, _ := container.MappedPort(ctx, "5432")
    dsn := fmt.Sprintf("postgres://test:test@%s:%s/testdb?sslmode=disable", host, port.Port())
 
    // DB接続
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        t.Fatalf("DB接続失敗: %v", err)
    }
 
    // テーブル作成
    _, err = db.ExecContext(ctx, `
        CREATE TABLE IF NOT EXISTS users (
            id BIGSERIAL PRIMARY KEY,
            name VARCHAR(100) NOT NULL,
            email VARCHAR(255) NOT NULL UNIQUE,
            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
            updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
        )
    `)
    if err != nil {
        t.Fatalf("テーブル作成失敗: %v", err)
    }
 
    // クリーンアップ関数
    cleanup := func() {
        db.Close()
        container.Terminate(ctx)
    }
 
    return db, cleanup
}
 
func TestUserRepository_Create(t *testing.T) {
    db, cleanup := setupTestDB(t)
    defer cleanup()
 
    repo := NewUserRepository(db)
    ctx := context.Background()
 
    user := &User{Name: "Test User", Email: "test@example.com"}
    err := repo.Create(ctx, user)
    if err != nil {
        t.Fatalf("Create失敗: %v", err)
    }
 
    if user.ID == 0 {
        t.Error("IDが設定されていない")
    }
 
    // 取得して確認
    got, err := repo.GetByID(ctx, user.ID)
    if err != nil {
        t.Fatalf("GetByID失敗: %v", err)
    }
 
    if got.Name != "Test User" {
        t.Errorf("Name = %q, want %q", got.Name, "Test User")
    }
    if got.Email != "test@example.com" {
        t.Errorf("Email = %q, want %q", got.Email, "test@example.com")
    }
}
 
func TestUserRepository_Update(t *testing.T) {
    db, cleanup := setupTestDB(t)
    defer cleanup()
 
    repo := NewUserRepository(db)
    ctx := context.Background()
 
    // セットアップ
    user := &User{Name: "Original", Email: "original@example.com"}
    if err := repo.Create(ctx, user); err != nil {
        t.Fatalf("Create失敗: %v", err)
    }
 
    // 更新
    user.Name = "Updated"
    if err := repo.Update(ctx, user); err != nil {
        t.Fatalf("Update失敗: %v", err)
    }
 
    // 確認
    got, err := repo.GetByID(ctx, user.ID)
    if err != nil {
        t.Fatalf("GetByID失敗: %v", err)
    }
    if got.Name != "Updated" {
        t.Errorf("Name = %q, want %q", got.Name, "Updated")
    }
}

package service
 
import (
    "context"
)
 
// UserRepository はリポジトリのインターフェース
type UserRepository interface {
    GetByID(ctx context.Context, id int64) (*User, error)
    List(ctx context.Context, limit, offset int) ([]User, error)
    Create(ctx context.Context, u *User) error
    Update(ctx context.Context, u *User) error
    Delete(ctx context.Context, id int64) error
}
 
// UserService はビジネスロジック層
type UserService struct {
    repo UserRepository
}
 
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}
 
func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
    return s.repo.GetByID(ctx, id)
}
 
// --- テスト側 ---
 
// mockUserRepository はテスト用のモック
type mockUserRepository struct {
    users map[int64]*User
}
 
func newMockUserRepository() *mockUserRepository {
    return &mockUserRepository{users: make(map[int64]*User)}
}
 
func (m *mockUserRepository) GetByID(ctx context.Context, id int64) (*User, error) {
    u, ok := m.users[id]
    if !ok {
        return nil, ErrNotFound
    }
    return u, nil
}
 
func (m *mockUserRepository) List(ctx context.Context, limit, offset int) ([]User, error) {
    var result []User
    for _, u := range m.users {
        result = append(result, *u)
    }
    return result, nil
}
 
func (m *mockUserRepository) Create(ctx context.Context, u *User) error {
    u.ID = int64(len(m.users) + 1)
    m.users[u.ID] = u
    return nil
}
 
func (m *mockUserRepository) Update(ctx context.Context, u *User) error {
    if _, ok := m.users[u.ID]; !ok {
        return ErrNotFound
    }
    m.users[u.ID] = u
    return nil
}
 
func (m *mockUserRepository) Delete(ctx context.Context, id int64) error {
    if _, ok := m.users[id]; !ok {
        return ErrNotFound
    }
    delete(m.users, id)
    return nil
}