Golang sqlhooks 使用指南

sqlhooks 是一个为 Go 的 database/sql 包添加钩子功能的插件库，它允许你在 SQL 查询执行前后插入自定义逻辑。

安装

go get github.com/gchaincl/sqlhooks

基本用法

1. 创建钩子

首先定义实现 sqlhooks.Hooks 接口的结构体：

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

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

// 定义钩子结构体
type MyHooks struct{}

// 实现 Before 方法
func (h *MyHooks) Before(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	fmt.Printf("Before> query: %s, args: %v\n", query, args)
	// 可以在上下文中存储开始时间
	return context.WithValue(ctx, "start", time.Now()), nil
}

// 实现 After 方法
func (h *MyHooks) After(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	// 从上下文中获取开始时间
	start := ctx.Value("start").(time.Time)
	duration := time.Since(start)
	fmt.Printf("After> query: %s, took: %v\n", query, duration)
	return ctx, nil
}

2. 注册驱动并连接数据库

func main() {
	// 注册带有钩子的驱动
	sql.Register("mysql-with-hooks", sqlhooks.Wrap(&mysql.MySQLDriver{}, &MyHooks{}))

	// 使用带钩子的驱动连接数据库
	db, err := sql.Open("mysql-with-hooks", "user:password@/dbname")
	if err != nil {
		panic(err)
	}
	defer db.Close()

	// 执行查询
	rows, err := db.Query("SELECT * FROM users WHERE id = ?", 1)
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	// 处理结果...
}

高级用法

1. 记录慢查询

type SlowQueryHook struct {
	Threshold time.Duration
}

func (h *SlowQueryHook) Before(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	return context.WithValue(ctx, "start", time.Now()), nil
}

func (h *SlowQueryHook) After(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	start := ctx.Value("start").(time.Time)
	duration := time.Since(start)
	
	if duration > h.Threshold {
		fmt.Printf("SLOW QUERY: %s (%v)\nArgs: %v\n", query, duration, args)
	}
	return ctx, nil
}

// 使用
sql.Register("mysql-slow-query", sqlhooks.Wrap(&mysql.MySQLDriver{}, &SlowQueryHook{
	Threshold: 100 * time.Millisecond,
}))

2. SQL 日志记录

type SQLLogger struct{}

func (l *SQLLogger) Before(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	log.Printf("Executing: %s\nWith args: %v", query, args)
	return ctx, nil
}

func (l *SQLLogger) After(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	return ctx, nil
}

3. SQL 分析

type SQLAnalyzer struct {
	stats map[string]time.Duration
	count map[string]int
}

func NewSQLAnalyzer() *SQLAnalyzer {
	return &SQLAnalyzer{
		stats: make(map[string]time.Duration),
		count: make(map[string]int),
	}
}

func (a *SQLAnalyzer) Before(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	return context.WithValue(ctx, "start", time.Now()), nil
}

func (a *SQLAnalyzer) After(ctx context.Context, query string, args ...interface{}) (context.Context, error) {
	start := ctx.Value("start").(time.Time)
	duration := time.Since(start)
	
	// 简化查询作为key
	key := simplifyQuery(query)
	
	a.stats[key] += duration
	a.count[key]++
	
	return ctx, nil
}

func (a *SQLAnalyzer) Report() {
	fmt.Println("SQL Query Analysis Report:")
	for query, total := range a.stats {
		avg := total / time.Duration(a.count[query])
		fmt.Printf("- %s: %d calls, total %v, avg %v\n", 
			query, a.count[query], total, avg)
	}
}

func simplifyQuery(query string) string {
	// 简化查询逻辑，去除具体参数值等
	return query
}

注意事项

1. sqlhooks 会为每个查询增加少量开销，生产环境中应谨慎使用性能敏感的钩子
2. 钩子中发生的错误会传播到主查询中
3. 对于高性能场景，可以考虑使用采样而不是记录所有查询

sqlhooks 是一个强大的工具，可以用于监控、分析、日志记录等多种场景，帮助开发者更好地理解和优化数据库访问模式。