4.3 分库分表策略：单表千万级数据如何高效查询？

少林码僧
2 阅读12分钟

4.3 分库分表策略：单表千万级数据如何高效查询？

在构建高并发、大数据量的分布式系统时，单表存储千万级甚至亿级数据会带来严重的性能问题。查询速度慢、索引效率低、锁竞争激烈等问题会严重影响系统的响应时间和吞吐量。分库分表是一种有效的解决方案，通过将数据分散到多个数据库和表中，可以显著提升系统的性能和可扩展性。本节将深入探讨分库分表的策略和实现方法。

分库分表基础概念

什么是分库分表？

分库分表是数据库水平拆分的两种方式：

  1. 分库（Sharding）：将数据按照一定规则分散到多个数据库实例中
  2. 分表（Partitioning）：将数据按照一定规则分散到同一个数据库的多个表中

分库分表的优势

  1. 提升性能：分散数据存储和查询压力，减少单点瓶颈
  2. 增强可扩展性：通过增加数据库实例和表来扩展存储容量
  3. 提高可用性：单个数据库或表的故障不会影响整个系统
  4. 优化资源利用：充分利用多台服务器的计算和存储资源

分库分表的挑战

  1. 事务一致性：跨库事务难以保证ACID特性
  2. 查询复杂性：跨库跨表查询实现复杂
  3. 数据迁移：重新分片时数据迁移困难
  4. 维护成本：系统复杂度增加，维护成本上升

分库分表策略

1. 哈希分片

哈希分片通过哈希函数将数据均匀分布到多个分片中。

// HashShardingRule 哈希分片规则
type HashShardingRule struct {
    // 分片键
    shardingKey string
    
    // 分片数量
    shardingCount int
    
    // 数据源列表
    dataSources []string
    
    // 表前缀
    tablePrefix string
}

// ShardingResult 分片结果
type ShardingResult struct {
    // 数据源
    DataSource string
    
    // 表名
    TableName string
    
    // 分片索引
    ShardIndex int
}

// NewHashShardingRule 创建哈希分片规则
func NewHashShardingRule(shardingKey string, shardingCount int, dataSources []string, tablePrefix string) *HashShardingRule {
    return &HashShardingRule{
        shardingKey:   shardingKey,
        shardingCount: shardingCount,
        dataSources:   dataSources,
        tablePrefix:   tablePrefix,
    }
}

// CalculateShard 计算分片
func (h *HashShardingRule) CalculateShard(key interface{}) (*ShardingResult, error) {
    // 将键转换为字符串
    keyStr := fmt.Sprintf("%v", key)
    
    // 计算哈希值
    var hashValue uint32
    hasher := fnv.New32a()
    if _, err := hasher.Write([]byte(keyStr)); err != nil {
        return nil, fmt.Errorf("failed to calculate hash: %w", err)
    }
    hashValue = hasher.Sum32()
    
    // 计算分片索引
    shardIndex := int(hashValue) % h.shardingCount
    
    // 计算数据源索引
    dataSourceIndex := shardIndex % len(h.dataSources)
    dataSource := h.dataSources[dataSourceIndex]
    
    // 计算表名
    tableName := fmt.Sprintf("%s_%d", h.tablePrefix, shardIndex)
    
    return &ShardingResult{
        DataSource: dataSource,
        TableName:  tableName,
        ShardIndex: shardIndex,
    }, nil
}

// GetShardIndexes 获取所有分片索引
func (h *HashShardingRule) GetShardIndexes() []int {
    indexes := make([]int, h.shardingCount)
    for i := 0; i < h.shardingCount; i++ {
        indexes[i] = i
    }
    return indexes
}

2. 范围分片

范围分片根据数据的范围将数据分布到不同的分片中。

// RangeShardingRule 范围分片规则
type RangeShardingRule struct {
    // 分片键
    shardingKey string
    
    // 范围配置
    ranges []*RangeConfig
    
    // 数据源列表
    dataSources []string
    
    // 表前缀
    tablePrefix string
}

