Go语言Google Cloud Datastore：如何正确执行祖先查询

// 假设 k 是一个有效的父实体Key
// t 是一个用于存储结果的结构体
// c 是 context.Context
// ...
// 错误的父实体过滤尝试
// _, err = datastore.NewQuery("TagRecord").
//   Filter("Parent =", k). // 错误用法！
//   Order("-CreatedAt").
//   Limit(1).
//   Run(c).Next(t)
// ...
// 这种方式会导致错误，例如 "datastore: query has no more results"，
// 因为Datastore并不将父实体视为一个可直接通过Filter()查询的普通属性。

package main

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

    "cloud.google.com/go/datastore"
)

// ParentEntity 代表父实体
type ParentEntity struct {
    Name      string    `datastore:"name"`
    CreatedAt time.Time `datastore:"createdAt"`
}

// TagRecord 代表子实体
type TagRecord struct {
    Name      string    `datastore:"name"`
    Value     string    `datastore:"value"`
    CreatedAt time.Time `datastore:"createdAt"`
}

func main() {
    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. 创建并保存一个父实体 ---
    parentKey := datastore.IncompleteKey("ParentEntity", nil) // 创建一个不完整的父Key
    parent := &ParentEntity{
        Name:      "MyParentContainer",
        CreatedAt: time.Now(),
    }
    parentKey, err = client.Put(ctx, parentKey, parent) // 保存父实体，获取完整的Key
    if err != nil {
        log.Fatalf("Failed to put parent entity: %v", err)
    }
    fmt.Printf("Saved parent entity with key: %s\n", parentKey.String())

    // --- 2. 创建并保存一些子实体，关联到父实体 ---
    // 子实体的Key在创建时需要指定父Key
    childKey1 := datastore.IncompleteKey("TagRecord", parentKey)
    tag1 := &TagRecord{
        Name:      "tagA",
        Value:     "valueA",
        CreatedAt: time.Now().Add(-2 * time.Hour), // 2小时前
    }
    _, err = client.Put(ctx, childKey1, tag1)
    if err != nil {
        log.Fatalf("Failed to put child entity 1: %v", err)
    }
    fmt.Printf("Saved child entity 1 with key: %s\n", childKey1.String())

    childKey2 := datastore.IncompleteKey("TagRecord", parentKey)
    tag2 := &TagRecord{
        Name:      "tagB",
        Value:     "valueB",
        CreatedAt: time.Now().Add(-1 * time.Hour), // 1小时前
    }
    _, err = client.Put(ctx, childKey2, tag2)
    if err != nil {
        log.Fatalf("Failed to put child entity 2: %v", err)
    }
    fmt.Printf("Saved child entity 2 with key: %s\n", childKey2.String())

    // --- 3. 正确的祖先查询：使用 Ancestor() 方法 ---
    fmt.Println("\n--- 执行祖先查询以获取最新TagRecord ---")
    q := datastore.NewQuery("TagRecord").
        Ancestor(parentKey). // 关键：指定父实体Key
        Order("-CreatedAt"). // 按创建时间倒序
        Limit(1)             // 获取最新的一条

    var latestTag TagRecord
    it := client.Run(ctx, q)
    _, err = it.Next(&latestTag)
    if err == datastore.Done {
        fmt.Println("No results found for ancestor query.")
    } else if err != nil {
        log.Fatalf("Failed to get next result from ancestor query: %v", err)
    } else {
        fmt.Printf("最新TagRecord (通过祖先查询): %+v\n", latestTag)
    }

    // --- 4. 获取所有子实体 ---
    fmt.Println("\n--- 获取所有子实体 ---")
    qAll := datastore.NewQuery("TagRecord").
        Ancestor(parentKey). // 再次使用 Ancestor()
        Order("CreatedAt")   // 按创建时间正序

    var allTags []*TagRecord
    keys, err := client.GetAll(ctx, qAll, &allTags) // GetAll 可以方便地获取所有结果
    if err != nil {
        log.Fatalf("Failed to get all results from ancestor query: %v", err)
    }
    fmt.Printf("找到 %d 个子实体:\n", len(allTags))
    for i, tag := range allTags {
        fmt.Printf("  Key: %s, Data: %+v\n", keys[i].String(), tag)
    }
}