1

var users = []string{"Alice", "Bob"} // 内存里的数组，关机就没了

1
2

// 写入到文件
os.WriteFile("data.txt", []byte("Alice\nBob\n"), 0644)

1
2
3
4

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"  // 匿名导入，注册MySQL驱动
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
    "database/sql"
    "fmt"
    // 匿名导入执行驱动注册
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    // 此时mysql驱动已经注册，可以使用了
    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/testdb")
    if err != nil {
        fmt.Println("打开数据库失败:", err)
        return
    }
    defer db.Close()
    fmt.Println("数据库连接已创建（实际连接可能尚未建立）")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func main() {
    // DSN: Data Source Name，数据库连接字符串
    dsn := "user:password@tcp(localhost:3306)/testdb?charset=utf8mb4"
    
    // sql.Open 返回 *DB 对象，此时并没有真正连接数据库
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("打开数据库失败:", err)
        return
    }
    defer db.Close()
    
    fmt.Println("DB对象已创建，实际网络连接尚未建立")
    fmt.Println("真正的连接会在第一次执行Query/Exec时建立")
}

1
2
3
4

// 常见的DSN格式
// MySQL: "user:password@tcp(localhost:3306)/dbname?charset=utf8mb4"
// PostgreSQL: "host=localhost port=5432 user=postgres password=secret dbname=test"
// SQLite: "test.db"  // 文件路径即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func main() {
    dsn := "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // Ping 检查连接是否可用
    if err := db.Ping(); err != nil {
        fmt.Println("数据库连接失败:", err)
        return
    }
    fmt.Println("数据库连接正常！")
}

1
2
3
4
5
6
7
8

// 实际项目中可以这样用
func checkDB(db *sql.DB) error {
    if err := db.Ping(); err != nil {
        // 记录日志并告警
        return fmt.Errorf("数据库连接异常: %w", err)
    }
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 设置最大打开连接数为10
    // 超过10个并发请求时，第11个会等待前面的释放连接
    db.SetMaxOpenConns(10)
    
    fmt.Println("最大并发连接数已设置为10")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 设置最大空闲连接数为5
    // 当连接用完归还后，池子里最多保留5个空闲连接
    db.SetMaxIdleConns(5)
    
    // 设置空闲连接的最大存活时间（后面会讲）
    db.SetConnMaxLifetime(5 * time.Minute)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 设置连接最大存活时间为1小时
    // 任何连接存活超过1小时后都会被关闭
    db.SetConnMaxLifetime(1 * time.Hour)
    
    fmt.Println("连接最大生命周期设置为1小时")
}

1
2
3
4

// 错误示例：设置了MaxLifetime但没有设置MaxIdleConns
db.SetConnMaxLifetime(5 * time.Minute)
// 如果MaxIdleConns是默认值2，创建5分钟后这两个连接会过期
// 下次请求时会创建新连接，导致连接数翻倍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 设置最大连接数为2，用于演示
    db.SetMaxOpenConns(2)
    db.SetMaxIdleConns(2)
    
    // 模拟3个请求
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            start := time.Now()
            
            // 从连接池获取连接（最多等30秒）
            ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
            defer cancel()
            
            // 假设执行一个耗时查询
            rows, err := db.QueryContext(ctx, "SELECT SLEEP(3)")
            if err != nil {
                fmt.Printf("请求%d: 获取连接失败: %v\n", id, err)
                return
            }
            rows.Close()
            
            fmt.Printf("请求%d: 耗时 %v\n", id, time.Since(start))
        }(i)
    }
    
    wg.Wait()
    fmt.Println("所有请求完成")
}

1
2
3
4
5