// RangeConfig 范围配置
type RangeConfig struct {
    // 起始值
    Start interface{}
    
    // 结束值
    End interface{}
    
    // 分片索引
    ShardIndex int
}

// NewRangeShardingRule 创建范围分片规则
func NewRangeShardingRule(shardingKey string, ranges []*RangeConfig, dataSources []string, tablePrefix string) *RangeShardingRule {
    return &RangeShardingRule{
        shardingKey: shardingKey,
        ranges:      ranges,
        dataSources: dataSources,
        tablePrefix: tablePrefix,
    }
}

// CalculateShard 计算分片
func (r *RangeShardingRule) CalculateShard(key interface{}) (*ShardingResult, error) {
    shardIndex := -1
    
    // 根据键值查找对应的分片
    switch k := key.(type) {
    case int, int32, int64:
        keyValue := toInt64(k)
        for _, rng := range r.ranges {
            if toInt64(rng.Start) <= keyValue && keyValue <= toInt64(rng.End) {
                shardIndex = rng.ShardIndex
                break
            }
        }
    case string:
        for _, rng := range r.ranges {
            if str, ok := rng.Start.(string); ok && strings.Compare(str, k) <= 0 {
                if endStr, ok := rng.End.(string); ok && strings.Compare(k, endStr) <= 0 {
                    shardIndex = rng.ShardIndex
                    break
                }
            }
        }
    default:
        return nil, fmt.Errorf("unsupported key type: %T", key)
    }
    
    if shardIndex == -1 {
        return nil, fmt.Errorf("no shard found for key: %v", key)
    }
    
    // 计算数据源索引
    dataSourceIndex := shardIndex % len(r.dataSources)
    dataSource := r.dataSources[dataSourceIndex]
    
    // 计算表名
    tableName := fmt.Sprintf("%s_%d", r.tablePrefix, shardIndex)
    
    return &ShardingResult{
        DataSource: dataSource,
        TableName:  tableName,
        ShardIndex: shardIndex,
    }, nil
}

// GetShardIndexes 获取所有分片索引
func (r *RangeShardingRule) GetShardIndexes() []int {
    indexes := make([]int, 0, len(r.ranges))
    for _, rng := range r.ranges {
        indexes = append(indexes, rng.ShardIndex)
    }
    return indexes
}

// toInt64 将接口类型转换为int64
func toInt64(value interface{}) int64 {
    switch v := value.(type) {
    case int:
        return int64(v)
    case int32:
        return int64(v)
    case int64:
        return v
    default:
        return 0
    }
}

3. 标签分片

标签分片根据数据的标签属性将数据分布到不同的分片中。

// TagShardingRule 标签分片规则
type TagShardingRule struct {
    // 分片键
    shardingKey string
    
    // 标签到分片的映射
    tagToShard map[string]int
    
    // 数据源列表
    dataSources []string
    
    // 表前缀
    tablePrefix string
}

// NewTagShardingRule 创建标签分片规则
func NewTagShardingRule(shardingKey string, tagToShard map[string]int, dataSources []string, tablePrefix string) *TagShardingRule {
    return &TagShardingRule{
        shardingKey: shardingKey,
        tagToShard:  tagToShard,
        dataSources: dataSources,
        tablePrefix: tablePrefix,
    }
}

// CalculateShard 计算分片
func (t *TagShardingRule) CalculateShard(key interface{}) (*ShardingResult, error) {
    keyStr := fmt.Sprintf("%v", key)
    
    shardIndex, exists := t.tagToShard[keyStr]
    if !exists {
        return nil, fmt.Errorf("no shard found for tag: %s", keyStr)
    }
    
    // 计算数据源索引
    dataSourceIndex := shardIndex % len(t.dataSources)
    dataSource := t.dataSources[dataSourceIndex]
    
    // 计算表名
    tableName := fmt.Sprintf("%s_%d", t.tablePrefix, shardIndex)
    
    return &ShardingResult{
        DataSource: dataSource,
        TableName:  tableName,
        ShardIndex: shardIndex,
    }, nil
}

