QueryContext 内部实现解析

database/sql 包中的 QueryContext 方法内部实现涉及多个层次的协作，以下是其核心实现机制：

1. 整体流程

QueryContext 的基本工作流程如下：

1. 检查 Context 是否已被取消
2. 从连接池获取或创建新连接
3. 准备查询语句
4. 执行查询
5. 返回结果集

2. 关键实现细节

上下文监控

// 伪代码表示核心逻辑
func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
    // 首先检查上下文是否已取消
    if err := ctx.Err(); err != nil {
        return nil, err
    }

    // 获取数据库连接（会考虑上下文）
    dc, err := db.conn(ctx, strategy)
    if err != nil {
        return nil, err
    }

    // 执行查询（会监控上下文）
    return db.queryDC(ctx, dc, dc.releaseConn, nil, query, args)
}

连接获取与上下文整合

连接获取过程 (conn 方法) 会：

1. 启动一个 goroutine 监控上下文的取消信号
2. 同时尝试从连接池获取连接或建立新连接
3. 采用 select 等待最先发生的事件：

   select {
   case <-ctx.Done():
       // 上下文取消，返回错误
       return nil, ctx.Err()
   case conn := <-pool:
       // 获取到连接
       return conn, nil
   case <-time.After(timeout):
       // 获取连接超时
       return nil, ErrConnTimeout
   }

查询执行过程

实际查询执行 (queryDC 方法) 会：

1. 准备语句时检查上下文
2. 执行查询时启动后台 goroutine 监控上下文
3. 如果上下文被取消：
   • 向数据库服务器发送取消请求（如果驱动支持）
   • 关闭底层网络连接
   • 返回上下文错误

3. 驱动层实现

不同数据库驱动有各自的实现方式，但通常遵循以下模式：

MySQL 驱动示例

// 伪代码
func (mc *mysqlConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
    // 启动监控 goroutine
    done := make(chan struct{})
    defer close(done)

    go func() {
        select {
        case <-ctx.Done():
            // 取消查询
            mc.cancelQuery()
        case <-done:
            // 正常完成
        }
    }()

    // 执行实际查询
    return mc.query(query, args)
}

4. 超时处理机制

1. 网络IO超时：底层使用 net.Conn 的 SetDeadline 方法
2. 查询执行超时：通过上下文取消触发驱动特定的取消命令
3. 连接获取超时：由连接池管理，与上下文超时协同工作

5. 资源清理

任何时候如果上下文被取消：

1. 释放正在获取的连接回连接池
2. 关闭正在执行的查询的结果集
3. 释放所有相关资源

这种实现确保了即使查询被取消，也不会造成资源泄漏。

直接用orm不行吗

package main

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

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

func main() {
    db, err := sql.Open("mysql", "用户名:密码@(数据库ip)/数据库名")
    if err != nil {
        fmt.Println(err)
        return
    }

    ctx := context.Background()

    queryCtx, cancel := context.WithTimeout(ctx, 1*time.Second) // 设置超时时间为1秒
    defer cancel()

    begin := time.Now()

    _, err = db.QueryContext(queryCtx, "select sleep(3)") // db sleep 3秒，模拟超时情况
    end := time.Now()

    fmt.Println("查询耗时：", end.Sub(begin)) // 输出：查询耗时： 1.001157083s
    if err != nil {
        fmt.Println(err) // 输出超时错误：context deadline exceeded
    }
}