sqlDB, err := db.DB()
if err != nil {
    log.Fatal(err)
}

// 最大空闲连接数（建议：连接数 / 2）
sqlDB.SetMaxIdleConns(25)

// 最大打开连接数（建议：连接数）
sqlDB.SetMaxOpenConns(50)

// 连接最大生命周期（防止连接过期）
sqlDB.SetConnMaxLifetime(30 * time.Minute)

// 连接最大空闲时间（Go 1.15+）
sqlDB.SetConnMaxIdleTime(10 * time.Minute)

// 差：SELECT *
db.Find(&users)

// 好：只选需要的字段
db.Select("id", "name", "email").Find(&users)

// 更好：使用特定结构体
type UserListItem struct {
    ID   uint
    Name string
}
var items []UserListItem
db.Model(&User{}).Find(&items)

// 分页必须加 Limit
db.Offset(0).Limit(100).Find(&users)

// 列表页限制最大数量
db.Limit(1000).Find(&users)

// 差：N+1
var users []User
db.Find(&users)
for _, u := range users {
    db.Model(&u).Related(&u.Orders)  // N 次查询
}

// 好：使用 Preload
db.Preload("Orders").Find(&users)  // 2 次查询

// 更好：使用 Join（数据量小时）
db.Joins("Orders").Find(&users)  // 1 次查询

// 限制关联数据数量
db.Preload("Orders", func(db *gorm.DB) *gorm.DB {
    return db.Order("created_at DESC").Limit(10)
}).Find(&users)

// 只预加载有效订单
db.Preload("Orders", "status = ?", OrderStatusActive).Find(&users)

// 多层预加载优化
db.Preload("Orders.Items", func(db *gorm.DB) *gorm.DB {
    return db.Select("id", "order_id", "product_name", "price")
}).Find(&users)

// 差：逐条插入
for _, user := range users {
    db.Create(&user)  // N 次 INSERT
}

// 好：批量插入
db.CreateInBatches(users, 100)  // 每 100 条一批

// 更好：原生 SQL 批量插入
db.Exec("INSERT INTO users (name, email) VALUES (?, ?), (?, ?), ...", values...)

// 使用 Case When 批量更新
db.Model(&User{}).Where("id IN ?", ids).Update("status", 2)

// 批量 Upsert（MySQL）
db.Clauses(clause.OnConflict{
    Columns:   []clause.Column{{Name: "id"}},
    DoUpdates: clause.AssignmentColumns([]string{"name", "age", "updated_at"}),
}).Create(&users)

import "github.com/patrickmn/go-cache"

var cache = cache.New(5*time.Minute, 10*time.Minute)

func GetUserWithCache(db *gorm.DB, id uint) (*User, error) {
    key := fmt.Sprintf("user:%d", id)
    
    if cached, found := cache.Get(key); found {
        return cached.(*User), nil
    }
    
    var user User
    if err := db.First(&user, id).Error; err != nil {
        return nil, err
    }
    
    cache.Set(key, &user, cache.DefaultExpiration)
    return &user, nil
}

func QueryWithCache(db *gorm.DB, key string, dest interface{}, queryFunc func(*gorm.DB) error) error {
    // 从 Redis 获取
    if data, err := redis.Get(key).Result(); err == nil {
        return json.Unmarshal([]byte(data), dest)
    }
    
    // 查询数据库
    if err := queryFunc(db); err != nil {
        return err
    }
    
    // 写入缓存
    if data, err := json.Marshal(dest); err == nil {
        redis.Set(key, data, 5*time.Minute)
    }
    
    return nil
}

type User struct {
    ID        uint   `gorm:"primaryKey"`
    Email     string `gorm:"uniqueIndex"`  // 唯一查询
    Name      string `gorm:"index"`        // 普通查询
    Status    int    `gorm:"index:idx_status_created"`  // 复合索引前缀
    CreatedAt int64  `gorm:"index:idx_status_created"`  // 复合索引
}

// 查询超时控制
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

if err := db.WithContext(ctx).Find(&users).Error; err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        // 查询超时处理
    }
}

// 慢查询阈值
newLogger := logger.New(
    log.New(os.Stdout, "\r\n", log.LstdFlags),
    logger.Config{
        SlowThreshold: 100 * time.Millisecond,  // 慢查询阈值
        LogLevel:      logger.Warn,
    },
)

// 默认启用，可禁用
// MySQL 需要设置 interpolateParams=false

dsn := "user:pass@tcp(localhost:3306)/db?charset=utf8mb4&parseTime=True&loc=Local&interpolateParams=false"

// GORM 自动缓存 Prepared Statement
// 可通过配置控制
sqlDB, _ := db.DB()
sqlDB.SetConnMaxLifetime(time.Hour)  // 避免连接过期导致 Statement 失效

import "gorm.io/plugin/dbresolver"

db.Use(dbresolver.Register(dbresolver.Config{
    Sources: []gorm.Dialector{mysql.Open("write_dsn")},
    Replicas: []gorm.Dialector{
        mysql.Open("read_dsn_1"),
        mysql.Open("read_dsn_2"),
    },
    Policy: dbresolver.RandomPolicy{},
}))

// 自动路由：写操作走 Sources，读操作走 Replicas
db.Create(&user)    // 写
db.Find(&users)    // 读

import "github.com/wei840222/gorm-prom"

db.Use(gormprom.New(gormprom.Config{
    DBName: "mydb",
}))

type QueryMetrics struct {
    QueryCount    prometheus.Counter
    QueryDuration prometheus.Histogram
}

func (m *QueryMetrics) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
    sql, rows := fc()
    duration := time.Since(begin)
    
    m.QueryCount.Inc()
    m.QueryDuration.Observe(duration.Seconds())
    
    if duration > 100*time.Millisecond {
        log.Printf("慢查询: %s, 耗时: %v", sql, duration)
    }
}

func BenchmarkCreate(b *testing.B) {
    db, _ := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
    db.AutoMigrate(&User{})
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        db.Create(&User{Name: "test"})
    }
}

func BenchmarkBatchCreate(b *testing.B) {
    db, _ := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
    db.AutoMigrate(&User{})
    
    users := make([]User, 100)
    for i := range users {
        users[i] = User{Name: fmt.Sprintf("test%d", i)}
    }
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        db.CreateInBatches(users, 100)
    }
}

// 优化前检查项
type PerformanceChecklist struct {
    ConnectionPool   bool  // 连接池配置是否合理
    IndexUsage       bool  // 查询是否使用索引
    NPlus1           bool  // 是否存在 N+1 问题
    SelectFields     bool  // 是否只查询必要字段
    BatchSize        bool  // 批量操作批次大小
    CacheEnabled     bool  // 热点数据是否缓存
    TimeoutSet       bool  // 是否设置查询超时
    SlowQueryLog     bool  // 是否启用慢查询日志
}