// GetShardIndexes 获取所有分片索引
func (t *TagShardingRule) GetShardIndexes() []int {
    indexes := make([]int, 0, len(t.tagToShard))
    for _, shardIndex := range t.tagToShard {
        indexes = append(indexes, shardIndex)
    }
    return indexes
}

分片路由管理

分片路由管理器负责根据分片规则将SQL路由到正确的分片。

// ShardingManager 分片管理器
type ShardingManager struct {
    // 分片规则
    shardingRules map[string]ShardingRule
    
    // 数据源管理器
    dataSourceManager *DataSourceManager
}

// ShardingRule 分片规则接口
type ShardingRule interface {
    // CalculateShard 计算分片
    CalculateShard(key interface{}) (*ShardingResult, error)
    
    // GetShardIndexes 获取所有分片索引
    GetShardIndexes() []int
}

// DataSourceManager 数据源管理器
type DataSourceManager struct {
    // 数据源映射
    dataSources map[string]*sql.DB
}

// NewShardingManager 创建分片管理器
func NewShardingManager(dataSourceManager *DataSourceManager) *ShardingManager {
    return &ShardingManager{
        shardingRules:     make(map[string]ShardingRule),
        dataSourceManager: dataSourceManager,
    }
}

// AddShardingRule 添加分片规则
func (sm *ShardingManager) AddShardingRule(tableName string, rule ShardingRule) {
    sm.shardingRules[tableName] = rule
}

// GetShardingRule 获取分片规则
func (sm *ShardingManager) GetShardingRule(tableName string) (ShardingRule, bool) {
    rule, exists := sm.shardingRules[tableName]
    return rule, exists
}

// Route 路由SQL到分片
func (sm *ShardingManager) Route(tableName string, shardingKey interface{}) (*ShardingResult, error) {
    rule, exists := sm.shardingRules[tableName]
    if !exists {
        return nil, fmt.Errorf("no sharding rule found for table: %s", tableName)
    }
    
    return rule.CalculateShard(shardingKey)
}

// ExecuteQuery 执行查询
func (sm *ShardingManager) ExecuteQuery(ctx context.Context, tableName string, shardingKey interface{}, query string, args ...interface{}) (*sql.Rows, error) {
    // 路由到分片
    shard, err := sm.Route(tableName, shardingKey)
    if err != nil {
        return nil, fmt.Errorf("failed to route query: %w", err)
    }
    
    // 获取数据源
    db, exists := sm.dataSourceManager.dataSources[shard.DataSource]
    if !exists {
        return nil, fmt.Errorf("data source not found: %s", shard.DataSource)
    }
    
    // 替换表名
    finalQuery := strings.Replace(query, tableName, shard.TableName, -1)
    
    // 执行查询
    return db.QueryContext(ctx, finalQuery, args...)
}

// ExecuteExec 执行更新
func (sm *ShardingManager) ExecuteExec(ctx context.Context, tableName string, shardingKey interface{}, query string, args ...interface{}) (sql.Result, error) {
    // 路由到分片
    shard, err := sm.Route(tableName, shardingKey)
    if err != nil {
        return nil, fmt.Errorf("failed to route exec: %w", err)
    }
    
    // 获取数据源
    db, exists := sm.dataSourceManager.dataSources[shard.DataSource]
    if !exists {
        return nil, fmt.Errorf("data source not found: %s", shard.DataSource)
    }
    
    // 替换表名
    finalQuery := strings.Replace(query, tableName, shard.TableName, -1)
    
    // 执行更新
    return db.ExecContext(ctx, finalQuery, args...)
}

分布式事务处理

分库分表后，跨库事务处理变得复杂，需要采用分布式事务解决方案。

// DistributedTransaction 分布式事务
type DistributedTransaction struct {
    // 事务ID
    ID string
    
    // 参与的分片
    shards []*ShardingResult
    
    // 数据源事务映射
    transactions map[string]*sql.Tx
    
    // 状态
    status TransactionStatus
    
    // 超时时间
    timeout time.Duration
}

// TransactionStatus 事务状态
type TransactionStatus int

