深入理解Go语言GAE Datastore多租户与事务机制

package main

import (
    "context"
    "fmt"
    "log"

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

// Item represents a simple entity in Datastore
type Item struct {
    Name  string
    Count int
}

func updateItemInTransaction(ctx context.Context, itemKey *datastore.Key, newCount int) error {
    err := datastore.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
        var item Item
        // Get the item within the transaction
        if err := tx.Get(itemKey, &item); err != nil {
            return err
        }

        // Perform the update
        item.Count = newCount
        item.Name = item.Name + " (updated)" // Example of a non-idempotent change if not careful

        // Put the updated item within the transaction
        _, err := tx.Put(itemKey, &item)
        return err
    }, nil) // Options can be nil for default
    return err
}

func main() {
    // This is a conceptual example. In a real GAE app, ctx would come from appengine.NewContext(r)
    // and keys would be created with datastore.NewKey.
    // For demonstration, assume we have a context and a key.
    // ctx := appengine.NewContext(request)
    // itemKey := datastore.NewKey(ctx, "Item", "my-item-id", 0, nil) // No parent, default namespace

    // Simulate context and key for compilation
    ctx := context.Background()
    itemKey := datastore.NewKey(ctx, "Item", "my-item-id", 0, nil)

    // Example usage
    err := updateItemInTransaction(ctx, itemKey, 100)
    if err != nil {
        log.Printf("Transaction failed: %v", err)
    } else {
        fmt.Println("Transaction completed successfully.")
    }
}

// 假设 item.Count 初始为 5
item.Count = item.Count + 1
// 第一次执行后 item.Count = 6
// 如果事务失败并重试，第二次执行后 item.Count = 7 (错误)

item.Status = "PROCESSED"
// 无论执行多少次，item.Status 最终都会是 "PROCESSED"

err := datastore.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
    var item Item
    if err := tx.Get(itemKey, &item); err != nil {
        return err
    }
    // Read the current count, then calculate the new count
    // This part is crucial for idempotency if newCount depends on external factors
    item.Count = item.Count + 1 // This specific line is NOT idempotent if retried without re-fetching
                                // A truly idempotent increment would involve fetching, then writing a *specific* new value,
                                // or ensuring the fetch always gets the latest state before incrementing.
                                // For simple increments, Datastore transactions handle the "get-modify-put" atomically
                                // within the retry loop, making the *overall effect* idempotent for this specific case,
                                // as long as the base value is re-fetched on retry.
                                // The key is that tx.Get will always retrieve the latest committed state on each retry.
    _, err := tx.Put(itemKey, &item)
    return err
}, nil)