// ❌ 差：每条 INSERT 一个事务（每条都触发 Raft 复制）
func badInsert(db *sql.DB, records []Record) error {
    for _, r := range records {
        _, err := db.Exec("INSERT INTO logs (msg) VALUES (?)", r.Msg)
        if err != nil {
            return err
        }
    }
    return nil
}
// 1000 条记录 = 1000 次 Raft 复制 ≈ 1000-5000ms

// ✅ 好：所有 INSERT 在一个事务中（一次 Raft 复制）
func goodInsert(db *sql.DB, records []Record) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    stmt, err := tx.Prepare("INSERT INTO logs (msg) VALUES (?)")
    if err != nil {
        return err
    }
    defer stmt.Close()

    for _, r := range records {
        if _, err := stmt.Exec(r.Msg); err != nil {
            return err
        }
    }

    return tx.Commit()
}
// 1000 条记录 = 1 次 Raft 复制 ≈ 2-10ms

func streamInsert(ctx context.Context, db *sql.DB, ch <-chan Record, batchSize int) error {
    batch := make([]Record, 0, batchSize)

    flush := func() error {
        if len(batch) == 0 {
            return nil
        }

        tx, err := db.BeginTx(ctx, nil)
        if err != nil {
            return err
        }
        defer tx.Rollback()

        stmt, err := tx.PrepareContext(ctx,
            "INSERT INTO records (data, timestamp) VALUES (?, ?)")
        if err != nil {
            return err
        }
        defer stmt.Close()

        for _, r := range batch {
            if _, err := stmt.ExecContext(ctx, r.Data, r.Timestamp); err != nil {
                return err
            }
        }

        if err := tx.Commit(); err != nil {
            return err
        }

        batch = batch[:0] // 重置切片
        return nil
    }

    for {
        select {
        case record, ok := <-ch:
            if !ok {
                return flush() // 通道关闭，刷新最后一批
            }
            batch = append(batch, record)
            if len(batch) >= batchSize {
                if err := flush(); err != nil {
                    return err
                }
            }
        case <-ctx.Done():
            return ctx.Err()
        }
    }
}

// ❌ 差：每次执行都编译 SQL
func badQuery(db *sql.DB) {
    for i := 0; i < 1000; i++ {
        db.Exec("INSERT INTO test (val) VALUES (?)", i)
    }
}

// ✅ 好：预编译一次，多次执行
func goodQuery(db *sql.DB) {
    stmt, err := db.Prepare("INSERT INTO test (val) VALUES (?)")
    if err != nil {
        log.Fatal(err)
    }
    defer stmt.Close()

    for i := 0; i < 1000; i++ {
        stmt.Exec(i)
    }
}

// Follower 读取配置（通过 go-dqlite driver option）
drv, err := driver.New(nodeStore,
    driver.WithDialFunc(func(ctx context.Context, address string) (net.Conn, error) {
        // 自定义连接逻辑，可以选择连接到 Follower
        return net.Dial("tcp", address)
    }),
)

// ❌ 差：SELECT * 返回所有列
rows, _ := db.Query("SELECT * FROM users WHERE status = 'active'")

// ✅ 好：只查询需要的列
rows, _ := db.Query("SELECT id, name, email FROM users WHERE status = 'active'")

// ✅ 好：使用 LIMIT 限制返回行数
rows, _ := db.Query("SELECT id, name FROM users ORDER BY created_at DESC LIMIT 100")

// ✅ 好：使用索引覆盖查询
// 创建覆盖索引
db.Exec("CREATE INDEX idx_users_status_name ON users(status, name)")
// 查询只需扫描索引
rows, _ = db.Query("SELECT name FROM users WHERE status = 'active'")

// 创建有效的索引
_, err := db.Exec(`
    -- 常用查询索引
    CREATE INDEX IF NOT EXISTS idx_orders_customer_date
        ON orders(customer_id, created_at DESC);

    -- 覆盖索引（包含查询所需的所有列）
    CREATE INDEX IF NOT EXISTS idx_orders_covering
        ON orders(customer_id, status)
        INCLUDE (total, created_at);

    -- 部分索引（只索引符合条件的行）
    CREATE INDEX IF NOT EXISTS idx_orders_active
        ON orders(customer_id)
        WHERE status = 'active';
`)

