Golang操作SQLite：go-sqlite3使用教程

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《Golang操作SQLite教程：go-sqlite3驱动使用指南》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

在Golang中操作SQLite数据库，新手可通过以下步骤快速上手：1. 导入database/sql标准库和go-sqlite3驱动；2. 使用sql.Open打开数据库连接并用defer确保关闭；3. 通过db.Exec创建表；4. 使用db.Prepare和stmt.Exec插入数据；5. 利用db.Query遍历查询结果；6. 使用预处理语句执行更新和删除操作。常见错误包括忽略错误处理、频繁打开关闭连接、SQL注入风险、并发写入瓶颈及类型映射问题，建议启用WAL模式提升并发性能，并使用预处理参数防止注入。为确保数据一致性，应使用事务处理，通过db.Begin启动事务，tx.Commit提交或tx.Rollback回滚，所有操作均通过*sql.Tx对象完成。此外，可借助golang-migrate实现Schema迁移，或引入ORM工具如GORM简化复杂业务逻辑。

在Golang中操作SQLite数据库，对于新手来说，其实比想象中要简单得多，核心就是利用好database/sql标准库和go-sqlite3这个驱动。它能让你快速上手，实现数据的存取，而不用被复杂的数据库概念吓到。简单来说，就是连接、执行SQL、处理结果，然后别忘了关掉连接。

解决方案

要开始用Go操作SQLite，首先得把go-sqlite3驱动导入进来。它会注册自己到database/sql，所以我们后续的操作都是基于database/sql这个标准库进行的，这很Go。

package main

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

    _ "github.com/mattn/go-sqlite3" // 导入驱动，注意下划线，表示只导入包执行其init函数
)