const (
    // TransactionStatusActive 活动状态
    TransactionStatusActive TransactionStatus = iota
    
    // TransactionStatusCommitted 已提交
    TransactionStatusCommitted
    
    // TransactionStatusRolledBack 已回滚
    TransactionStatusRolledBack
    
    // TransactionStatusFailed 失败
    TransactionStatusFailed
)

// DistributedTransactionManager 分布式事务管理器
type DistributedTransactionManager struct {
    // 数据源管理器
    dataSourceManager *DataSourceManager
    
    // 事务超时时间
    transactionTimeout time.Duration
}

// NewDistributedTransactionManager 创建分布式事务管理器
func NewDistributedTransactionManager(dataSourceManager *DataSourceManager, timeout time.Duration) *DistributedTransactionManager {
    return &DistributedTransactionManager{
        dataSourceManager:  dataSourceManager,
        transactionTimeout: timeout,
    }
}

// Begin 开始分布式事务
func (dtm *DistributedTransactionManager) Begin(ctx context.Context, shards []*ShardingResult) (*DistributedTransaction, error) {
    tx := &DistributedTransaction{
        ID:          generateTransactionID(),
        shards:      shards,
        transactions: make(map[string]*sql.Tx),
        status:      TransactionStatusActive,
        timeout:     dtm.transactionTimeout,
    }
    
    // 为每个数据源开始事务
    for _, shard := range shards {
        if _, exists := tx.transactions[shard.DataSource]; !exists {
            db, exists := dtm.dataSourceManager.dataSources[shard.DataSource]
            if !exists {
                tx.Rollback()
                return nil, fmt.Errorf("data source not found: %s", shard.DataSource)
            }
            
            sqlTx, err := db.BeginTx(ctx, nil)
            if err != nil {
                tx.Rollback()
                return nil, fmt.Errorf("failed to begin transaction on %s: %w", shard.DataSource, err)
            }
            
            tx.transactions[shard.DataSource] = sqlTx
        }
    }
    
    return tx, nil
}

// Commit 提交分布式事务
func (dt *DistributedTransaction) Commit() error {
    if dt.status != TransactionStatusActive {
        return fmt.Errorf("transaction is not active")
    }
    
    // 两阶段提交的第一阶段：准备提交
    for dataSource, tx := range dt.transactions {
        // 在实际实现中，这里应该执行准备提交操作
        log.Printf("Preparing commit on data source: %s", dataSource)
    }
    
    // 两阶段提交的第二阶段：正式提交
    for dataSource, tx := range dt.transactions {
        if err := tx.Commit(); err != nil {
            dt.status = TransactionStatusFailed
            log.Printf("Failed to commit transaction on data source %s: %v", dataSource, err)
            // 在实际实现中，这里应该执行回滚操作
            return fmt.Errorf("failed to commit transaction on %s: %w", dataSource, err)
        }
        log.Printf("Committed transaction on data source: %s", dataSource)
    }
    
    dt.status = TransactionStatusCommitted
    return nil
}

// Rollback 回滚分布式事务
func (dt *DistributedTransaction) Rollback() error {
    if dt.status != TransactionStatusActive && dt.status != TransactionStatusFailed {
        return fmt.Errorf("transaction is not active or failed")
    }
    
    var errs []error
    for dataSource, tx := range dt.transactions {
        if err := tx.Rollback(); err != nil {
            errs = append(errs, fmt.Errorf("failed to rollback transaction on %s: %w", dataSource, err))
            continue
        }
        log.Printf("Rolled back transaction on data source: %s", dataSource)
    }
    
    dt.status = TransactionStatusRolledBack
    
    if len(errs) > 0 {
        return fmt.Errorf("rollback failed with errors: %v", errs)
    }
    
    return nil
}

