在Go语言中实现GAE Datastore的‘IN’查询：多值过滤与结果合并

package m<a style="color:#f60; text-decoration:underline;" title= "ai"href="https://www.php.cn/zt/17539.html" target="_blank">ai</a>n

import (
    "context"
    "fmt"
    "sort"
    "strings"

    "google.<a style="color:#f60; text-decoration:underline;" title= "golang"href="https://www.php.cn/zt/16009.html" target="_blank">golang</a>.org/appengine/v2/datastore" // 适用于App Engine标准环境
    // 如果是Cloud Datastore，则使用 "cloud.google.com/go/datastore"
)

// Foo 代表Datastore中的一个实体
type Foo struct {
    Name      string
    CreatorId int64
}

// simulateAppEngineContext 模拟App Engine上下文。
// 在真实的App Engine应用中，ctx会从HTTP请求中获取。
func simulateAppEngineContext() context.Context {
    // 在本地开发服务器（dev_appserver.py）运行时，context.Background() 通常足够。
    // 对于生产环境，应使用 appengine.NewContext(r)
    return context.Background()
}

func main() {
    ctx := simulateAppEngineContext()

    // --- 1. 准备示例数据 (在实际应用中，数据通常已存在) ---
    // 为了演示，我们先存储一些数据。
    sampleFoos := []Foo{
        {Name: "Foo A", CreatorId: 1},
        {Name: "Foo B", CreatorId: 5},
        {Name: "Foo C", CreatorId: 23},
        {Name: "Foo D", CreatorId: 2},
        {Name: "Foo E", CreatorId: 5}, // 注意：CreatorId 5 有两个实体
        {Name: "Foo F", CreatorId: 100},
    }

    // 批量插入数据，让Datastore自动生成ID
    keys := make([]*datastore.Key, len(sampleFoos))
    for i := range sampleFoos {
        keys[i] = datastore.IncompleteKey(ctx, "Foo", nil) // 创建不完整的键，Datastore将分配ID
    }

    // PutMulti 返回完整的键
    actualKeys, err := datastore.PutMulti(ctx, keys, sampleFoos)
    if err != nil {
        fmt.Printf("Error putting sample data: %v\n", err)
        // 错误处理：在无法连接Datastore时可能会发生
    } else {
        fmt.Println("Sample data inserted successfully.")
    }

    // --- 2. 执行“IN”查询模拟 ---
    targetCreatorIds := []int64{1, 5, 23} // 我们希望查询的 CreatorId 列表
    var allMatchingFoos []*Foo            // 用于存储所有匹配的实体
    seenKeys := make(map[string]bool)     // 使用 map 存储已获取的实体键字符串，以避免重复

    fmt.Printf("\nExecuting queries for CreatorIds: %v\n", targetCreatorIds)

    for _, creatorID := range targetCreatorIds {
        // 为每个 CreatorId 创建并执行一个单独的查询
        q := datastore.NewQuery("Foo").Filter("CreatorId =", creatorID)

        var currentFoos []*Foo
        // GetAll 执行查询，返回匹配的实体键和实体数据
        keysForCurrentQuery, err := datastore.GetAll(ctx, q, &currentFoos)
        if err != nil {
            fmt.Printf("Error fetching Foos for CreatorId %d: %v\n", creatorID, err)
            continue // 继续处理下一个 CreatorId
        }

        // 将当前查询结果合并到总结果中，并进行去重
        for i, foo := range currentFoos {
            keyStr := keysForCurrentQuery[i].String() // 获取实体的唯一键字符串
            if _, exists := seenKeys[keyStr]; !exists {
                allMatchingFoos = append(allMatchingFoos, &foo) // 添加实体指针
                seenKeys[keyStr] = true
            }
        }
    }

    // 为了输出的一致性，可以对结果进行排序（例如按 CreatorId 或 Name）
    sort.Slice(allMatchingFoos, func(i, j int) bool {
        if allMatchingFoos[i].CreatorId != allMatchingFoos[j].CreatorId {
            return allMatchingFoos[i].CreatorId < allMatchingFoos[j].CreatorId
        }
        return strings.Compare(allMatchingFoos[i].Name, allMatchingFoos[j].Name) < 0
    })

    fmt.Printf("\nFound %d Foo entities matching CreatorIds %v:\n", len(allMatchingFoos), targetCreatorIds)
    if len(allMatchingFoos) == 0 {
        fmt.Println("  No entities found.")
    } else {
        for _, foo := range allMatchingFoos {
            fmt.Printf("  Name: %s, CreatorId: %d\n", foo.Name, foo.CreatorId)
        }
    }

    // --- 3. 清理示例数据 (可选，仅用于演示) ---
    // 在实际应用中，通常不会在每次请求后立即删除数据
    if len(actualKeys) > 0 {
        err = datastore.DeleteMulti(ctx, actualKeys)
        if err != nil {
            fmt.Printf("Error deleting sample data: %v\n", err)
        } else {
            fmt.Println("\nSample data deleted successfully.")
        }
    }
}