func main() {
    // 1. 打开数据库连接
    // 如果文件不存在，会自动创建。这是一个很方便的特性。
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        log.Fatal(err)
    }
    // 养成好习惯，操作完数据库记得关闭连接。
    // 这里用defer确保在函数退出时执行。
    defer func() {
        err := db.Close()
        if err != nil {
            log.Printf("关闭数据库连接失败: %v", err)
        }
    }()

    // 2. 创建表（如果不存在）
    // SQL语句写在这里，用`Exec`方法执行。
    sqlStmt := `
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER
    );`
    _, err = db.Exec(sqlStmt)
    if err != nil {
        log.Fatalf("创建表失败: %v", err)
    }
    fmt.Println("表 'users' 检查或创建成功。")

    // 3. 插入数据
    // 插入操作也用`Exec`。这里我推荐使用预处理语句（Prepared Statement），
    // 这样可以有效防止SQL注入，而且对于重复插入性能更好。
    stmt, err := db.Prepare("INSERT INTO users(name, age) VALUES(?, ?)")
    if err != nil {
        log.Fatalf("准备插入语句失败: %v", err)
    }
    defer func() {
        err := stmt.Close()
        if err != nil {
            log.Printf("关闭预处理语句失败: %v", err)
        }
    }()

    _, err = stmt.Exec("张三", 30)
    if err != nil {
        log.Fatalf("插入数据失败: %v", err)
    }
    fmt.Println("插入数据 '张三' 成功。")

    _, err = stmt.Exec("李四", 25)
    if err != nil {
        log.Fatalf("插入数据 '李四' 失败: %v", err)
    }
    fmt.Println("插入数据 '李四' 成功。")

    // 4. 查询数据
    // 查询操作用`Query`。它会返回一个`*sql.Rows`对象，我们需要遍历它。
    rows, err := db.Query("SELECT id, name, age FROM users")
    if err != nil {
        log.Fatalf("查询数据失败: %v", err)
    }
    defer func() {
        err := rows.Close()
        if err != nil {
            log.Printf("关闭查询结果集失败: %v", err)
        }
    }()

    fmt.Println("\n查询所有用户:")
    for rows.Next() { // 遍历每一行
        var id int
        var name string
        var age int
        // 将列数据扫描到变量中
        err = rows.Scan(&id, &name, &age)
        if err != nil {
            log.Fatalf("扫描行数据失败: %v", err)
        }
        fmt.Printf("ID: %d, 姓名: %s, 年龄: %d\n", id, name, age)
    }
    // 检查遍历过程中是否有错误发生
    err = rows.Err()
    if err != nil {
        log.Fatalf("遍历结果集时发生错误: %v", err)
    }

    // 5. 更新数据
    // 同样使用预处理语句，然后用`Exec`执行。
    updateStmt, err := db.Prepare("UPDATE users SET age = ? WHERE name = ?")
    if err != nil {
        log.Fatalf("准备更新语句失败: %v", err)
    }
    defer func() {
        err := updateStmt.Close()
        if err != nil {
            log.Printf("关闭更新预处理语句失败: %v", err)
        }
    }()

    res, err := updateStmt.Exec(31, "张三")
    if err != nil {
        log.Fatalf("更新数据失败: %v", err)
    }
    rowsAffected, _ := res.RowsAffected() // 获取受影响的行数
    fmt.Printf("\n更新 '张三' 的年龄为 31，影响行数: %d\n", rowsAffected)

    // 6. 删除数据
    // 删除操作也类似。
    deleteStmt, err := db.Prepare("DELETE FROM users WHERE name = ?")
    if err != nil {
        log.Fatalf("准备删除语句失败: %v", err)
    }
    defer func() {
        err := deleteStmt.Close()
        if err != nil {
            log.Printf("关闭删除预处理语句失败: %v", err)
        }
    }()

    res, err = deleteStmt.Exec("李四")
    if err != nil {
        log.Fatalf("删除数据失败: %v", err)
    }
    rowsAffected, _ = res.RowsAffected()
    fmt.Printf("删除 '李四'，影响行数: %d\n", rowsAffected)

    // 再次查询，看看删掉没
    fmt.Println("\n再次查询所有用户 (验证删除):")
    rows, err = db.Query("SELECT id, name, age FROM users")
    if err != nil {
        log.Fatalf("再次查询数据失败: %v", err)
    }
    defer func() {
        err := rows.Close()
        if err != nil {
            log.Printf("关闭再次查询结果集失败: %v", err)
        }
    }()

    for rows.Next() {
        var id int
        var name string
        var age int
        err = rows.Scan(&id, &name, &age)
        if err != nil {
            log.Fatalf("再次扫描行数据失败: %v", err)
        }
        fmt.Printf("ID: %d, 姓名: %s, 年龄: %d\n", id, name, age)
    }
    err = rows.Err()
    if err != nil {
        log.Fatalf("再次遍历结果集时发生错误: %v", err)
    }
}

在Golang中使用SQLite，有哪些常见的错误或优化建议？

在我看来，新手在使用Go和SQLite时，最容易犯的错误往往不是代码逻辑上的大问题，而是那些“小细节”：