// ExecuteInTransaction 在事务中执行操作
func (dtm *DistributedTransactionManager) ExecuteInTransaction(
    ctx context.Context,
    shards []*ShardingResult,
    fn func(*DistributedTransaction) error,
) error {
    // 开始分布式事务
    tx, err := dtm.Begin(ctx, shards)
    if err != nil {
        return fmt.Errorf("failed to begin distributed transaction: %w", err)
    }
    
    // 执行业务逻辑
    if err := fn(tx); err != nil {
        // 回滚事务
        if rollbackErr := tx.Rollback(); rollbackErr != nil {
            log.Printf("Failed to rollback transaction: %v", rollbackErr)
        }
        return fmt.Errorf("business logic failed: %w", err)
    }
    
    // 提交事务
    if err := tx.Commit(); err != nil {
        return fmt.Errorf("failed to commit transaction: %w", err)
    }
    
    return nil
}

跨分片查询处理

分库分表后，跨分片查询需要特殊处理。

// CrossShardQueryProcessor 跨分片查询处理器
type CrossShardQueryProcessor struct {
    // 分片管理器
    shardingManager *ShardingManager
    
    // 查询合并器
    resultMerger *ResultMerger
}

// ResultMerger 结果合并器
type ResultMerger struct {
    // 排序字段
    orderByFields []string
    
    // 是否去重
    distinct bool
    
    // 限制数量
    limit int
}

// QueryResult 查询结果
type QueryResult struct {
    // 数据行
    Rows []*QueryRow
    
    // 总数
    TotalCount int
}

// QueryRow 查询行
type QueryRow struct {
    // 列名到值的映射
    Values map[string]interface{}
}

// NewCrossShardQueryProcessor 创建跨分片查询处理器
func NewCrossShardQueryProcessor(shardingManager *ShardingManager) *CrossShardQueryProcessor {
    return &CrossShardQueryProcessor{
        shardingManager: shardingManager,
        resultMerger:    &ResultMerger{},
    }
}

// ExecuteCrossShardQuery 执行跨分片查询
func (csp *CrossShardQueryProcessor) ExecuteCrossShardQuery(
    ctx context.Context,
    tableName string,
    query string,
    args ...interface{},
) (*QueryResult, error) {
    // 获取分片规则
    rule, exists := csp.shardingManager.GetShardingRule(tableName)
    if !exists {
        return nil, fmt.Errorf("no sharding rule found for table: %s", tableName)
    }
    
    // 获取所有分片索引
    shardIndexes := rule.GetShardIndexes()
    
    // 并行查询所有分片
    results := make(chan *ShardQueryResult, len(shardIndexes))
    var wg sync.WaitGroup
    
    for _, shardIndex := range shardIndexes {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            result, err := csp.queryShard(ctx, tableName, index, query, args...)
            results <- &ShardQueryResult{
                ShardIndex: index,
                Result:     result,
                Error:      err,
            }
        }(shardIndex)
    }
    
    // 等待所有查询完成
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 收集查询结果
    var allRows []*QueryRow
    for shardResult := range results {
        if shardResult.Error != nil {
            log.Printf("Query shard %d failed: %v", shardResult.ShardIndex, shardResult.Error)
            continue
        }
        
        allRows = append(allRows, shardResult.Result.Rows...)
    }
    
    // 合并结果
    mergedResult := csp.resultMerger.Merge(allRows)
    
    return mergedResult, nil
}

// ShardQueryResult 分片查询结果
type ShardQueryResult struct {
    // 分片索引
    ShardIndex int
    
    // 查询结果
    Result *QueryResult
    
    // 错误
    Error error
}

