Go语言GAE Datastore：实现多值属性查询（模拟IN查询）

type Foo struct {
    Id        int64
    Name      string
    CreatorId int64
}

// 假设我们想查询 CreatorId 为 1, 5, 23 的 Foo 实体
q := datastore.NewQuery("Foo").
    Filter("CreatorId =", 1).
    Filter("CreatorId =", 5).
    Filter("CreatorId =", 23)

package main

import (
    "context"
    "fmt"
    "log"
    "sort"
    "sync"
    "time"

    "cloud.google.com/go/datastore" // 导入新的Datastore客户端库
    // "google.golang.org/appengine/v2/datastore" // 如果是旧版App Engine Standard，可能使用这个
    // "google.golang.org/appengine/v2/aetest" // 用于本地测试
)

// Foo 实体定义
type Foo struct {
    Id        int64 `datastore:"-"` // Id字段不存储在Datastore中，而是作为Key的一部分或在应用层处理
    Name      string
    CreatorId int64
}

// 辅助函数：将Datastore Key转换为Id（如果适用）
func keyToID(key *datastore.Key) int64 {
    if key != nil {
        return key.ID
    }
    return 0
}

func main() {
    // 假设您已经设置了GCP项目ID和认证
    // 对于本地开发，您可以使用Datastore模拟器或设置 GOOGLE_APPLICATION_CREDENTIALS 环境变量
    // 例如：export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/key.json"
    // 或使用 aetest.NewContext() 进行本地App Engine模拟测试

    ctx := context.Background()
    projectID := "your-gcp-project-id" // 替换为您的GCP项目ID

    client, err := datastore.NewClient(ctx, projectID)
    if err != nil {
        log.Fatalf("Failed to create Datastore client: %v", err)
    }
    defer client.Close()

    // 1. 准备一些测试数据 (可选，用于演示)
    // 实际应用中，这些数据应已存在于Datastore中
    keys := []*datastore.Key{
        datastore.IncompleteKey("Foo", nil),
        datastore.IncompleteKey("Foo", nil),
        datastore.IncompleteKey("Foo", nil),
        datastore.IncompleteKey("Foo", nil),
        datastore.IncompleteKey("Foo", nil),
    }
    foos := []*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},
    }

    // 批量保存实体，并获取完整的Key
    // 注意：IncompleteKey 在保存后会获得一个完整的ID
    _, err = client.PutMulti(ctx, keys, foos)
    if err != nil {
        log.Printf("Failed to put entities (might be ok if already exists): %v", err)
    }
    // 刷新一下，确保数据可见（在模拟器中可能需要，实际Datastore通常很快）
    time.Sleep(1 * time.Second)


    // 2. 定义要查询的 CreatorId 列表
    targetCreatorIds := []int64{1, 5, 23}

    // 用于存储所有查询结果的切片
    var allMatchingFoos []*Foo
    // 使用 map 来避免重复实体，因为多个查询可能返回同一个实体（尽管在这里CreatorId是唯一的）
    // 但如果查询条件更复杂，或者实体可能因其他属性被多次匹配，map是很有用的
    uniqueFoosMap := make(map[int64]*Foo) // key: 实体ID, value: *Foo

    // 使用 WaitGroup 等待所有并发查询完成
    var wg sync.WaitGroup
    var mu sync.Mutex // 保护 allMatchingFoos 和 uniqueFoosMap 的并发写入

    fmt.Printf("开始查询 CreatorId 在 %v 中的 Foo 实体...\n", targetCreatorIds)

    for _, id := range targetCreatorIds {
        wg.Add(1)
        go func(creatorID int64) {
            defer wg.Done()

            // 为每个 CreatorId 创建一个独立的查询
            query := datastore.NewQuery("Foo").Filter("CreatorId =", creatorID)

            var currentFoos []*Foo
            keys, err := client.GetAll(ctx, query, &currentFoos)
            if err != nil {
                log.Printf("Error querying for CreatorId %d: %v", creatorID, err)
                return
            }

            mu.Lock()
            for i, foo := range currentFoos {
                // 假设实体的ID可以通过Key获取，并作为唯一标识
                // 实际应用中，您可能需要根据业务逻辑定义实体的唯一性
                entityID := keyToID(keys[i]) // 从Key中提取ID
                if entityID == 0 { // 如果是IncompleteKey保存的，ID会在PutMulti后生成
                    // 这是一个简化的处理，实际应用中需要确保keyToID能正确获取ID
                    // 如果ID在实体结构中，则直接使用 foo.Id
                    // 这里我们假设 keyToID 可以获取到Datastore自动生成的ID
                    log.Printf("Warning: Entity with CreatorId %d has no valid ID from key. Skipping deduplication for this item.", creatorID)
                    allMatchingFoos = append(allMatchingFoos, foo) // 无法去重，直接添加
                } else if _, exists := uniqueFoosMap[entityID]; !exists {
                    uniqueFoosMap[entityID] = foo
                    allMatchingFoos = append(allMatchingFoos, foo)
                }
            }
            mu.Unlock()
        }(id)
    }

    wg.Wait() // 等待所有查询完成

    // 对结果进行排序（可选）
    sort.Slice(allMatchingFoos, func(i, j int) bool {
        return allMatchingFoos[i].CreatorId < allMatchingFoos[j].CreatorId
    })

    fmt.Printf("\n查询结果 (%d 个实体):\n", len(allMatchingFoos))
    if len(allMatchingFoos) == 0 {
        fmt.Println("未找到匹配的实体。")
    } else {
        for _, foo := range allMatchingFoos {
            fmt.Printf("  Name: %s, CreatorId: %d\n", foo.Name, foo.CreatorId)
        }
    }
}