7天用Go实现ORM框架GeeORM：数据库迁移(Migrate)详解-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00903/article/details/148375999

7天用Go实现ORM框架GeeORM：数据库迁移(Migrate)详解

7days-golang 7 days golang programs from scratch (web framework Gee, distributed cache GeeCache, object relational mapping ORM framework GeeORM, rpc framework GeeRPC etc) 7天用Go动手写/从零实现系列项目地址: https://gitcode.com/gh_mirrors/7d/7days-golang

前言

在开发数据库应用时，随着业务需求的变化，我们经常需要修改数据库表结构。传统做法是手动编写SQL脚本来执行这些变更，但这种方式容易出错且效率低下。本文将介绍如何在GeeORM框架中实现自动化的数据库迁移(Migrate)功能，让表结构变更更加高效可靠。

什么是数据库迁移

数据库迁移是指当我们的数据模型(通常对应Go中的结构体)发生变化时，自动同步这些变化到数据库表结构的过程。一个完善的迁移系统应该能够：

检测模型与表结构之间的差异
自动生成并执行变更SQL
保证迁移过程的安全性

SQLite迁移实现原理

新增字段实现

在大多数数据库中，新增字段相对简单，可以使用ALTER TABLE语句：

ALTER TABLE table_name ADD COLUMN col_name col_type;

删除字段实现

SQLite删除字段较为复杂，需要以下步骤：

创建临时表，只包含需要保留的字段
删除原表
将临时表重命名为原表名

CREATE TABLE new_table AS SELECT col1, col2 FROM old_table;
DROP TABLE old_table;
ALTER TABLE new_table RENAME TO old_table;

GeeORM迁移实现详解

差异计算

首先需要计算模型字段与表字段之间的差异：

func difference(a []string, b []string) (diff []string) {
    mapB := make(map[string]bool)
    for _, v := range b {
        mapB[v] = true
    }
    for _, v := range a {
        if _, ok := mapB[v]; !ok {
            diff = append(diff, v)
        }
    }
    return
}

这个函数计算两个字符串切片的差集，用于找出新增和删除的字段。

迁移主逻辑

迁移的主要逻辑封装在Engine.Migrate方法中：

func (engine *Engine) Migrate(value interface{}) error {
    _, err := engine.Transaction(func(s *session.Session) (result interface{}, err error) {
        // 检查表是否存在
        if !s.Model(value).HasTable() {
            return nil, s.CreateTable()
        }
        
        // 获取当前表结构
        table := s.RefTable()
        rows, _ := s.Raw(fmt.Sprintf("SELECT * FROM %s LIMIT 1", table.Name)).QueryRows()
        columns, _ := rows.Columns()
        
        // 计算差异
        addCols := difference(table.FieldNames, columns) // 新增字段
        delCols := difference(columns, table.FieldNames) // 删除字段

        // 处理新增字段
        for _, col := range addCols {
            f := table.GetField(col)
            sqlStr := fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s %s;", table.Name, f.Name, f.Type)
            if _, err = s.Raw(sqlStr).Exec(); err != nil {
                return
            }
        }

        // 处理删除字段
        if len(delCols) > 0 {
            tmp := "tmp_" + table.Name
            fieldStr := strings.Join(table.FieldNames, ", ")
            s.Raw(fmt.Sprintf("CREATE TABLE %s AS SELECT %s from %s;", tmp, fieldStr, table.Name))
            s.Raw(fmt.Sprintf("DROP TABLE %s;", table.Name))
            s.Raw(fmt.Sprintf("ALTER TABLE %s RENAME TO %s;", tmp, table.Name))
            _, err = s.Exec()
        }
        return
    })
    return err
}

关键点解析

事务支持：整个迁移过程在事务中执行，确保原子性
差异检测：通过比较模型字段和表字段找出差异
分步处理：
- 新增字段使用ALTER TABLE语句
- 删除字段采用创建临时表的方式
错误处理：任何步骤出错都会回滚事务

测试用例

type User struct {
    Name string `geeorm:"PRIMARY KEY"`
    Age  int
}

func TestEngine_Migrate(t *testing.T) {
    engine := OpenDB(t)
    defer engine.Close()
    
    s := engine.NewSession()
    _, _ = s.Raw("DROP TABLE IF EXISTS User;").Exec()
    _, _ = s.Raw("CREATE TABLE User(Name text PRIMARY KEY, XXX integer);").Exec()
    _, _ = s.Raw("INSERT INTO User(`Name`) values (?), (?)", "Tom", "Sam").Exec()
    
    // 执行迁移
    engine.Migrate(&User{})
    
    // 验证结果
    rows, _ := s.Raw("SELECT * FROM User").QueryRows()
    columns, _ := rows.Columns()
    if !reflect.DeepEqual(columns, []string{"Name", "Age"}) {
        t.Fatal("迁移失败，得到的列:", columns)
    }
}

这个测试用例模拟了从包含Name和XXX字段的表结构迁移到包含Name和Age字段的过程。