// queryShard 查询单个分片
func (csp *CrossShardQueryProcessor) queryShard(
    ctx context.Context,
    tableName string,
    shardIndex int,
    query string,
    args ...interface{},
) (*QueryResult, error) {
    // 构造分片结果（简化实现）
    shard := &ShardingResult{
        DataSource: fmt.Sprintf("ds_%d", shardIndex%3), // 假设有3个数据源
        TableName:  fmt.Sprintf("%s_%d", tableName, shardIndex),
        ShardIndex: shardIndex,
    }
    
    // 获取数据源
    db, exists := csp.shardingManager.dataSourceManager.dataSources[shard.DataSource]
    if !exists {
        return nil, fmt.Errorf("data source not found: %s", shard.DataSource)
    }
    
    // 替换表名
    finalQuery := strings.Replace(query, tableName, shard.TableName, -1)
    
    // 执行查询
    rows, err := db.QueryContext(ctx, finalQuery, args...)
    if err != nil {
        return nil, fmt.Errorf("failed to query shard %d: %w", shardIndex, err)
    }
    defer rows.Close()
    
    // 解析结果
    columns, err := rows.Columns()
    if err != nil {
        return nil, fmt.Errorf("failed to get columns: %w", err)
    }
    
    var resultRows []*QueryRow
    for rows.Next() {
        values := make([]interface{}, len(columns))
        valuePtrs := make([]interface{}, len(columns))
        for i := range values {
            valuePtrs[i] = &values[i]
        }
        
        if err := rows.Scan(valuePtrs...); err != nil {
            return nil, fmt.Errorf("failed to scan row: %w", err)
        }
        
        row := &QueryRow{
            Values: make(map[string]interface{}),
        }
        
        for i, col := range columns {
            row.Values[col] = values[i]
        }
        
        resultRows = append(resultRows, row)
    }
    
    if err := rows.Err(); err != nil {
        return nil, fmt.Errorf("row iteration error: %w", err)
    }
    
    return &QueryResult{
        Rows:       resultRows,
        TotalCount: len(resultRows),
    }, nil
}

// Merge 合并结果
func (rm *ResultMerger) Merge(rows []*QueryRow) *QueryResult {
    // 简化实现：直接返回所有行
    // 在实际应用中，这里应该实现排序、去重、分页等逻辑
    
    if rm.distinct {
        rows = rm.removeDuplicates(rows)
    }
    
    if len(rm.orderByFields) > 0 {
        rows = rm.sortRows(rows)
    }
    
    if rm.limit > 0 && len(rows) > rm.limit {
        rows = rows[:rm.limit]
    }
    
    return &QueryResult{
        Rows:       rows,
        TotalCount: len(rows),
    }
}

// removeDuplicates 去重
func (rm *ResultMerger) removeDuplicates(rows []*QueryRow) []*QueryRow {
    seen := make(map[string]bool)
    var uniqueRows []*QueryRow
    
    for _, row := range rows {
        // 简化实现：使用所有值的字符串表示作为唯一键
        key := fmt.Sprintf("%v", row.Values)
        if !seen[key] {
            seen[key] = true
            uniqueRows = append(uniqueRows, row)
        }
    }
    
    return uniqueRows
}

// sortRows 排序行
func (rm *ResultMerger) sortRows(rows []*QueryRow) []*QueryRow {
    // 简化实现：按第一个排序字段排序
    if len(rm.orderByFields) == 0 {
        return rows
    }
    
    sort.Slice(rows, func(i, j int) bool {
        field := rm.orderByFields[0]
        valI, okI := rows[i].Values[field]
        valJ, okJ := rows[j].Values[field]
        
        if !okI || !okJ {
            return false
        }
        
        return fmt.Sprintf("%v", valI) < fmt.Sprintf("%v", valJ)
    })
    
    return rows
}

使用示例

