【Go语言学习系列34】数据库编程（一）：SQL接口

📚 原创系列： “Go语言学习系列”

🔄 转载说明： 本文最初发布于"Gopher部落"微信公众号，经原作者授权转载。

🔗 关注原创： 欢迎扫描文末二维码，关注"Gopher部落"微信公众号获取第一手Go技术文章。

📑 Go语言学习系列导航

本文是【Go语言学习系列】的第34篇，当前位于第三阶段（进阶篇）

28. 并发编程（一）：goroutine基础
29. 并发编程（二）：channel基础
30. 并发编程（三）：select语句
31. 并发编程（四）：sync包
32. 并发编程（五）：并发模式
33. 并发编程（六）：原子操作与内存模型
34. 数据库编程（一）：SQL接口 👈 当前位置
35. 数据库编程（二）：ORM技术
36. Web开发（一）：路由与中间件
37. Web开发（二）：模板与静态资源
38. Web开发（三）：API开发
39. Web开发（四）：认证与授权
40. Web开发（五）：WebSocket
41. 微服务（一）：基础概念
42. 微服务（二）：gRPC入门
43. 日志与监控
44. 第三阶段项目实战：微服务聊天应用

📚 查看完整Go语言学习系列导航

📖 文章导读

在本文中，您将了解：

• Go语言的数据库编程基础，特别是database/sql包的使用
• 如何连接各种SQL数据库并配置连接池
• 执行基本查询和修改操作的方法
• 事务处理和预处理语句的使用
• 如何正确处理NULL值和常见错误
• 使用仓储模式组织数据库代码的最佳实践
• 构建一个完整的用户管理系统示例

数据库编程（一）：SQL接口

在前面六篇关于并发编程的文章中，我们深入探讨了Go语言的并发特性。从本篇开始，我们将转向另一个重要领域：数据库编程。Go语言提供了强大而灵活的数据库操作支持，本文将重点介绍标准库中的database/sql包，这是Go与各种SQL数据库交互的基础。

1. Go数据库编程概述

Go语言通过database/sql包提供了一套统一的SQL数据库接口，并通过各种数据库驱动实现了对具体数据库的支持。这种设计使得我们可以用相同的代码风格操作不同的数据库系统。

1.1 数据库访问结构

Go的数据库访问主要通过以下几个层次实现：

应用代码 → database/sql包 → 数据库驱动 → 具体数据库

• database/sql：提供通用的SQL接口和连接池管理
• 数据库驱动：实现具体数据库与database/sql接口的连接
• 具体数据库：如MySQL、PostgreSQL、SQLite等

1.2 常用数据库驱动

以下是一些常用的Go数据库驱动：

• MySQL: github.com/go-sql-driver/mysql
• PostgreSQL: github.com/lib/pq
• SQLite: github.com/mattn/go-sqlite3
• Microsoft SQL Server: github.com/denisenkom/go-mssqldb

2. 数据库连接

2.1 导入必要的包

package main

import (
    "database/sql"
    "fmt"
    "log"
    
    _ "github.com/go-sql-driver/mysql" // 仅导入驱动，不直接使用
)

注意下划线前缀_表示仅注册驱动，而不直接引用包中的函数或变量。

2.2 建立数据库连接

func main() {
    // 数据源名称（DSN）格式：用户名:密码@协议(地址)/数据库?参数=值
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True"
    
    // 打开数据库连接
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal("连接数据库失败:", err)
    }
    defer db.Close() // 确保在函数退出时关闭数据库连接
    
    // 验证连接
    if err := db.Ping(); err != nil {
        log.Fatal("Ping数据库失败:", err)
    }
    
    fmt.Println("成功连接到数据库!")
}

2.3 连接池配置

database/sql包内置了连接池管理，我们可以配置连接池参数以优化性能：

// 设置最大打开连接数
db.SetMaxOpenConns(25)

// 设置最大空闲连接数
db.SetMaxIdleConns(5)

// 设置连接最大生命周期
db.SetConnMaxLifetime(5 * time.Minute)

// 设置空闲连接最大存活时间（Go 1.15+）
db.SetConnMaxIdleTime(10 * time.Minute)

连接池相关设置应根据应用负载和服务器资源进行调整。

3. 基本查询操作

3.1 执行简单查询

func queryExample(db *sql.DB) {
    // 查询单行
    var name string
    var age int
    
    row := db.QueryRow("SELECT name, age FROM users WHERE id = ?", 1)
    err := row.Scan(&name, &age)
    if err != nil {
        if err == sql.ErrNoRows {
            fmt.Println("未找到记录")
            return
        }
        log.Fatal("查询失败:", err)
    }
    
    fmt.Printf("用户: %s, 年龄: %d\n", name, age)
}

3.2 查询多行数据