// 查看查询计划
rows, _ := db.Query("EXPLAIN QUERY PLAN SELECT * FROM orders WHERE customer_id = ?")
// 输出应包含 "USING INDEX" 以确认使用了索引

db := sql.OpenDB(drv)

// 根据场景调整连接池
db.SetMaxOpenConns(10)        // 最大连接数
db.SetMaxIdleConns(5)         // 空闲连接数
db.SetConnMaxLifetime(0)      // 连接不过期
db.SetConnMaxIdleTime(5 * time.Minute) // 空闲连接 5 分钟后关闭

// 优化 SQLite PRAGMA（在 dqlite 内部或通过连接设置）
pragmas := map[string]string{
    // 同步策略 - NORMAL 在 dqlite 场景下足够安全
    // 因为 Raft 日志已经提供了额外的持久化保证
    "synchronous": "NORMAL",

    // WAL 模式（dqlite 默认使用）
    "journal_mode": "WAL",

    // 缓存大小（页数，负值为 KB）
    "cache_size": "-8000", // 8MB

    // 临时表存储位置
    "temp_store": "MEMORY",

    // 内存映射 I/O（适用于数据量 < 内存的情况）
    "mmap_size": "268435456", // 256MB

    // 页面大小
    "page_size": "4096",

    // WAL 自动检查点阈值
    "wal_autocheckpoint": "1000",
}

for k, v := range pragmas {
    _, err := db.Exec(fmt.Sprintf("PRAGMA %s = %s", k, v))
    if err != nil {
        log.Printf("Warning: PRAGMA %s failed: %v", k, err)
    }
}

/* C API: 调整快照参数 */

/* 快照阈值：日志条目数量超过此值时触发快照 */
dqlite_node_set_snapshot_threshold(node, 1024);  /* 默认 1024 */

/* 快照后保留：快照完成后保留的最近日志条目数 */
dqlite_node_set_snapshot_trailing(node, 2048);  /* 默认 2048 */

// 设置缓存大小
db.Exec("PRAGMA cache_size = -16000") // 16MB

// 查看缓存使用情况
var cacheSize int
db.QueryRow("PRAGMA cache_size").Scan(&cacheSize)
fmt.Printf("Cache size: %d pages\n", cacheSize)

# Linux 系统级优化
# 增大 TCP 缓冲区
sysctl -w net.core.rmem_max=16777216
sysctl -w net.core.wmem_max=16777216
sysctl -w net.ipv4.tcp_rmem="4096 87380 16777216"
sysctl -w net.ipv4.tcp_wmem="4096 65536 16777216"

# 启用 TCP 快速打开
sysctl -w net.ipv4.tcp_fastopen=3

# 调整 TCP 拥塞控制
sysctl -w net.ipv4.tcp_congestion_control=bbr

package bench

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

func BenchmarkSingleInsert(b *testing.B) {
    db := setupDB(b)
    defer db.Close()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := db.Exec("INSERT INTO bench (val) VALUES (?)", i)
        if err != nil {
            b.Fatal(err)
        }
    }
}

func BenchmarkBatchInsert(b *testing.B) {
    batchSize := 100
    db := setupDB(b)
    defer db.Close()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        tx, _ := db.Begin()
        stmt, _ := tx.Prepare("INSERT INTO bench (val) VALUES (?)")
        for j := 0; j < batchSize; j++ {
            stmt.Exec(i*batchSize + j)
        }
        stmt.Close()
        tx.Commit()
    }
}

func BenchmarkSelect(b *testing.B) {
    db := setupDB(b)
    defer db.Close()

    // 预填充数据
    tx, _ := db.Begin()
    stmt, _ := tx.Prepare("INSERT INTO bench (val) VALUES (?)")
    for i := 0; i < 10000; i++ {
        stmt.Exec(i)
    }
    stmt.Close()
    tx.Commit()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        var val int
        db.QueryRow("SELECT val FROM bench WHERE id = ?", i%10000+1).Scan(&val)
    }
}

func BenchmarkConcurrentRead(b *testing.B) {
    db := setupDB(b)
    defer db.Close()

    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            var count int
            db.QueryRow("SELECT COUNT(*) FROM bench").Scan(&count)
        }
    })
}