Go GAE Datastore 结构体字段平滑重命名与数据迁移指南

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/appengine/v2/datastore" // 使用v2版本以兼容新版Go模块
    "google.golang.org/appengine/v2/aetest"    // 用于本地测试
)

// 定义原始结构体（假设已在Datastore中存储了大量此类型的数据）
type OldAA struct {
    A  string
    BB string // 旧字段名
}

// 定义新的结构体，其中BB字段已重命名为B
type AA struct {
    A string
    B string // 新字段名
}

// 实现datastore.PropertyLoadSaver接口的Load方法
func (s *AA) Load(properties []datastore.Property) error {
    // 将传入的属性列表转换为PropertyMap，方便按名称查找
    pm := make(datastore.PropertyMap)
    for _, p := range properties {
        pm[p.Name] = append(pm[p.Name], p)
    }

    // 加载A字段
    if err := pm.LoadStruct(s); err != nil {
        return err
    }

    // 优先加载新字段B
    if p, ok := pm["B"]; ok && len(p) > 0 {
        s.B = p[0].Value.(string)
    } else if p, ok := pm["BB"]; ok && len(p) > 0 {
        // 如果没有B字段，则尝试从旧字段BB加载
        s.B = p[0].Value.(string)
    }
    // 如果两者都没有，B将保持其零值（空字符串）
    return nil
}

// 实现datastore.PropertyLoadSaver接口的Save方法
func (s *AA) Save() ([]datastore.Property, error) {
    var properties []datastore.Property

    // 只保存新字段A和B，忽略旧字段BB
    properties = append(properties, datastore.Property{
        Name:    "A",
        Value:   s.A,
        NoIndex: false, // 根据需要设置索引
    })
    properties = append(properties, datastore.Property{
        Name:    "B",
        Value:   s.B,
        NoIndex: false, // 根据需要设置索引
    })

    return properties, nil
}

func main() {
    // 初始化一个GAE测试上下文
    ctx, done, err := aetest.NewContext()
    if err != nil {
        log.Fatalf("Failed to create aetest context: %v", err)
    }
    defer done()

    // --- 模拟旧数据写入 ---
    log.Println("--- 模拟旧数据写入 ---")
    oldEntity := OldAA{
        A:  "Value A Old",
        BB: "Value BB Old", // 使用旧字段名
    }
    key := datastore.NewKey(ctx, "AAEntity", "entity-id-1", 0, nil)
    _, err = datastore.Put(ctx, key, &oldEntity)
    if err != nil {
        log.Fatalf("Failed to put old entity: %v", err)
    }
    log.Printf("旧实体写入成功: %v\n", oldEntity)

    // --- 模拟新数据写入 (使用新的AA结构体) ---
    log.Println("--- 模拟新数据写入 ---")
    newEntity := AA{
        A: "Value A New",
        B: "Value B New", // 使用新字段名
    }
    newKey := datastore.NewKey(ctx, "AAEntity", "entity-id-2", 0, nil)
    _, err = datastore.Put(ctx, newKey, &newEntity)
    if err != nil {
        log.Fatalf("Failed to put new entity: %v", err)
    }
    log.Printf("新实体写入成功: %v\n", newEntity)


    // --- 从Datastore加载数据，验证迁移逻辑 ---
    log.Println("--- 从Datastore加载数据，验证迁移逻辑 ---")

    // 尝试加载旧实体
    var loadedOldEntity AA
    err = datastore.Get(ctx, key, &loadedOldEntity)
    if err != nil {
        log.Fatalf("Failed to get old entity with new struct: %v", err)
    }
    log.Printf("成功加载旧实体 (使用新结构体): %+v\n", loadedOldEntity)
    if loadedOldEntity.A != "Value A Old" || loadedOldEntity.B != "Value BB Old" {
        log.Fatalf("旧实体加载后数据不匹配！期望 A:'Value A Old', B:'Value BB Old' 但得到 A:'%s', B:'%s'", loadedOldEntity.A, loadedOldEntity.B)
    } else {
        log.Println("旧实体加载并成功迁移到新字段B。")
    }

    // 尝试加载新实体
    var loadedNewEntity AA
    err = datastore.Get(ctx, newKey, &loadedNewEntity)
    if err != nil {
        log.Fatalf("Failed to get new entity: %v", err)
    }
    log.Printf("成功加载新实体: %+v\n", loadedNewEntity)
    if loadedNewEntity.A != "Value A New" || loadedNewEntity.B != "Value B New" {
        log.Fatalf("新实体加载后数据不匹配！期望 A:'Value A New', B:'Value B New' 但得到 A:'%s', B:'%s'", loadedNewEntity.A, loadedNewEntity.B)
    } else {
        log.Println("新实体加载成功。")
    }

    // --- 验证重新保存旧实体后，Datastore中是否只剩下新字段 ---
    log.Println("--- 验证重新保存旧实体后，Datastore中是否只剩下新字段 ---")
    // 重新保存加载的旧实体
    _, err = datastore.Put(ctx, key, &loadedOldEntity)
    if err != nil {
        log.Fatalf("Failed to re-put old entity: %v", err)
    }
    log.Println("旧实体重新保存成功。")

    // 再次从Datastore中直接查询属性，验证旧字段BB是否已消失
    var checkProps []datastore.Property
    err = datastore.Get(ctx, key, &checkProps) // 直接加载为属性列表
    if err != nil {
        log.Fatalf("Failed to get properties for re-saved old entity: %v", err)
    }
    log.Printf("重新保存的旧实体属性列表: %+v\n", checkProps)

    foundBB := false
    for _, p := range checkProps {
        if p.Name == "BB" {
            foundBB = true
            break
        }
    }
    if foundBB {
        log.Println("警告: 旧字段BB在重新保存后仍然存在于Datastore中！")
    } else {
        log.Println("验证通过: 旧字段BB在重新保存后已从Datastore中移除。")
    }

    log.Println("所有测试完成。")
}