// 给每个数据库操作设置超时
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE id = ?", userID)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // Query 执行查询，返回 *Rows
    rows, err := db.Query("SELECT id, name, age FROM users WHERE age > ?", 18)
    if err != nil {
        panic(err)
    }
    defer rows.Close()  // 重要：关闭rows释放连接
    
    // 遍历结果
    for rows.Next() {
        var id int
        var name string
        var age int
        
        // Scan 将当前行的数据扫描到变量中
        if err := rows.Scan(&id, &name, &age); err != nil {
            panic(err)
        }
        fmt.Printf("用户: ID=%d, 姓名=%s, 年龄=%d\n", id, name, age)
    }
    
    // 检查遍历是否有错误
    if err := rows.Err(); err != nil {
        panic(err)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // QueryRow 查询单行，返回 *Row
    var name string
    var age int
    
    // 查询ID为1的用户
    err := db.QueryRow("SELECT name, age FROM users WHERE id = ?", 1).Scan(&name, &age)
    if err != nil {
        if err == sql.ErrNoRows {
            fmt.Println("没找到这个用户")
        } else {
            panic(err)
        }
        return
    }
    
    fmt.Printf("查到的用户: 姓名=%s, 年龄=%d\n", name, age)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    rows, err := db.Query("SELECT id, name, email, created_at FROM users LIMIT 1")
    if err != nil {
        panic(err)
    }
    defer rows.Close()
    
    if rows.Next() {
        var (
            id        int
            name      string
            email     sql.NullString  // 允许NULL的字段
            createdAt time.Time
        )
        
        // Scan 按列顺序将数据扫描到变量
        // 顺序必须和SELECT的列顺序一致！
        err := rows.Scan(&id, &name, &email, &createdAt)
        if err != nil {
            panic(err)
        }
        
        fmt.Printf("ID: %d\n", id)
        fmt.Printf("姓名: %s\n", name)
        fmt.Printf("邮箱: %v (Valid=%v)\n", email.String, email.Valid)
        fmt.Printf("创建时间: %v\n", createdAt)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    rows, err := db.Query("SELECT id, name FROM users LIMIT 5")
    if err != nil {
        panic(err)
    }
    defer rows.Close()
    
    // Next 返回true表示有下一行数据
    // 返回false表示已经遍历完所有行
    for rowNum := 1; rows.Next(); rowNum++ {
        var id int
        var name string
        
        if err := rows.Scan(&id, &name); err != nil {
            panic(err)
        }
        fmt.Printf("第%d行: ID=%d, 姓名=%s\n", rowNum, id, name)
    }
    
    // 重要：检查遍历过程中是否有错误
    if err := rows.Err(); err != nil {
        panic(err)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 错误示例：没有检查Next的返回值
rows, _ := db.Query("SELECT id FROM users")
for {
    var id int
    rows.Scan(&id)  // 可能扫描到空行或出错
    fmt.Println(id)
    if !rows.Next() {
        break
    }
}

// 正确写法：for循环直接使用Next作为条件
rows, _ := db.Query("SELECT id FROM users")
for rows.Next() {
    var id int
    rows.Scan(&id)
    fmt.Println(id)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    rows, err := db.Query("SELECT name FROM users")
    if err != nil {
        panic(err)
    }
    
    // defer rows.Close() 是最佳实践
    // 确保无论函数怎么退出，连接都会被释放
    defer rows.Close()
    
    for rows.Next() {
        var name string
        rows.Scan(&name)
        fmt.Println(name)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 这段代码有内存泄漏风险
func badQuery() {
    db, _ := sql.Open("mysql", "dsn")
    
    for {
        rows, _ := db.Query("SELECT ...")  // 不关闭
        // 处理rows...
        // 连接永远不会被释放！
    }
}

1
2
3
4
5
6
7

rows, err := db.Query("SELECT ...")
if err != nil {
    return err
}
defer rows.Close()  // defer是Go的"保险"机制

// 使用rows...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    var name string
    // 查询一个不存在的用户
    err := db.QueryRow("SELECT name FROM users WHERE id = ?", 99999).Scan(&name)
    
    if err != nil {
        if err == sql.ErrNoRows {
            // QueryRow 没查到任何记录
            fmt.Println("用户不存在（没有找到匹配的记录）")
        } else {
            // 其他错误（数据库连接失败等）
            fmt.Println("查询出错:", err)
        }
        return
    }
    
    fmt.Println("查到的用户:", name)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func getUserName(db *sql.DB, id int) (string, error) {
    var name string
    err := db.QueryRow("SELECT name FROM users WHERE id = ?", id).Scan(&name)
    
    if err != nil {
        if err == sql.ErrNoRows {
            return "", fmt.Errorf("用户%d不存在", id)
        }
        return "", fmt.Errorf("查询用户%d失败: %w", id, err)
    }
    
    return name, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 执行INSERT
    result, err := db.Exec(
        "INSERT INTO users (name, age, email) VALUES (?, ?, ?)",
        "张三", 25, "zhangsan@example.com",
    )
    if err != nil {
        panic(err)
    }
    
    // 获取插入的ID和影响行数（后面会详细讲）
    id, _ := result.LastInsertId()
    fmt.Printf("插入成功，ID=%d\n", id)
    
    // 执行UPDATE
    affected, _ := result.RowsAffected()
    fmt.Printf("受影响行数=%d\n", affected)
    
    // 执行UPDATE
    result, err = db.Exec(
        "UPDATE users SET age = ? WHERE name = ?",
        26, "张三",
    )
    if err != nil {
        panic(err)
    }
    rowsAffected, _ := result.RowsAffected()
    fmt.Printf("更新了%d行\n", rowsAffected)
    
    // 执行DELETE
    result, err = db.Exec("DELETE FROM users WHERE name = ?", "张三")
    if err != nil {
        panic(err)
    }
    rowsAffected, _ = result.RowsAffected()
    fmt.Printf("删除了%d行\n", rowsAffected)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 先创建一个测试表
    db.Exec("CREATE TABLE IF NOT EXISTS products (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))")
    
    // INSERT - 获取自增ID
    result, err := db.Exec("INSERT INTO products (name) VALUES (?)", "手机")
    if err != nil {
        panic(err)
    }
    
    // LastInsertId 返回插入的自增ID
    // 注意：只有自增ID的INSERT才能获取到
    id, err := result.LastInsertId()
    if err != nil {
        panic(err)
    }
    fmt.Printf("插入的产品ID: %d\n", id)
    
    // UPDATE/DELETE - 获取影响行数
    result, err = db.Exec("UPDATE products SET name = ? WHERE id = ?", "智能手机", id)
    if err != nil {
        panic(err)
    }
    
    // RowsAffected 返回受影响的行数
    affected, err := result.RowsAffected()
    if err != nil {
        panic(err)
    }
    fmt.Printf("更新了%d行\n", affected)
    
    // 再次更新（内容没变）
    result, err = db.Exec("UPDATE products SET name = ? WHERE id = ?", "智能手机", id)
    affected, _ = result.RowsAffected()
    fmt.Printf("再次更新（无变化），受影响行数: %d\n", affected)  // 仍然是1，因为WHERE条件仍匹配
    
    // 清理测试表
    db.Exec("DROP TABLE products")
}

1
2
3
4
5
6
7
8

// LastInsertId 可能返回0或错误，如果：
// 1. 插入的表没有自增主键
// 2. 使用的是批量插入（只有第一个ID会被返回）
// 3. 驱动不支持该功能

// RowsAffected 可能和预期不符，如果：
// 1. UPDATE的WHERE条件没有匹配到任何行（返回0）
// 2. UPDATE前后值一样（MySQL可能返回0，因为没有实际修改）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 创建预编译语句
    // ? 是占位符，会在执行时替换
    stmt, err := db.Prepare("INSERT INTO users (name, age) VALUES (?, ?)")
    if err != nil {
        panic(err)
    }
    defer stmt.Close()  // 记得关闭预编译语句
    
    // 多次执行同一语句，每次传入不同的参数
    users := [][2]interface{}{
        {"Alice", 20},
        {"Bob", 25},
        {"Charlie", 30},
    }
    
    for _, user := range users {
        result, err := stmt.Exec(user[0], user[1])
        if err != nil {
            panic(err)
        }
        id, _ := result.LastInsertId()
        fmt.Printf("插入用户 %s，ID=%d\n", user[0], id)
    }
    
    // 清理
    db.Exec("DELETE FROM users WHERE name IN (?, ?, ?)", "Alice", "Bob", "Charlie")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 开启事务
    tx, err := db.Begin()
    if err != nil {
        panic(err)
    }
    
    // 在事务中执行操作
    _, err = tx.Exec("INSERT INTO accounts (name, balance) VALUES (?, ?)", "张三", 1000)
    if err != nil {
        // 出错了，回滚事务
        tx.Rollback()
        panic(err)
    }
    
    _, err = tx.Exec("INSERT INTO accounts (name, balance) VALUES (?, ?)", "李四", 500)
    if err != nil {
        tx.Rollback()
        panic(err)
    }
    
    // 所有操作成功，提交事务
    err = tx.Commit()
    if err != nil {
        panic(err)
    }
    
    fmt.Println("事务提交成功！")
}

1
2
3
4
5
6
7
8

// BeginTx 支持更多选项
tx, err := db.BeginTx(
    context.Background(),
    &sql.TxOptions{
        Isolation: sql.LevelRepeatableRead,  // 设置隔离级别
        ReadOnly: false,                     // 是否只读
    },
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

func transferMoney(db *sql.DB, from string, to string, amount float64) error {
    // 开启事务
    tx, err := db.Begin()
    if err != nil {
        return fmt.Errorf("开启事务失败: %w", err)
    }
    
    // 标记一个退出点，任何错误都会触发回滚
    var success bool
    defer func() {
        if !success {
            tx.Rollback()  // 即使.Commit()失败，Rollback()也是安全的
        }
    }()
    
    // 扣钱
    result, err := tx.Exec("UPDATE accounts SET balance = balance - ? WHERE name = ?", amount, from)
    if err != nil {
        return fmt.Errorf("扣款失败: %w", err)
    }
    if affected, _ := result.RowsAffected(); affected == 0 {
        return fmt.Errorf("付款账户不存在或余额不足")
    }
    
    // 加钱
    _, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE name = ?", amount, to)
    if err != nil {
        return fmt.Errorf("收款失败: %w", err)
    }
    
    // 提交事务
    if err := tx.Commit(); err != nil {
        return fmt.Errorf("提交事务失败: %w", err)
    }
    
    success = true  // 标记事务成功
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 常见陷阱：忘记回滚
func badExample() {
    tx, _ := db.Begin()
    // ... 执行操作 ...
    if someError {
        tx.Rollback()  // 这里return了就不会Commit
        return
    }
    tx.Commit()  // 如果上面没回滚，这里会Commit
}

// 推荐写法：defer自动处理
func goodExample() {
    tx, _ := db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
            panic(r)  // 重新抛出panic
        }
    }()
    // ... 执行操作 ...
    tx.Commit()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // ReadUncommitted - 最低级别，可能读到未提交的数据（脏读）
    tx1, _ := db.BeginTx(context.Background(), &sql.TxOptions{
        Isolation: sql.LevelReadUncommitted,
    })
    
    // ReadCommitted - 只有提交后的数据才能被读到（防止脏读，但可能有不可重复读）
    tx2, _ := db.BeginTx(context.Background(), &sql.TxOptions{
        Isolation: sql.LevelReadCommitted,
    })
    
    // RepeatableRead - 保证同一事务中多次读取结果一致（防止不可重复读）
    tx3, _ := db.BeginTx(context.Background(), &sql.TxOptions{
        Isolation: sql.LevelRepeatableRead,
    })
    
    // Serializable - 最高级别，完全串行化（防止幻读，但性能最差）
    tx4, _ := db.BeginTx(context.Background(), &sql.TxOptions{
        Isolation: sql.LevelSerializable,
    })
    
    // 使用完关闭事务
    tx1.Rollback()
    tx2.Rollback()
    tx3.Rollback()
    tx4.Rollback()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

func main() {
    db, err := sql.Open("mysql", "root:root@tcp(localhost:3306)/testdb?charset=utf8mb4")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 创建测试表，其中email允许NULL
    db.Exec("CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(50), email VARCHAR(50))")
    db.Exec("DELETE FROM users")
    db.Exec("INSERT INTO users (id, name, email) VALUES (1, 'Alice', 'alice@example.com')")
    db.Exec("INSERT INTO users (id, name, email) VALUES (2, 'Bob', NULL)")           // NULL
    db.Exec("INSERT INTO users (id, name, email) VALUES (3, 'Charlie', 'charlie@example.com')")
    
    rows, err := db.Query("SELECT id, name, email FROM users ORDER BY id")
    if err != nil {
        panic(err)
    }
    defer rows.Close()
    
    fmt.Println("用户列表：")
    for rows.Next() {
        var (
            id    int
            name  string
            email sql.NullString  // 专门处理NULL的类型
        )
        
        rows.Scan(&id, &name, &email)
        
        // 检查是否为NULL
        if email.Valid {
            fmt.Printf("ID=%d, 姓名=%s, 邮箱=%s\n", id, name, email.String)
        } else {
            fmt.Printf("ID=%d, 姓名=%s, 邮箱=<未填写>\n", id, name)
        }
    }
    
    // 其他可空类型
    var nullInt sql.NullInt64       // 相当于 Go的 int64?（可空）
    var nullBool sql.NullBool       // 相当于 Go的 bool?
    var nullFloat sql.NullFloat64   // 相当于 Go的 float64?
    var nullTime sql.NullTime       // 相当于 Go的 time.Time?
    var nullByte sql.NullByte       // 相当于 Go的 byte?
    
    _ = nullInt
    _ = nullBool
    _ = nullFloat
    _ = nullTime
    _ = nullByte
    
    // 清理测试表
    db.Exec("DROP TABLE users")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 如果直接用string扫描NULL列
var email string
rows.Scan(&email)  // 会出错！因为Go的string不能是nil

// 使用NullString
var email sql.NullString
rows.Scan(&email)  // OK
if email.Valid {
    fmt.Println(email.String)  // 有值
} else {
    fmt.Println("NULL")        // 空值
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/*
driver包的核心接口定义（简化版）

// Driver 是数据库驱动必须实现的接口
type Driver interface {
    Open(name string) (Conn, error)  // 打开一个新连接
}

// Conn 代表一个数据库连接
type Conn interface {
    Prepare(query string) (Stmt, error)      // 准备预编译语句
    Close() error                             // 关闭连接
    Begin() (Tx, error)                       // 开始事务
}

// Stmt 代表一个预编译语句
type Stmt interface {
    Close() error                      // 关闭语句
    NumInput() int                     // 返回占位符数量
    Exec(args []Value) (Result, error) // 执行（INSERT/UPDATE/DELETE）
    Query(args []Value) (Rows, error)  // 查询（SELECT）
}

// Tx 代表一个事务
type Tx interface {
    Commit() error       // 提交
    Rollback() error     // 回滚
}

// Rows 代表查询结果集
type Rows interface {
    Columns() []string   // 返回列名
    Close() error        // 关闭游标
    Next(dest []Value) error  // 移动到下一行
}

// Result 是执行INSERT/UPDATE/DELETE的结果
type Result interface {
    LastInsertId() (int64, error)    // 插入的ID
    RowsAffected() (int64, error)    // 影响的行数
}
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package mydriver

import (
    "database/sql"
    "database/sql/driver"
    "fmt"
)

// 注册驱动（驱动包init函数会自动调用）
func init() {
    sql.Register("mydriver", &MyDriver{})
}

// 实现Driver接口
type MyDriver struct{}

func (d *MyDriver) Open(dsn string) (driver.Conn, error) {
    fmt.Printf("连接数据库: %s\n", dsn)
    return &MyConn{}, nil
}

// 实现Conn接口
type MyConn struct{}

func (c *MyConn) Prepare(query string) (driver.Stmt, error) {
    return &MyStmt{query: query}, nil
}

func (c *MyConn) Close() error {
    return nil
}

func (c *MyConn) Begin() (driver.Tx, error) {
    return &MyTx{}, nil
}

// 实现Stmt接口
type MyStmt struct {
    query string
}

func (s *MyStmt) Close() error { return nil }
func (s *MyStmt) NumInput() int { return 0 }
func (s *MyStmt) Exec(args []driver.Value) (driver.Result, error) {
    return &MyResult{}, nil
}
func (s *MyStmt) Query(args []driver.Value) (driver.Rows, error) {
    return &MyRows{}, nil
}

// 实现Tx接口
type MyTx struct{}

func (t *MyTx) Commit() error { return nil }
func (t *MyTx) Rollback() error { return nil }

// 实现Result接口
type MyResult struct{}

func (r *MyResult) LastInsertId() (int64, error) { return 1, nil }
func (r *MyResult) RowsAffected() (int64, error) { return 1, nil }

// 实现Rows接口
type MyRows struct{}

func (r *MyRows) Columns() []string { return nil }
func (r *MyRows) Close() error { return nil }
func (r *MyRows) Next(dest []driver.Value) error { return nil }

// 使用自定义驱动
func ExampleUsage() {
    // import _ "mydriver"
    // db, _ := sql.Open("mydriver", "dsn")
    fmt.Println("驱动已注册，可通过 sql.Open 使用")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

rows, err := db.Query("SELECT ...")
if err != nil {
    return err
}
defer rows.Close()

for rows.Next() {
    // 处理当前行
    rows.Scan(&var1, &var2)
}
// 记得检查Err
if err := rows.Err(); err != nil {
    return err
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

tx, err := db.Begin()
if err != nil {
    return err
}

// 执行操作
_, err = tx.Exec("INSERT ...", ...)
if err != nil {
    tx.Rollback()
    return err
}

err = tx.Commit()

1

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