Go语言App Engine Datastore：高效实现唯一键约束与查询策略

package main

import (
    "context"
    "fmt"
    "log"

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

// MyEntity represents the data structure stored in Datastore.
type MyEntity struct {
    Value string
    // Other fields...
}

// queryEntityByKey demonstrates how to query an entity by its datastore.Key using __key__ filter.
func queryEntityByKey(ctx context.Context, client *datastore.Client, userKeyID string) (*MyEntity, error) {
    // 1. Construct the datastore.Key from the user-provided string ID.
    // "MyEntityType" should be replaced with your actual Kind name.
    key := datastore.NewKey(ctx, "MyEntityType", userKeyID, 0, nil)

    // 2. Create a query filtering by the special __key__ property.
    query := datastore.NewQuery("MyEntityType").Filter("__key__ =", key)

    var entities []*MyEntity
    // client.GetAll fetches all entities matching the query.
    // For a unique key, we expect at most one result.
    _, err := client.GetAll(ctx, query, &entities)
    if err != nil {
        return nil, fmt.Errorf("failed to query by __key__: %w", err)
    }

    if len(entities) == 0 {
        return nil, datastore.ErrNoSuchEntity // No entity found with this key
    }
    if len(entities) > 1 {
        // This scenario should ideally not happen for a unique key, but serves as a defensive check.
        log.Printf("Warning: Query by unique key '%s' returned multiple entities. This indicates a data inconsistency.", userKeyID)
    }

    return entities[0], nil
}

func main() {
    // Example usage (requires a Datastore client and context setup)
    // ctx := context.Background()
    // client, err := datastore.NewClient(ctx, "your-gcp-project-id")
    // if err != nil {
    //  log.Fatalf("Failed to create Datastore client: %v", err)
    // }
    // defer client.Close()

    // entity, err := queryEntityByKey(ctx, client, "unique-user-id-123")
    // if err != nil {
    //  if errors.Is(err, datastore.ErrNoSuchEntity) {
    //      fmt.Println("Entity not found.")
    //  } else {
    //      log.Fatalf("Error querying entity: %v", err)
    //  }
    // } else {
    //  fmt.Printf("Found entity: %+v\n", entity)
    // }
    fmt.Println("Run `go mod tidy` and then uncomment the main function body to test.")
}

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

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

// MyEntity represents the data structure stored in Datastore.
type MyEntity struct {
    Value string
    // Other fields...
}

// enforceUniqueKeyNonTransactional attempts to enforce key uniqueness without a transaction.
// Not recommended for high-concurrency environments due to race conditions.
func enforceUniqueKeyNonTransactional(ctx context.Context, client *datastore.Client, userKeyID string, entity *MyEntity) error {
    key := datastore.NewKey(ctx, "MyEntityType", userKeyID, 0, nil)

    // Attempt to fetch the entity directly by key.
    existingEntity := &MyEntity{}
    err := client.Get(ctx, key, existingEntity)

    if err == nil {
        // Entity with this key already exists
        return fmt.Errorf("key '%s' already exists", userKeyID)
    }
    if !errors.Is(err, datastore.ErrNoSuchEntity) {
        // Some other error occurred during Get
        return fmt.Errorf("failed to check key existence: %w", err)
    }

    // If ErrNoSuchEntity, the key is unique, proceed to Put.
    _, err = client.Put(ctx, key, entity)
    if err != nil {
        return fmt.Errorf("failed to put entity with unique key: %w", err)
    }

    log.Printf("Successfully created entity with key '%s' (non-transactional)", userKeyID)
    return nil
}

func main() {
    // Example usage placeholder
    fmt.Println("Non-transactional unique key enforcement example.")
}

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

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

// MyEntity represents the data structure stored in Datastore.
type MyEntity struct {
    Value string
    // Other fields...
}

// enforceUniqueKeyInTransaction enforces key uniqueness within a Datastore transaction.
// This is the recommended approach for high-concurrency environments.
func enforceUniqueKeyInTransaction(ctx context.Context, client *datastore.Client, userKeyID string, entity *MyEntity) error {
    key := datastore.NewKey(ctx, "MyEntityType", userKeyID, 0, nil)

    _, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
        // Inside a transaction, use tx.Get and tx.Put.
        existingEntity := &MyEntity{}
        err := tx.Get(key, existingEntity) // Attempt to get the entity within the transaction.

        if err == nil {
            // Entity with this key already exists, return an error to abort the transaction.
            return fmt.Errorf("key '%s' already exists (transactional check)", userKeyID)
        }
        if !errors.Is(err, datastore.ErrNoSuchEntity) {
            // Some other error occurred during Get, abort transaction.
            return fmt.Errorf("failed to check key existence in transaction: %w", err)
        }

        // If ErrNoSuchEntity, the key is unique within this transaction's view, proceed to Put.
        _, err = tx.Put(key, entity) // Put the new entity within the same transaction.
        if err != nil {
            return fmt.Errorf("failed to put entity with unique key in transaction: %w", err)
        }
        return nil // Commit the transaction
    })

    if err != nil {
        return fmt.Errorf("transaction failed: %w", err)
    }

    log.Printf("Successfully created entity with key '%s' (transactional)", userKeyID)
    return nil
}

func main() {
    // Example usage placeholder
    fmt.Println("Transactional unique key enforcement example.")
}