Go GAE Datastore 结构体字段重命名与数据迁移策略

type PropertyLoadSaver interface {
    Load([]Property) error
    Save() ([]Property, error)
}

type AA struct {
    A  string
    BB string // 旧字段名
}

type AA struct {
    A string
    B string // 新字段名
}

func (a *AA) Load(ps []datastore.Property) error {
    for _, p := range ps {
        switch p.Name {
        case "A":
            if v, ok := p.Value.(string); ok {
                a.A = v
            }
        case "BB": // 处理旧字段名
            if v, ok := p.Value.(string); ok {
                a.B = v // 将旧字段BB的值赋给新字段B
            }
        case "B": // 处理新字段名
            if v, ok := p.Value.(string); ok {
                a.B = v // 如果已经有新字段B的数据，则覆盖
            }
        default:
            // 忽略其他未知属性
        }
    }
    return nil
}

func (a *AA) Save() ([]datastore.Property, error) {
    return []datastore.Property{
        {Name: "A", Value: a.A},
        {Name: "B", Value: a.B}, // 只保存新字段名
    }, nil
}

package main

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

    "google.golang.org/appengine/v2"
    "google.golang.org/appengine/v2/datastore"
)

// AA 结构体，用于演示字段重命名
type AA struct {
    A string
    B string // 新字段名，在Load方法中兼容旧字段BB
}

// Load 方法实现了 datastore.PropertyLoadSaver 接口的 Load 部分
func (a *AA) Load(ps []datastore.Property) error {
    for _, p := range ps {
        switch p.Name {
        case "A":
            if v, ok := p.Value.(string); ok {
                a.A = v
            }
        case "BB": // 处理旧字段名
            if v, ok := p.Value.(string); ok {
                a.B = v // 将旧字段BB的值赋给新字段B
            }
        case "B": // 处理新字段名
            if v, ok := p.Value.(string); ok {
                a.B = v // 如果已经有新字段B的数据，则覆盖
            }
        // 可以在此处添加其他字段的加载逻辑
        default:
            // 忽略其他未知属性
        }
    }
    return nil
}

// Save 方法实现了 datastore.PropertyLoadSaver 接口的 Save 部分
func (a *AA) Save() ([]datastore.Property, error) {
    return []datastore.Property{
        {Name: "A", Value: a.A},
        {Name: "B", Value: a.B}, // 只保存新字段名
    }, nil
}

// 示例用法（在GAE环境中运行）
func main() {
    // 这是一个模拟App Engine上下文的示例，实际运行时需要App Engine环境
    // ctx := appengine.NewContext(r)
    // For demonstration, let's use a dummy context if not in GAE environment
    ctx := context.Background() // Replace with appengine.NewContext(r) in actual GAE app

    // --- 模拟旧数据存储 ---
    // 假设在重命名之前，我们存储了一个旧版本的AA结构体
    log.Println("--- 模拟旧数据存储 ---")
    oldKey := datastore.NewIncompleteKey(ctx, "AAEntity", nil)
    oldProps := []datastore.Property{
        {Name: "A", Value: "ValueA-Old"},
        {Name: "BB", Value: "ValueBB-Old"}, // 使用旧字段名BB
    }
    // 直接使用PutMulti保存属性，模拟旧数据
    oldKey, err := datastore.Put(ctx, oldKey, &oldProps) // 注意：这里直接保存属性列表，而非AA结构体
    if err != nil {
        log.Fatalf("Failed to save old data: %v", err)
    }
    log.Printf("旧数据已存储，Key: %v", oldKey)

    // --- 加载旧数据并验证 ---
    log.Println("\n--- 加载旧数据并验证 ---")
    var loadedAA AA
    err = datastore.Get(ctx, oldKey, &loadedAA)
    if err != nil {
        log.Fatalf("Failed to load old data: %v", err)
    }
    fmt.Printf("从旧数据加载的AA实体: A='%s', B='%s'\n", loadedAA.A, loadedAA.B)
    // 此时 loadedAA.B 应该包含 "ValueBB-Old"

    // --- 修改并保存数据（现在会以新字段名保存） ---
    log.Println("\n--- 修改并保存数据（现在会以新字段名保存） ---")
    loadedAA.A = "ValueA-Updated"
    loadedAA.B = "ValueB-New" // 修改新字段B的值

    newKey, err := datastore.Put(ctx, oldKey, &loadedAA) // 使用Put方法，会调用AA的Save方法
    if err != nil {
        log.Fatalf("Failed to update and save data: %v", err)
    }
    log.Printf("数据已更新并以新字段名保存，Key: %v", newKey)

    // --- 再次加载数据并验证（确认已用新字段名保存） ---
    log.Println("\n--- 再次加载数据并验证（确认已用新字段名保存） ---")
    var reloadedAA AA
    err = datastore.Get(ctx, newKey, &reloadedAA)
    if err != nil {
        log.Fatalf("Failed to reload updated data: %v", err)
    }
    fmt.Printf("重新加载的AA实体: A='%s', B='%s'\n", reloadedAA.A, reloadedAA.B)
    // 此时 reloadedAA.B 应该包含 "ValueB-New"

    // --- 存储一个全新的实体（直接使用新字段名） ---
    log.Println("\n--- 存储一个全新的实体（直接使用新字段名） ---")
    newEntity := AA{
        A: "BrandNewA",
        B: "BrandNewB",
    }
    brandNewKey := datastore.NewIncompleteKey(ctx, "AAEntity", nil)
    brandNewKey, err = datastore.Put(ctx, brandNewKey, &newEntity)
    if err != nil {
        log.Fatalf("Failed to save brand new entity: %v", err)
    }
    log.Printf("全新实体已存储，Key: %v", brandNewKey)

    // --- 加载全新实体并验证 ---
    log.Println("\n--- 加载全新实体并验证 ---")
    var loadedBrandNew AA
    err = datastore.Get(ctx, brandNewKey, &loadedBrandNew)
    if err != nil {
        log.Fatalf("Failed to load brand new entity: %v", err)
    }
    fmt.Printf("加载的全新AA实体: A='%s', B='%s'\n", loadedBrandNew.A, loadedBrandNew.B)

    // 实际运行需要App Engine本地开发服务器或部署到GAE
    // 在本地开发环境中，datastore模拟器可能不会完全模拟旧字段名的持久化，
    // 但在真实的GAE Datastore中，此逻辑将正常工作。
    log.Println("\n--- 演示完成 ---")
    log.Println("注意：此示例在非GAE环境中使用context.Background()，并直接模拟了旧数据的存储方式。")
    log.Println("在真实的GAE应用中，datastore.Put和datastore.Get会自动调用Load/Save方法。")
}