func ExampleNewKey_withParent() { // [START key_with_parent] parentKey := datastore.NameKey("TaskList", "default", nil) taskKey := datastore.NameKey("Task", "sampleTask", parentKey) // [END key_with_parent] _ = taskKey // Use the task key for datastore operations. }
func ExampleNewKey_withMultipleParents() { // [START key_with_multilevel_parent] userKey := datastore.NameKey("User", "alice", nil) parentKey := datastore.NameKey("TaskList", "default", userKey) taskKey := datastore.NameKey("Task", "sampleTask", parentKey) // [END key_with_multilevel_parent] _ = taskKey // Use the task key for datastore operations. }
func ExampleQuery_EventualConsistency() { // [START eventual_consistent_query] ancestor := datastore.NameKey("TaskList", "default", nil) query := datastore.NewQuery("Task").Ancestor(ancestor).EventualConsistency() // [END eventual_consistent_query] _ = query // Use client.Run or client.GetAll to execute the query. }
func ExampleQuery_Ancestor() { // [START ancestor_query] ancestor := datastore.NameKey("TaskList", "default", nil) query := datastore.NewQuery("Task").Ancestor(ancestor) // [END ancestor_query] _ = query // Use client.Run or client.GetAll to execute the query. }
func ExampleQuery_keyFilter() { // [START key_filter] key := datastore.NameKey("Task", "someTask", nil) query := datastore.NewQuery("Task").Filter("__key__ >", key) // [END key_filter] _ = query // Use client.Run or client.GetAll to execute the query. }
func ExampleClient_RunInTransaction() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } // Increment a counter. // See https://cloud.google.com/appengine/articles/sharding_counters for // a more scalable solution. type Counter struct { Count int } var count int key := datastore.NameKey("Counter", "singleton", nil) _, err = client.RunInTransaction(ctx, func(tx *datastore.Transaction) error { var x Counter if err := tx.Get(key, &x); err != nil && err != datastore.ErrNoSuchEntity { return err } x.Count++ if _, err := tx.Put(key, &x); err != nil { return err } count = x.Count return nil }) if err != nil { // TODO: Handle error. } // The value of count is only valid once the transaction is successful // (RunInTransaction has returned nil). fmt.Printf("Count=%d\n", count) }
func ExampleClient_Put() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } type Article struct { Title string Description string Body string `datastore:",noindex"` Author *datastore.Key PublishedAt time.Time } newKey := datastore.IncompleteKey("Article", nil) _, err = client.Put(ctx, newKey, &Article{ Title: "The title of the article", Description: "The description of the article...", Body: "...", Author: datastore.NameKey("Author", "jbd", nil), PublishedAt: time.Now(), }) if err != nil { // TODO: Handle error. } }
func ExampleClient_GetMulti() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } keys := []*datastore.Key{ datastore.NameKey("Post", "post1", nil), datastore.NameKey("Post", "post2", nil), datastore.NameKey("Post", "post3", nil), } posts := make([]Post, 3) if err := client.GetMulti(ctx, keys, posts); err != nil { // TODO: Handle error. } }
func ExampleClient_Delete() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") key := datastore.NameKey("Task", "sampletask", nil) // [START delete] err := client.Delete(ctx, key) // [END delete] _ = err // Make sure you check err. }
func ExampleClient_Get() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") taskKey := datastore.NameKey("Task", "sampleTask", nil) // [START lookup] var task Task err := client.Get(ctx, taskKey, &task) // [END lookup] _ = err // Make sure you check err. }
func ExampleClient_PutMulti_interfaceSlice() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } keys := []*datastore.Key{ datastore.NameKey("Post", "post1", nil), datastore.NameKey("Post", "post2", nil), } // PutMulti with an empty interface slice. posts := []interface{}{ &Post{Title: "Post 1", PublishedAt: time.Now()}, &Post{Title: "Post 2", PublishedAt: time.Now()}, } if _, err := client.PutMulti(ctx, keys, posts); err != nil { // TODO: Handle error. } }
func ExampleClient_Delete() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } key := datastore.NameKey("Article", "articled1", nil) if err := client.Delete(ctx, key); err != nil { // TODO: Handle error. } }
func Example_metadataPropertiesForKind() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") // [START property_by_kind_run_query] kindKey := datastore.NameKey("__kind__", "Task", nil) query := datastore.NewQuery("__property__").Ancestor(kindKey) type Prop struct { Repr []string `datastore:"property_representation"` } var props []Prop keys, err := client.GetAll(ctx, query, &props) // [END property_by_kind_run_query] _ = err // Check error. _ = keys // Use keys to find property names, and props for their representations. }
func ExampleTransaction_runQuery() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") // [START transactional_single_entity_group_read_only] tx, err := client.NewTransaction(ctx) if err != nil { log.Fatalf("client.NewTransaction: %v", err) } defer tx.Rollback() // Transaction only used for read. ancestor := datastore.NameKey("TaskList", "default", nil) query := datastore.NewQuery("Task").Ancestor(ancestor).Transaction(tx) var tasks []Task _, err = client.GetAll(ctx, query, &tasks) // [END transactional_single_entity_group_read_only] _ = err // Check error. }
func ExampleTransaction_insert() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") task := Task{} // Populated with appropriate data. taskKey := datastore.NameKey("Task", "sampleTask", nil) // [START insert] _, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error { // We first check that there is no entity stored with the given key. var empty Task if err := tx.Get(taskKey, &empty); err != datastore.ErrNoSuchEntity { return err } // If there was no matching entity, store it now. _, err := tx.Put(taskKey, &task) return err }) // [END insert] _ = err // Make sure you check err. }
func ExampleClient_Put() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") // [START entity_with_parent] parentKey := datastore.NameKey("TaskList", "default", nil) key := datastore.IncompleteKey("Task", parentKey) task := Task{ Category: "Personal", Done: false, Priority: 4, Description: "Learn Cloud Datastore", } // A complete key is assigned to the entity when it is Put. var err error key, err = client.Put(ctx, key, &task) // [END entity_with_parent] _ = err // Make sure you check err. }
func ExampleClient_Get() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } type Article struct { Title string Description string Body string `datastore:",noindex"` Author *datastore.Key PublishedAt time.Time } key := datastore.NameKey("Article", "articled1", nil) article := &Article{} if err := client.Get(ctx, key, article); err != nil { // TODO: Handle error. } }
func ExampleClient_NewTransaction() { ctx := context.Background() client, err := datastore.NewClient(ctx, "project-id") if err != nil { // TODO: Handle error. } const retries = 3 // Increment a counter. // See https://cloud.google.com/appengine/articles/sharding_counters for // a more scalable solution. type Counter struct { Count int } key := datastore.NameKey("counter", "CounterA", nil) var tx *datastore.Transaction for i := 0; i < retries; i++ { tx, err = client.NewTransaction(ctx) if err != nil { break } var c Counter if err = tx.Get(key, &c); err != nil && err != datastore.ErrNoSuchEntity { break } c.Count++ if _, err = tx.Put(key, &c); err != nil { break } // Attempt to commit the transaction. If there's a conflict, try again. if _, err = tx.Commit(); err != datastore.ErrConcurrentTransaction { break } } if err != nil { // TODO: Handle error. } }
func ExampleTransaction_getOrCreate() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") key := datastore.NameKey("Task", "sampletask", nil) // [START transactional_get_or_create] _, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error { var task Task if err := tx.Get(key, &task); err != datastore.ErrNoSuchEntity { return err } _, err := tx.Put(key, &Task{ Category: "Personal", Done: false, Priority: 4, Description: "Learn Cloud Datastore", }) return err }) // [END transactional_get_or_create] _ = err // Check error. }
func ExampleTransaction_update() { ctx := context.Background() client, _ := datastore.NewClient(ctx, "my-proj") taskKey := datastore.NameKey("Task", "sampleTask", nil) // [START update] tx, err := client.NewTransaction(ctx) if err != nil { log.Fatalf("client.NewTransaction: %v", err) } var task Task if err := tx.Get(taskKey, &task); err != nil { log.Fatalf("tx.Get: %v", err) } task.Priority = 5 if _, err := tx.Put(taskKey, task); err != nil { log.Fatalf("tx.Put: %v", err) } if _, err := tx.Commit(); err != nil { log.Fatalf("tx.Commit: %v", err) } // [END update] }
func ExampleNameKey() { // Key with string ID. k := datastore.NameKey("Article", "article8", nil) _ = k // TODO: Use key. }
func ExampleNewKey() { // [START named_key] taskKey := datastore.NameKey("Task", "sampletask", nil) // [END named_key] _ = taskKey // Use the task key for datastore operations. }
// makeRequests makes some requests. // req is an incoming request used to construct the trace. traceClient is the // client used to upload the trace. rt is the trace client's http client's // transport. This is used to retrieve the trace uploaded by the client, if // any. If expectTrace is true, we expect a trace will be uploaded. If // synchronous is true, the call to Finish is expected not to return before the // client has uploaded any traces. func makeRequests(t *testing.T, req *http.Request, traceClient *Client, rt *fakeRoundTripper, synchronous bool, expectTrace bool) *http.Request { span := traceClient.SpanFromRequest(req) ctx := NewContext(context.Background(), span) // An HTTP request. { req2, err := http.NewRequest("GET", "http://example.com/bar", nil) if err != nil { t.Fatal(err) } resp := &http.Response{StatusCode: 200} s := span.NewRemoteChild(req2) s.Finish(WithResponse(resp)) } // An autogenerated API call. { rt := &fakeRoundTripper{reqc: make(chan *http.Request, 1)} hc := &http.Client{Transport: rt} computeClient, err := compute.New(hc) if err != nil { t.Fatal(err) } _, err = computeClient.Zones.List(testProjectID).Context(ctx).Do() if err != nil { t.Fatal(err) } } // A cloud library call that uses the autogenerated API. { rt := &fakeRoundTripper{reqc: make(chan *http.Request, 1)} hc := &http.Client{Transport: rt} storageClient, err := storage.NewClient(context.Background(), option.WithHTTPClient(hc)) if err != nil { t.Fatal(err) } var objAttrsList []*storage.ObjectAttrs it := storageClient.Bucket("testbucket").Objects(ctx, nil) for { objAttrs, err := it.Next() if err != nil && err != iterator.Done { t.Fatal(err) } if err == iterator.Done { break } objAttrsList = append(objAttrsList, objAttrs) } } // A cloud library call that uses grpc internally. for _, fail := range []bool{false, true} { srv, err := testutil.NewServer() if err != nil { t.Fatalf("creating test datastore server: %v", err) } dspb.RegisterDatastoreServer(srv.Gsrv, &fakeDatastoreServer{fail: fail}) srv.Start() conn, err := grpc.Dial(srv.Addr, grpc.WithInsecure(), EnableGRPCTracingDialOption) if err != nil { t.Fatalf("connecting to test datastore server: %v", err) } datastoreClient, err := datastore.NewClient(ctx, testProjectID, option.WithGRPCConn(conn)) if err != nil { t.Fatalf("creating datastore client: %v", err) } k := datastore.NameKey("Entity", "stringID", nil) e := new(datastore.Entity) datastoreClient.Get(ctx, k, e) } done := make(chan struct{}) go func() { if synchronous { err := span.FinishWait() if err != nil { t.Errorf("Unexpected error from span.FinishWait: %v", err) } } else { span.Finish() } done <- struct{}{} }() if !expectTrace { <-done select { case <-rt.reqc: t.Errorf("Got a trace, expected none.") case <-time.After(5 * time.Millisecond): } return nil } else if !synchronous { <-done return <-rt.reqc } else { select { case <-done: t.Errorf("Synchronous Finish didn't wait for trace upload.") return <-rt.reqc case <-time.After(5 * time.Millisecond): r := <-rt.reqc <-done return r } } }