// 初始化分库分表系统
func main() {
    // 创建数据源管理器
    dataSourceManager := &DataSourceManager{
        dataSources: make(map[string]*sql.DB),
    }
    
    // 模拟创建数据源
    for i := 0; i < 3; i++ {
        db, err := sql.Open("mysql", fmt.Sprintf("user:password@tcp(localhost:%d)/db%d", 3306+i, i))
        if err != nil {
            log.Printf("Failed to create data source ds_%d: %v", i, err)
            continue
        }
        dataSourceManager.dataSources[fmt.Sprintf("ds_%d", i)] = db
    }
    
    // 创建分片管理器
    shardingManager := NewShardingManager(dataSourceManager)
    
    // 创建哈希分片规则 (用户表按用户ID分片)
    userShardingRule := NewHashShardingRule(
        "user_id",
        8, // 8个分片
        []string{"ds_0", "ds_1", "ds_2"},
        "user",
    )
    shardingManager.AddShardingRule("user", userShardingRule)
    
    // 创建范围分片规则 (订单表按订单ID范围分片)
    orderRanges := []*RangeConfig{
        {Start: 0, End: 999999, ShardIndex: 0},
        {Start: 1000000, End: 1999999, ShardIndex: 1},
        {Start: 2000000, End: 2999999, ShardIndex: 2},
    }
    orderShardingRule := NewRangeShardingRule(
        "order_id",
        orderRanges,
        []string{"ds_0", "ds_1", "ds_2"},
        "order",
    )
    shardingManager.AddShardingRule("order", orderShardingRule)
    
    // 创建标签分片规则 (日志表按业务类型分片)
    tagToShard := map[string]int{
        "user":   0,
        "order":  1,
        "payment": 2,
    }
    logShardingRule := NewTagShardingRule(
        "biz_type",
        tagToShard,
        []string{"ds_0", "ds_1", "ds_2"},
        "log",
    )
    shardingManager.AddShardingRule("log", logShardingRule)
    
    // 创建分布式事务管理器
    txManager := NewDistributedTransactionManager(dataSourceManager, 30*time.Second)
    
    // 创建跨分片查询处理器
    crossShardQueryProcessor := NewCrossShardQueryProcessor(shardingManager)
    
    // 模拟用户查询
    ctx := context.Background()
    
    // 查询特定用户
    userID := 123456
    rows, err := shardingManager.ExecuteQuery(
        ctx,
        "user",
        userID,
        "SELECT * FROM user WHERE user_id = ?",
        userID,
    )
    if err != nil {
        log.Printf("Query user failed: %v", err)
    } else {
        defer rows.Close()
        log.Printf("Query user success")
    }
    
    // 跨分片查询所有用户
    crossResult, err := crossShardQueryProcessor.ExecuteCrossShardQuery(
        ctx,
        "user",
        "SELECT * FROM user WHERE created_at > ? ORDER BY created_at LIMIT 100",
        "2023-01-01",
    )
    if err != nil {
        log.Printf("Cross shard query failed: %v", err)
    } else {
        log.Printf("Cross shard query returned %d rows", crossResult.TotalCount)
    }
    
    // 模拟分布式事务
    shards := []*ShardingResult{
        {DataSource: "ds_0", TableName: "user_1", ShardIndex: 1},
        {DataSource: "ds_1", TableName: "order_2", ShardIndex: 2},
    }
    
    err = txManager.ExecuteInTransaction(ctx, shards, func(tx *DistributedTransaction) error {
        // 在事务中执行业务逻辑
        log.Printf("Executing business logic in distributed transaction %s", tx.ID)
        return nil
    })
    if err != nil {
        log.Printf("Distributed transaction failed: %v", err)
    } else {
        log.Printf("Distributed transaction succeeded")
    }
}

// 工具函数
func generateTransactionID() string {
    return fmt.Sprintf("tx_%d_%s", time.Now().UnixNano(), randomString(8))
}

func randomString(length int) string {
    const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    b := make([]byte, length)
    for i := range b {
        b[i] = charset[rand.Intn(len(charset))]
    }
    return string(b)
}

总结

通过合理的分库分表策略，我们可以有效解决单表存储千万级数据的性能问题：

  1. 哈希分片：将数据均匀分布到多个分片中，适合等量分布的场景
  2. 范围分片：根据数据范围分布到不同分片，适合按时间或ID范围查询的场景
  3. 标签分片：根据数据标签属性分布到不同分片，适合按业务类型分类的场景

在实际应用中，还需要考虑以下几点：

  1. 分片键选择：选择合适的分片键是分库分表成功的关键
  2. 数据迁移：当需要重新分片时，需要考虑数据迁移方案
  3. 监控告警：实时监控各分片的性能指标和数据分布情况
  4. 扩容策略：设计合理的扩容方案，支持动态增加分片

通过系统性地应用这些分库分表技术和策略，确实可以解决单表千万级数据的查询性能问题，显著提升系统的可扩展性和性能。

avatar
文章
阅读
粉丝