• 错误处理的缺失或不完整：这是老生常谈，但真的太重要了。Go的哲学就是显式错误处理。sql.Open、db.Exec、db.Query、rows.Next、rows.Scan等等，每个操作都可能返回错误。如果你不检查，一旦出问题，程序可能就悄无声息地挂了或者返回了不正确的结果，排查起来简直是噩梦。我的建议是，每次操作后都检查err，如果是非预期错误，直接log.Fatal或者返回给上层处理。
• 连接管理不当：虽然在上面的例子里用了defer db.Close()，但在实际的Web服务或者长生命周期应用中，你可能不会每次请求都去sql.Open。database/sql模块其实内置了连接池，sql.Open只会建立一个到数据库的抽象连接，实际的物理连接会按需创建和复用。但如果你频繁地Open和Close，这反而会带来性能开销。通常的做法是在程序启动时Open一次，然后把*sql.DB对象传递给需要数据库操作的地方。
• SQL注入风险：直接拼接用户输入到SQL语句里，比如"SELECT * FROM users WHERE name = '" + userName + "'"，这简直是给黑客送钥匙。正确的姿势是始终使用预处理语句（db.Prepare()），然后通过stmt.Exec()或db.QueryRow()、db.Query()的参数来传递值。go-sqlite3和database/sql会自动帮你处理好参数的转义，安全又高效。
• 并发问题与WAL模式：SQLite是一个文件级数据库，这意味着它在并发写入时可能会遇到锁的问题。默认情况下，SQLite在写入时会锁定整个数据库文件。如果你的应用需要高并发写入，这可能会成为瓶颈。一个非常有效的优化是启用WAL（Write-Ahead Logging）模式。WAL模式允许读操作与写操作并行进行，显著提升了并发性能。你可以在连接字符串中设置_journal=WAL来启用，例如：sql.Open("sqlite3", "./test.db?_journal=WAL")。
• 数据类型映射的误解：Go语言有严格的类型系统，而SQL数据库的类型则相对灵活。在rows.Scan()时，你需要确保Go变量的类型与数据库列的类型兼容。比如，数据库里的INTEGER可以映射到Go的int、int64；TEXT映射到string。如果遇到NULL值，你需要使用sql.NullString、sql.NullInt64等类型来避免Scan时的panic。

Golang操作SQLite时，如何确保数据一致性（事务处理）？

数据一致性，通常我们说的是事务（Transaction）的ACID特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。简单来说，就是一系列数据库操作要么全部成功，要么全部失败，绝不会出现只完成了一部分的情况。在Go中操作SQLite，实现事务处理非常直观。

database/sql提供了db.Begin()方法来开始一个事务，它会返回一个*sql.Tx对象。所有的数据库操作，包括Exec、Query等，都应该通过这个*sql.Tx对象来执行，而不是直接通过*sql.DB。当所有操作都成功后，调用tx.Commit()提交事务；如果中间任何一步出错，就调用tx.Rollback()回滚事务。

一个常见的模式是，在Begin()之后，立即defer tx.Rollback()。这样，即使后续代码发生panic或者提前返回，事务也会被自动回滚，确保数据不会处于一个不确定的状态。只有当所有操作都成功且准备提交时，才将tx.Rollback()置为nil或者显式调用tx.Commit()。

看个例子：

package main

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

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./test_tx.db")
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        err := db.Close()
        if err != nil {
            log.Printf("关闭数据库连接失败: %v", err)
        }
    }()

    // 确保表存在
    sqlStmt := `
    CREATE TABLE IF NOT EXISTS accounts (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        balance INTEGER NOT NULL
    );`
    _, err = db.Exec(sqlStmt)
    if err != nil {
        log.Fatalf("创建表失败: %v", err)
    }
    fmt.Println("表 'accounts' 检查或创建成功。")

    // 插入一些初始数据
    _, err = db.Exec("INSERT INTO accounts(name, balance) VALUES('Alice', 100), ('Bob', 50)")
    if err != nil {
        log.Printf("插入初始数据失败 (可能已存在): %v", err)
    }

    // 模拟转账操作：从Alice转账20到Bob
    fmt.Println("\n尝试进行转账操作 (Alice -> Bob, 20元)...")
    err = transfer(db, "Alice", "Bob", 20)
    if err != nil {
        fmt.Printf("转账失败: %v\n", err)
    } else {
        fmt.Println("转账成功！")
    }

    // 模拟一次失败的转账（余额不足）
    fmt.Println("\n尝试进行失败的转账操作 (Alice -> Bob, 200元)...")
    err = transfer(db, "Alice", "Bob", 200)
    if err != nil {
        fmt.Printf("转账失败 (预期): %v\n", err)
    } else {
        fmt.Println("转账成功！")
    }

    // 查询最终余额
    fmt.Println("\n查询最终账户余额:")
    rows, err := db.Query("SELECT name, balance FROM accounts")
    if err != nil {
        log.Fatalf("查询余额失败: %v", err)
    }
    defer func() {
        err := rows.Close()
        if err != nil {
            log.Printf("关闭查询结果集失败: %v", err)
        }
    }()
    for rows.Next() {
        var name string
        var balance int
        err = rows.Scan(&name, &balance)
        if err != nil {
            log.Fatalf("扫描余额数据失败: %v", err)
        }
        fmt.Printf("账户: %s, 余额: %d\n", name, balance)
    }
    err = rows.Err()
    if err != nil {
        log.Fatalf("遍历余额结果集时发生错误: %v", err)
    }
}