func queryMultipleRows(db *sql.DB) {
    // 查询多行
    rows, err := db.Query("SELECT id, name, age FROM users WHERE age > ?", 18)
    if err != nil {
        log.Fatal("查询失败:", err)
    }
    defer rows.Close() // 非常重要：确保关闭rows
    
    // 遍历结果集
    for rows.Next() {
        var id int
        var name string
        var age int
        
        if err := rows.Scan(&id, &name, &age); err != nil {
            log.Fatal("Scan失败:", err)
        }
        
        fmt.Printf("ID: %d, 名称: %s, 年龄: %d\n", id, name, age)
    }
    
    // 检查遍历过程中的错误
    if err := rows.Err(); err != nil {
        log.Fatal("结果集遍历失败:", err)
    }
}

3.3 使用预处理语句

预处理语句可以提高性能并防止SQL注入攻击：

func preparedStatementExample(db *sql.DB) {
    // 准备语句
    stmt, err := db.Prepare("SELECT name, age FROM users WHERE id = ?")
    if err != nil {
        log.Fatal("准备语句失败:", err)
    }
    defer stmt.Close() // 确保关闭语句
    
    // 使用准备好的语句多次查询
    for id := 1; id <= 5; id++ {
        var name string
        var age int
        
        err := stmt.QueryRow(id).Scan(&name, &age)
        if err != nil {
            if err == sql.ErrNoRows {
                fmt.Printf("ID %d: 未找到记录\n", id)
                continue
            }
            log.Printf("查询ID %d失败: %v\n", id, err)
            continue
        }
        
        fmt.Printf("ID %d: 名称=%s, 年龄=%d\n", id, name, age)
    }
}

4. 修改数据操作

4.1 插入数据

func insertExample(db *sql.DB) {
    // 插入单条记录
    result, err := db.Exec(
        "INSERT INTO users (name, age, email) VALUES (?, ?, ?)",
        "张三", 30, "zhangsan@example.com",
    )
    if err != nil {
        log.Fatal("插入失败:", err)
    }
    
    // 获取自增ID
    id, err := result.LastInsertId()
    if err != nil {
        log.Fatal("获取最后插入ID失败:", err)
    }
    
    // 获取受影响行数
    rows, err := result.RowsAffected()
    if err != nil {
        log.Fatal("获取受影响行数失败:", err)
    }
    
    fmt.Printf("成功插入记录，ID: %d, 受影响行数: %d\n", id, rows)
}

4.2 更新数据

func updateExample(db *sql.DB) {
    // 更新记录
    result, err := db.Exec(
        "UPDATE users SET age = ?, email = ? WHERE id = ?",
        31, "zhangsan_new@example.com", 1,
    )
    if err != nil {
        log.Fatal("更新失败:", err)
    }
    
    // 获取受影响行数
    rows, err := result.RowsAffected()
    if err != nil {
        log.Fatal("获取受影响行数失败:", err)
    }
    
    fmt.Printf("成功更新记录，受影响行数: %d\n", rows)
}

4.3 删除数据

func deleteExample(db *sql.DB) {
    // 删除记录
    result, err := db.Exec("DELETE FROM users WHERE id = ?", 1)
    if err != nil {
        log.Fatal("删除失败:", err)
    }
    
    // 获取受影响行数
    rows, err := result.RowsAffected()
    if err != nil {
        log.Fatal("获取受影响行数失败:", err)
    }
    
    fmt.Printf("成功删除记录，受影响行数: %d\n", rows)
}

5. 事务处理

事务允许将多个数据库操作作为一个原子单元执行，要么全部成功，要么全部失败。

func transactionExample(db *sql.DB) {
    // 开始事务
    tx, err := db.Begin()
    if err != nil {
        log.Fatal("开始事务失败:", err)
    }
    
    // 使用defer和recover处理异常，确保事务正确结束
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
            log.Printf("发生异常，事务回滚: %v", r)
        }
    }()
    
    // 执行第一个操作
    _, err = tx.Exec("INSERT INTO accounts (user_id, balance) VALUES (?, ?)", 1, 1000)
    if err != nil {
        tx.Rollback()
        log.Fatal("第一个操作失败，事务回滚:", err)
        return
    }
    
    // 执行第二个操作
    _, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE user_id = ?", 200, 1)
    if err != nil {
        tx.Rollback()
        log.Fatal("第二个操作失败，事务回滚:", err)
        return
    }
    
    // 执行第三个操作
    _, err = tx.Exec("INSERT INTO transactions (user_id, amount, type) VALUES (?, ?, ?)", 1, 200, "withdrawal")
    if err != nil {
        tx.Rollback()
        log.Fatal("第三个操作失败，事务回滚:", err)
        return
    }
    
    // 提交事务
    err = tx.Commit()
    if err != nil {
        log.Fatal("提交事务失败:", err)
        return
    }
    
    fmt.Println("事务成功完成!")
}

