Go语言database/sql操作中如何简化重复的错误处理？

Great question! Dealing with repetitive error checks in Go's database/sql code is super common—we've all been there staring at endless if err != nil blocks. The good news is there are a few clean ways to handle this without sacrificing access to your variables like result or rows. Let's break down the most practical approaches:

This is the idiomatic Go approach, perfect for functions that return both a value and an error. By declaring your return variables upfront in the function signature, you can assign to them throughout the function and just return immediately when an error hits—no need to re-declare variables every time.

Example:

func GetUserWithRole(db *sql.DB, userID int) (user User, err error) {
    // Query user base data
    err = db.QueryRow(`SELECT id, username FROM users WHERE id = ?`, userID).
        Scan(&user.ID, &user.Username)
    if err != nil {
        return // Automatically returns the current user (zero value) and err
    }

    // Query associated role (reuses the same err variable)
    err = db.QueryRow(`SELECT role_name FROM roles WHERE user_id = ?`, userID).
        Scan(&user.Role)
    if err != nil {
        return
    }

    return // Success: returns the populated user and nil err
}

This keeps your code clean, avoids variable scoping issues, and follows Go's idioms perfectly.

If named returns don't fit your style, you can declare err once at the top of your function, then reassign it for each database operation. This lets you keep your result or rows variables in the outer scope while still keeping error checks concise.

Example:

func UpdateUserProfile(db *sql.DB, profile UserProfile) (sql.Result, error) {
    var res sql.Result
    var err error

    // First update operation
    res, err = db.Exec(`UPDATE profiles SET bio = ?, avatar_url = ? WHERE user_id = ?`,
        profile.Bio, profile.AvatarURL, profile.UserID)
    if err != nil {
        return nil, fmt.Errorf("update profile: %w", err)
    }

    // Verify rows affected (reuses err again)
    var rowsAffected int64
    rowsAffected, err = res.RowsAffected()
    if err != nil {
        return nil, fmt.Errorf("check rows affected: %w", err)
    }
    if rowsAffected == 0 {
        return nil, fmt.Errorf("no profile found for user ID %d", profile.UserID)
    }

    return res, nil
}

This approach is straightforward and keeps variables accessible across the whole function.

To reduce repetition in error messages and handle common database/sql errors (like sql.ErrNoRows), you can create a small helper function to standardize your error handling. This doesn't eliminate the if err != nil checks, but it makes them shorter and more consistent.

Example helper:

func wrapDBErr(err error, action string) error {
    if err == sql.ErrNoRows {
        return fmt.Errorf("%s: no record found", action)
    }
    return fmt.Errorf("%s: %w", action, err) // Preserve original error with %w
}

Usage in your code:

func GetUser(db *sql.DB, userID int) (User, error) {
    var user User
    err := db.QueryRow(`SELECT id, username FROM users WHERE id = ?`, userID).
        Scan(&user.ID, &user.Username)
    if err != nil {
        return User{}, wrapDBErr(err, "fetch user")
    }
    return user, nil
}

This ensures your errors are consistent and saves you from typing repetitive error message formats.

It's tempting to try tricks like combining assignment and error checking in a single line for every operation, but that often leads to unreadable code or scoping issues (like the problem you mentioned with variables being trapped in the if block). Go's error handling is intentionally explicit—prioritize readability over extreme brevity.

内容的提问来源于stack exchange，提问作者bblocs3141