// transfer 模拟转账函数
func transfer(db *sql.DB, fromUser, toUser string, amount int) error {
    tx, err := db.Begin() // 开始事务
    if err != nil {
        return fmt.Errorf("开始事务失败: %w", err)
    }
    // 无论函数如何退出，都尝试回滚。
    // 如果tx.Commit()成功执行，tx会变成nil，那么这个defer就不会执行了。
    defer func() {
        if tx != nil { // 只有当tx还没有被commit或rollback时才执行
            err := tx.Rollback()
            if err != nil && err != sql.ErrTxDone { // sql.ErrTxDone表示事务已完成
                log.Printf("事务回滚失败: %v", err)
            }
            fmt.Println("事务已回滚。")
        }
    }()

    // 1. 检查转出方余额
    var fromBalance int
    err = tx.QueryRow("SELECT balance FROM accounts WHERE name = ?", fromUser).Scan(&fromBalance)
    if err != nil {
        if err == sql.ErrNoRows {
            return fmt.Errorf("转出账户 '%s' 不存在", fromUser)
        }
        return fmt.Errorf("查询转出方余额失败: %w", err)
    }

    if fromBalance < amount {
        return fmt.Errorf("账户 '%s' 余额不足，当前: %d, 需转: %d", fromUser, fromBalance, amount)
    }

    // 2. 扣除转出方余额
    _, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE name = ?", amount, fromUser)
    if err != nil {
        return fmt.Errorf("扣除转出方余额失败: %w", err)
    }

    // 3. 增加转入方余额
    _, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE name = ?", amount, toUser)
    if err != nil {
        return fmt.Errorf("增加转入方余额失败: %w", err)
    }

    // 4. 提交事务
    err = tx.Commit()
    if err != nil {
        return fmt.Errorf("提交事务失败: %w", err)
    }
    tx = nil // 成功提交后，将tx设为nil，避免defer中的回滚再次执行
    return nil
}

这个例子里，transfer函数确保了转账操作的原子性：如果任何一步失败（比如余额不足或者数据库更新出错），整个转账都会被回滚，资金不会凭空消失或多出来。

除了基本的增删改查，Golang与SQLite结合还能实现哪些高级功能？

当然，Go和SQLite的结合远不止增删改查这么简单，还有一些更高级的功能和实践，能让你的应用更健壮、更易维护：

• 数据库Schema迁移（Schema Migration）：随着应用迭代，数据库表结构总会变化。手动修改SQL脚本管理版本非常容易出错。Schema迁移工具可以帮助你自动化这个过程，确保数据库结构与代码版本同步。像golang-migrate/migrate这样的库就是专门做这个的。它允许你编写独立的SQL脚本来定义每个版本的数据结构变化，然后工具会根据当前数据库版本自动执行或回滚这些脚本。对于生产环境的应用，这几乎是不可或缺的。
• 使用ORM或SQL构建器：对于更复杂的应用，手写大量的SQL语句可能会变得繁琐且容易出错。
  • ORM (Object-Relational Mapping)：如GORM、Bun等，它们允许你用Go结构体来定义数据库表，然后通过方法调用来执行CRUD操作，将SQL语句的生成

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~