6. 处理NULL值

数据库中的NULL值需要使用特殊的类型处理：

import (
    "database/sql"
    "fmt"
    "log"
    "time"
)

func nullValueExample(db *sql.DB) {
    // 声明可能包含NULL的变量
    var (
        id        int
        name      string
        age       sql.NullInt64
        email     sql.NullString
        createdAt sql.NullTime
    )
    
    // 查询可能包含NULL值的记录
    row := db.QueryRow("SELECT id, name, age, email, created_at FROM users WHERE id = ?", 1)
    err := row.Scan(&id, &name, &age, &email, &createdAt)
    if err != nil {
        log.Fatal("查询失败:", err)
    }
    
    // 安全地访问可能为NULL的值
    fmt.Printf("ID: %d, 名称: %s\n", id, name)
    
    if age.Valid {
        fmt.Printf("年龄: %d\n", age.Int64)
    } else {
        fmt.Println("年龄: NULL")
    }
    
    if email.Valid {
        fmt.Printf("邮箱: %s\n", email.String)
    } else {
        fmt.Println("邮箱: NULL")
    }
    
    if createdAt.Valid {
        fmt.Printf("创建时间: %v\n", createdAt.Time)
    } else {
        fmt.Println("创建时间: NULL")
    }
}

7. 常见错误和最佳实践

7.1 常见错误

1. 未关闭资源：如rows.Close()、stmt.Close()
2. 忽略错误检查：尤其是rows.Err()
3. 在循环中频繁准备语句：应在循环外准备，循环内执行
4. 不正确的事务处理：没有处理提交或回滚
5. 连接泄漏：比如使用了Query但没有迭代完所有结果

7.2 最佳实践

1. 始终使用参数化查询：防止SQL注入攻击

   // 好的做法
   db.Query("SELECT * FROM users WHERE name = ?", username)
   
   // 不安全的做法
   db.Query("SELECT * FROM users WHERE name = '" + username + "'")
   

2. 正确处理连接：设置合适的连接池参数

3. 使用合适的查询函数：

   • Query: 返回多行
   • QueryRow: 返回单行
   • Exec: 不返回行的操作（INSERT/UPDATE/DELETE）

4. 使用事务确保数据完整性：在需要原子操作时使用事务

5. 处理NULL值：使用sql.NullXXX类型处理可能为NULL的列

6. 结构化应用代码：将数据库操作封装到专门的包或函数中

8. 实战案例：用户管理系统

下面是一个简单的用户管理系统示例，展示如何组织数据库代码：

package main

import (
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "github.com/go-sql-driver/mysql"
)

// User 结构体表示用户信息
type User struct {
    ID        int
    Name      string
    Age       sql.NullInt64
    Email     sql.NullString
    CreatedAt time.Time
    UpdatedAt sql.NullTime
}

// UserRepository 用户仓储接口
type UserRepository struct {
    db *sql.DB
}

// NewUserRepository 创建用户仓储
func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

// GetByID 根据ID获取用户
func (r *UserRepository) GetByID(id int) (*User, error) {
    user := &User{}
    
    err := r.db.QueryRow(
        "SELECT id, name, age, email, created_at, updated_at FROM users WHERE id = ?", 
        id,
    ).Scan(
        &user.ID, 
        &user.Name, 
        &user.Age, 
        &user.Email, 
        &user.CreatedAt, 
        &user.UpdatedAt,
    )
    
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, fmt.Errorf("用户 ID %d 不存在", id)
        }
        return nil, fmt.Errorf("查询用户 ID %d 失败: %w", id, err)
    }
    
    return user, nil
}

// Create 创建新用户
func (r *UserRepository) Create(user *User) (int, error) {
    result, err := r.db.Exec(
        "INSERT INTO users (name, age, email, created_at) VALUES (?, ?, ?, ?)",
        user.Name,
        user.Age,
        user.Email,
        time.Now(),
    )
    
    if err != nil {
        return 0, fmt.Errorf("创建用户失败: %w", err)
    }
    
    id, err := result.LastInsertId()
    if err != nil {
        return 0, fmt.Errorf("获取插入ID失败: %w", err)
    }
    
    return int(id), nil
}

// Update 更新用户信息
func (r *UserRepository) Update(user *User) error {
    _, err := r.db.Exec(
        "UPDATE users SET name = ?, age = ?, email = ?, updated_at = ? WHERE id = ?",
        user.Name,
        user.Age,
        user.Email,
        time.Now(),
        user.ID,
    )
    
    if err != nil {
        return fmt.Errorf("更新用户 ID %d 失败: %w", user.ID, err)
    }
    
    return nil
}

// Delete 删除用户
func (r *UserRepository) Delete(id int) error {
    result, err := r.db.Exec("DELETE FROM users WHERE id = ?", id)
    if err != nil {
        return fmt.Errorf("删除用户 ID %d 失败: %w", id, err)
    }
    
    affected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("获取受影响行数失败: %w", err)
    }
    
    if affected == 0 {
        return fmt.Errorf("用户 ID %d 不存在", id)
    }
    
    return nil
}

// FindByAgeRange 查找特定年龄范围的用户
func (r *UserRepository) FindByAgeRange(min, max int) ([]*User, error) {
    rows, err := r.db.Query(
        "SELECT id, name, age, email, created_at, updated_at FROM users WHERE age >= ? AND age <= ?",
        min, max,
    )
    if err != nil {
        return nil, fmt.Errorf("查询年龄范围 %d-%d 的用户失败: %w", min, max, err)
    }
    defer rows.Close()
    
    var users []*User
    
    for rows.Next() {
        user := &User{}
        
        err := rows.Scan(
            &user.ID,
            &user.Name,
            &user.Age,
            &user.Email,
            &user.CreatedAt,
            &user.UpdatedAt,
        )
        
        if err != nil {
            return nil, fmt.Errorf("扫描用户数据失败: %w", err)
        }
        
        users = append(users, user)
    }
    
    if err := rows.Err(); err != nil {
        return nil, fmt.Errorf("迭代用户结果集失败: %w", err)
    }
    
    return users, nil
}

func main() {
    // 连接数据库
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/userdb?parseTime=true")
    if err != nil {
        log.Fatal("连接数据库失败:", err)
    }
    defer db.Close()
    
    // 设置连接池参数
    db.SetMaxOpenConns(10)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(time.Hour)
    
    // 创建用户仓储
    userRepo := NewUserRepository(db)
    
    // 创建用户示例
    newUser := &User{
        Name: "李四",
        Age: sql.NullInt64{Int64: 25, Valid: true},
        Email: sql.NullString{String: "lisi@example.com", Valid: true},
    }
    
    id, err := userRepo.Create(newUser)
    if err != nil {
        log.Fatal("创建用户失败:", err)
    }
    fmt.Printf("创建了新用户，ID: %d\n", id)
    
    // 查询用户示例
    user, err := userRepo.GetByID(id)
    if err != nil {
        log.Fatal("查询用户失败:", err)
    }
    fmt.Printf("查询到用户: ID=%d, 名称=%s\n", user.ID, user.Name)
    
    // 更新用户示例
    user.Name = "李四(已更新)"
    err = userRepo.Update(user)
    if err != nil {
        log.Fatal("更新用户失败:", err)
    }
    fmt.Println("已成功更新用户信息")
    
    // 查询年龄范围示例
    users, err := userRepo.FindByAgeRange(20, 30)
    if err != nil {
        log.Fatal("查询年龄范围的用户失败:", err)
    }
    fmt.Printf("找到 %d 个年龄在20-30之间的用户\n", len(users))
    
    for _, u := range users {
        if u.Age.Valid {
            fmt.Printf("- ID: %d, 名称: %s, 年龄: %d\n", u.ID, u.Name, u.Age.Int64)
        } else {
            fmt.Printf("- ID: %d, 名称: %s, 年龄: NULL\n", u.ID, u.Name)
        }
    }
}

9. 总结

Go语言的database/sql包提供了灵活而强大的数据库访问能力，通过统一的接口支持多种数据库。本文介绍了：

1. 数据库连接：建立连接、配置连接池
2. 基本查询：单行查询、多行查询、预处理语句
3. 数据修改：插入、更新、删除
4. 事务处理：事务的开始、提交和回滚
5. NULL值处理：使用sql.NullXXX类型
6. 最佳实践：资源管理、错误处理、参数化查询等
7. 实战案例：用户管理系统的实现

掌握这些基础知识后，你可以构建可靠的数据库应用程序。在下一篇文章中，我们将探讨ORM技术，它可以进一步简化数据库操作。

👨‍💻 关于作者与Gopher部落

"Gopher部落"专注于Go语言技术分享，提供从入门到精通的完整学习路线。

🌟 为什么关注我们？

1. 系统化学习路径：本系列44篇文章循序渐进，带你完整掌握Go开发
2. 实战驱动教学：理论结合实践，每篇文章都有可操作的代码示例
3. 持续更新内容：定期分享最新Go生态技术动态与大厂实践经验
4. 专业技术社区：加入我们的技术交流群，与众多Go开发者共同成长

📱 关注方式

1. 微信公众号：搜索 “Gopher部落” 或 “GopherTribe”
2. CSDN专栏：点击页面右上角"关注"按钮

💡 读者福利

关注公众号回复 “SQL” 即可获取：

• Go数据库编程最佳实践指南
• SQL优化技巧速查表
• 数据库设计案例分析

期待与您在Go语言的学习旅程中共同成长！