From fe229ee2b103ee98a8d5a456f5647825216a3de6 Mon Sep 17 00:00:00 2001 From: Jason Hall Date: Sun, 12 May 2019 16:07:25 -0400 Subject: [PATCH] Cache revision->manifest in datastore --- Gopkg.lock | 13 +- cmd/buildpack/main.go | 87 +- .../cloud.google.com/go/datastore/client.go | 117 + .../go/datastore/datastore.go | 670 ++++++ .../go/datastore/datastore.replay | Bin 0 -> 3335560 bytes vendor/cloud.google.com/go/datastore/doc.go | 497 ++++ .../cloud.google.com/go/datastore/errors.go | 47 + vendor/cloud.google.com/go/datastore/key.go | 280 +++ vendor/cloud.google.com/go/datastore/load.go | 521 ++++ .../cloud.google.com/go/datastore/mutation.go | 129 + vendor/cloud.google.com/go/datastore/prop.go | 339 +++ vendor/cloud.google.com/go/datastore/query.go | 786 ++++++ vendor/cloud.google.com/go/datastore/save.go | 470 ++++ vendor/cloud.google.com/go/datastore/time.go | 36 + .../go/datastore/transaction.go | 402 ++++ .../go/internal/fields/fields.go | 480 ++++ .../go/internal/fields/fold.go | 156 ++ .../protobuf/ptypes/wrappers/wrappers.pb.go | 461 ++++ .../protobuf/ptypes/wrappers/wrappers.proto | 118 + .../googleapis/datastore/v1/datastore.pb.go | 2116 +++++++++++++++++ .../googleapis/datastore/v1/entity.pb.go | 927 ++++++++ .../googleapis/datastore/v1/query.pb.go | 1258 ++++++++++ .../googleapis/type/latlng/latlng.pb.go | 93 + 23 files changed, 9998 insertions(+), 5 deletions(-) create mode 100644 vendor/cloud.google.com/go/datastore/client.go create mode 100644 vendor/cloud.google.com/go/datastore/datastore.go create mode 100644 vendor/cloud.google.com/go/datastore/datastore.replay create mode 100644 vendor/cloud.google.com/go/datastore/doc.go create mode 100644 vendor/cloud.google.com/go/datastore/errors.go create mode 100644 vendor/cloud.google.com/go/datastore/key.go create mode 100644 vendor/cloud.google.com/go/datastore/load.go create mode 100644 vendor/cloud.google.com/go/datastore/mutation.go create mode 100644 vendor/cloud.google.com/go/datastore/prop.go create mode 100644 vendor/cloud.google.com/go/datastore/query.go create mode 100644 vendor/cloud.google.com/go/datastore/save.go create mode 100644 vendor/cloud.google.com/go/datastore/time.go create mode 100644 vendor/cloud.google.com/go/datastore/transaction.go create mode 100644 vendor/cloud.google.com/go/internal/fields/fields.go create mode 100644 vendor/cloud.google.com/go/internal/fields/fold.go create mode 100644 vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go create mode 100644 vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto create mode 100644 vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go create mode 100644 vendor/google.golang.org/genproto/googleapis/datastore/v1/entity.pb.go create mode 100644 vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go create mode 100644 vendor/google.golang.org/genproto/googleapis/type/latlng/latlng.pb.go diff --git a/Gopkg.lock b/Gopkg.lock index fa57bbd..93d1262 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -2,12 +2,14 @@ [[projects]] - digest = "1:f0f96805f0c22d8fcb1114a2359c8ba250997772916a5b4e3ba98857b1356fb4" + digest = "1:7d4ae02f02b59fc967428e108406234c1ae9bb901aa163bb99d4c4b3e2a3c561" name = "cloud.google.com/go" packages = [ "compute/metadata", + "datastore", "iam", "internal", + "internal/fields", "internal/optional", "internal/trace", "internal/version", @@ -21,7 +23,7 @@ version = "v0.38.0" [[projects]] - digest = "1:1882d3bab192c14c94b61781ff6d3965362f98527f895987793908304e90c118" + digest = "1:1d3ad0f6a57c08e2168089a64c34313930571fcbe5359d71c608a97ce504f7ca" name = "github.com/golang/protobuf" packages = [ "proto", @@ -32,6 +34,7 @@ "ptypes/empty", "ptypes/struct", "ptypes/timestamp", + "ptypes/wrappers", ] pruneopts = "UT" revision = "b5d812f8a3706043e23a9cd5babf2e5423744d30" @@ -229,7 +232,7 @@ [[projects]] branch = "master" - digest = "1:9b3077a28e959d99788fefe3e1abb8ba9dd897b955227bdfb58b1a389ffc0660" + digest = "1:f24be77fdd5624b07d22093335e50834602f49eca8b7247847ff4f2b7e411726" name = "google.golang.org/genproto" packages = [ "googleapis/api", @@ -238,11 +241,13 @@ "googleapis/api/label", "googleapis/api/metric", "googleapis/api/monitoredres", + "googleapis/datastore/v1", "googleapis/iam/v1", "googleapis/logging/type", "googleapis/logging/v2", "googleapis/rpc/code", "googleapis/rpc/status", + "googleapis/type/latlng", "protobuf/field_mask", ] pruneopts = "UT" @@ -295,6 +300,7 @@ analyzer-version = 1 input-imports = [ "cloud.google.com/go/compute/metadata", + "cloud.google.com/go/datastore", "cloud.google.com/go/logging", "cloud.google.com/go/storage", "github.com/google/go-containerregistry/pkg/authn", @@ -302,6 +308,7 @@ "github.com/google/go-containerregistry/pkg/v1", "github.com/google/go-containerregistry/pkg/v1/random", "github.com/google/go-containerregistry/pkg/v1/remote", + "github.com/google/go-containerregistry/pkg/v1/types", "github.com/google/ko/pkg/build", "golang.org/x/oauth2/google", "google.golang.org/api/googleapi", diff --git a/cmd/buildpack/main.go b/cmd/buildpack/main.go index ca6a8ac..fed13b6 100644 --- a/cmd/buildpack/main.go +++ b/cmd/buildpack/main.go @@ -1,9 +1,12 @@ package main import ( + "bytes" "context" "encoding/base64" + "encoding/json" "fmt" + "io" "io/ioutil" "log" "net/http" @@ -12,11 +15,13 @@ import ( "time" "cloud.google.com/go/compute/metadata" + "cloud.google.com/go/datastore" "cloud.google.com/go/logging" "github.com/google/go-containerregistry/pkg/authn" "github.com/google/go-containerregistry/pkg/name" "github.com/google/go-containerregistry/pkg/v1" "github.com/google/go-containerregistry/pkg/v1/remote" + "github.com/google/go-containerregistry/pkg/v1/types" "github.com/imjasonh/kontain.me/pkg/run" "github.com/imjasonh/kontain.me/pkg/serve" "golang.org/x/oauth2/google" @@ -42,9 +47,15 @@ func main() { } lg := client.Logger("server") + dsClient, err := datastore.NewClient(ctx, projectID) + if err != nil { + log.Fatalf("datastore.NewClient: %v", err) + } + http.Handle("/v2/", &server{ - info: lg.StandardLogger(logging.Info), - error: lg.StandardLogger(logging.Error), + info: lg.StandardLogger(logging.Info), + error: lg.StandardLogger(logging.Error), + datastore: dsClient, }) log.Println("Starting...") @@ -59,6 +70,7 @@ func main() { type server struct { info, error *log.Logger + datastore *datastore.Client } func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) { @@ -108,6 +120,21 @@ func (s *server) serveBuildpackManifest(w http.ResponseWriter, r *http.Request) if revision == "latest" { revision = "master" } + // Resolve branch/tag/whatever -> SHA + revision, err = s.resolveCommit(repo, revision) + if err != nil { + s.error.Println("ERROR(resolveCommit):", err) + serve.Error(w, err) + return + } + + // Check whether we have a cached manfiest for this revision. + // If we do, just serve it. + if b := s.checkCachedManifest(revision); len(b) != 0 { + w.Header().Set("Content-Type", string(types.DockerManifestSchema2)) // TODO: don't hard-code + io.Copy(w, bytes.NewReader(b)) + return + } // Fetch, detect and build source. image, err := s.fetchAndBuild(src, layers, repo, revision) @@ -124,9 +151,65 @@ func (s *server) serveBuildpackManifest(w http.ResponseWriter, r *http.Request) serve.Error(w, err) return } + + // Cache the generated manifest. + if b, _ := img.RawManifest(); len(b) != 0 { + s.putCachedManifest(revision, b) + } + + // Serve the manifest. serve.Manifest(w, img) } +type cachedManifest struct { + Manifest []byte `datastore:",noindex"` +} + +func (s *server) checkCachedManifest(revision string) []byte { + k := datastore.NameKey("Manifests", revision, nil) + var e cachedManifest + ctx := context.Background() // TODO + if err := s.datastore.Get(ctx, k, &e); err == datastore.ErrNoSuchEntity { + s.info.Printf("No cached manifest digest for %q", revision) + } else if err != nil { + s.error.Printf("datastore.Get: %v", err) + } + return e.Manifest +} + +func (s *server) putCachedManifest(revision string, manifest []byte) { + k := datastore.NameKey("Manifests", revision, nil) + e := cachedManifest{manifest} + ctx := context.Background() // TODO + if _, err := s.datastore.Put(ctx, k, &e); err != nil { + s.error.Printf("datastore.Put: %v", err) + } +} + +// Resolves a ref (branch, tag, PR, commit) into its SHA. +// https://developer.github.com/v3/repos/commits/#get-the-sha-1-of-a-commit-reference +func (s *server) resolveCommit(repo, ref string) (string, error) { + url := fmt.Sprintf("https://api.github.com/repos/%s/commits/%s", repo, ref) + resp, err := http.Get(url) // TODO: cache this lookup? + if err != nil { + return "", err + } + if resp.StatusCode == http.StatusNotFound { + return "", serve.ErrNotFound + } else if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("Error resolving %q (%d): %v", url, resp.StatusCode, resp.Status) + } + defer resp.Body.Close() + var r struct { + SHA string `json:"sha"` + } + if err := json.NewDecoder(resp.Body).Decode(&r); err != nil { + return "", err + } + s.info.Printf("Resolved %q -> %q\n", ref, r.SHA) + return r.SHA, nil +} + func (s *server) prepareWorkspace() (string, string, error) { // Write Docker config. tok, err := google.ComputeTokenSource("").Token() diff --git a/vendor/cloud.google.com/go/datastore/client.go b/vendor/cloud.google.com/go/datastore/client.go new file mode 100644 index 0000000..618d8bb --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/client.go @@ -0,0 +1,117 @@ +// Copyright 2017 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "context" + "fmt" + + "cloud.google.com/go/internal" + "cloud.google.com/go/internal/version" + gax "github.com/googleapis/gax-go/v2" + pb "google.golang.org/genproto/googleapis/datastore/v1" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// datastoreClient is a wrapper for the pb.DatastoreClient that includes gRPC +// metadata to be sent in each request for server-side traffic management. +type datastoreClient struct { + // Embed so we still implement the DatastoreClient interface, + // if the interface adds more methods. + pb.DatastoreClient + + c pb.DatastoreClient + md metadata.MD +} + +func newDatastoreClient(conn *grpc.ClientConn, projectID string) pb.DatastoreClient { + return &datastoreClient{ + c: pb.NewDatastoreClient(conn), + md: metadata.Pairs( + resourcePrefixHeader, "projects/"+projectID, + "x-goog-api-client", fmt.Sprintf("gl-go/%s gccl/%s grpc/", version.Go(), version.Repo)), + } +} + +func (dc *datastoreClient) Lookup(ctx context.Context, in *pb.LookupRequest, opts ...grpc.CallOption) (res *pb.LookupResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.Lookup(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) RunQuery(ctx context.Context, in *pb.RunQueryRequest, opts ...grpc.CallOption) (res *pb.RunQueryResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.RunQuery(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) BeginTransaction(ctx context.Context, in *pb.BeginTransactionRequest, opts ...grpc.CallOption) (res *pb.BeginTransactionResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.BeginTransaction(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) Commit(ctx context.Context, in *pb.CommitRequest, opts ...grpc.CallOption) (res *pb.CommitResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.Commit(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) Rollback(ctx context.Context, in *pb.RollbackRequest, opts ...grpc.CallOption) (res *pb.RollbackResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.Rollback(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) AllocateIds(ctx context.Context, in *pb.AllocateIdsRequest, opts ...grpc.CallOption) (res *pb.AllocateIdsResponse, err error) { + err = dc.invoke(ctx, func(ctx context.Context) error { + res, err = dc.c.AllocateIds(ctx, in, opts...) + return err + }) + return res, err +} + +func (dc *datastoreClient) invoke(ctx context.Context, f func(ctx context.Context) error) error { + ctx = metadata.NewOutgoingContext(ctx, dc.md) + return internal.Retry(ctx, gax.Backoff{}, func() (stop bool, err error) { + err = f(ctx) + return !shouldRetry(err), err + }) +} + +func shouldRetry(err error) bool { + if err == nil { + return false + } + s, ok := status.FromError(err) + if !ok { + return false + } + // See https://cloud.google.com/datastore/docs/concepts/errors. + return s.Code() == codes.Unavailable || s.Code() == codes.DeadlineExceeded +} diff --git a/vendor/cloud.google.com/go/datastore/datastore.go b/vendor/cloud.google.com/go/datastore/datastore.go new file mode 100644 index 0000000..dbf085c --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/datastore.go @@ -0,0 +1,670 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "context" + "errors" + "fmt" + "log" + "os" + "reflect" + + "cloud.google.com/go/internal/trace" + "google.golang.org/api/option" + "google.golang.org/api/transport" + gtransport "google.golang.org/api/transport/grpc" + pb "google.golang.org/genproto/googleapis/datastore/v1" + "google.golang.org/grpc" +) + +const ( + prodAddr = "datastore.googleapis.com:443" + userAgent = "gcloud-golang-datastore/20160401" +) + +// ScopeDatastore grants permissions to view and/or manage datastore entities +const ScopeDatastore = "https://www.googleapis.com/auth/datastore" + +// DetectProjectID is a sentinel value that instructs NewClient to detect the +// project ID. It is given in place of the projectID argument. NewClient will +// use the project ID from the given credentials or the default credentials +// (https://developers.google.com/accounts/docs/application-default-credentials) +// if no credentials were provided. When providing credentials, not all +// options will allow NewClient to extract the project ID. Specifically a JWT +// does not have the project ID encoded. +const DetectProjectID = "*detect-project-id*" + +// resourcePrefixHeader is the name of the metadata header used to indicate +// the resource being operated on. +const resourcePrefixHeader = "google-cloud-resource-prefix" + +// Client is a client for reading and writing data in a datastore dataset. +type Client struct { + conn *grpc.ClientConn + client pb.DatastoreClient + dataset string // Called dataset by the datastore API, synonym for project ID. +} + +// NewClient creates a new Client for a given dataset. If the project ID is +// empty, it is derived from the DATASTORE_PROJECT_ID environment variable. +// If the DATASTORE_EMULATOR_HOST environment variable is set, client will use +// its value to connect to a locally-running datastore emulator. +// DetectProjectID can be passed as the projectID argument to instruct +// NewClient to detect the project ID from the credentials. +func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { + var o []option.ClientOption + // Environment variables for gcd emulator: + // https://cloud.google.com/datastore/docs/tools/datastore-emulator + // If the emulator is available, dial it without passing any credentials. + if addr := os.Getenv("DATASTORE_EMULATOR_HOST"); addr != "" { + o = []option.ClientOption{ + option.WithEndpoint(addr), + option.WithoutAuthentication(), + option.WithGRPCDialOption(grpc.WithInsecure()), + } + } else { + o = []option.ClientOption{ + option.WithEndpoint(prodAddr), + option.WithScopes(ScopeDatastore), + option.WithUserAgent(userAgent), + } + } + // Warn if we see the legacy emulator environment variables. + if os.Getenv("DATASTORE_HOST") != "" && os.Getenv("DATASTORE_EMULATOR_HOST") == "" { + log.Print("WARNING: legacy environment variable DATASTORE_HOST is ignored. Use DATASTORE_EMULATOR_HOST instead.") + } + if os.Getenv("DATASTORE_DATASET") != "" && os.Getenv("DATASTORE_PROJECT_ID") == "" { + log.Print("WARNING: legacy environment variable DATASTORE_DATASET is ignored. Use DATASTORE_PROJECT_ID instead.") + } + if projectID == "" { + projectID = os.Getenv("DATASTORE_PROJECT_ID") + } + + o = append(o, opts...) + + if projectID == DetectProjectID { + creds, err := transport.Creds(ctx, o...) + if err != nil { + return nil, fmt.Errorf("fetching creds: %v", err) + } + + if creds.ProjectID == "" { + return nil, errors.New("datastore: see the docs on DetectProjectID") + } + + projectID = creds.ProjectID + } + + if projectID == "" { + return nil, errors.New("datastore: missing project/dataset id") + } + conn, err := gtransport.Dial(ctx, o...) + if err != nil { + return nil, fmt.Errorf("dialing: %v", err) + } + return &Client{ + conn: conn, + client: newDatastoreClient(conn, projectID), + dataset: projectID, + }, nil +} + +var ( + // ErrInvalidEntityType is returned when functions like Get or Next are + // passed a dst or src argument of invalid type. + ErrInvalidEntityType = errors.New("datastore: invalid entity type") + // ErrInvalidKey is returned when an invalid key is presented. + ErrInvalidKey = errors.New("datastore: invalid key") + // ErrNoSuchEntity is returned when no entity was found for a given key. + ErrNoSuchEntity = errors.New("datastore: no such entity") +) + +type multiArgType int + +const ( + multiArgTypeInvalid multiArgType = iota + multiArgTypePropertyLoadSaver + multiArgTypeStruct + multiArgTypeStructPtr + multiArgTypeInterface +) + +// ErrFieldMismatch is returned when a field is to be loaded into a different +// type than the one it was stored from, or when a field is missing or +// unexported in the destination struct. +// StructType is the type of the struct pointed to by the destination argument +// passed to Get or to Iterator.Next. +type ErrFieldMismatch struct { + StructType reflect.Type + FieldName string + Reason string +} + +func (e *ErrFieldMismatch) Error() string { + return fmt.Sprintf("datastore: cannot load field %q into a %q: %s", + e.FieldName, e.StructType, e.Reason) +} + +// GeoPoint represents a location as latitude/longitude in degrees. +type GeoPoint struct { + Lat, Lng float64 +} + +// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude. +func (g GeoPoint) Valid() bool { + return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180 +} + +func keyToProto(k *Key) *pb.Key { + if k == nil { + return nil + } + + var path []*pb.Key_PathElement + for { + el := &pb.Key_PathElement{Kind: k.Kind} + if k.ID != 0 { + el.IdType = &pb.Key_PathElement_Id{Id: k.ID} + } else if k.Name != "" { + el.IdType = &pb.Key_PathElement_Name{Name: k.Name} + } + path = append(path, el) + if k.Parent == nil { + break + } + k = k.Parent + } + + // The path should be in order [grandparent, parent, child] + // We did it backward above, so reverse back. + for i := 0; i < len(path)/2; i++ { + path[i], path[len(path)-i-1] = path[len(path)-i-1], path[i] + } + + key := &pb.Key{Path: path} + if k.Namespace != "" { + key.PartitionId = &pb.PartitionId{ + NamespaceId: k.Namespace, + } + } + return key +} + +// protoToKey decodes a protocol buffer representation of a key into an +// equivalent *Key object. If the key is invalid, protoToKey will return the +// invalid key along with ErrInvalidKey. +func protoToKey(p *pb.Key) (*Key, error) { + var key *Key + var namespace string + if partition := p.PartitionId; partition != nil { + namespace = partition.NamespaceId + } + for _, el := range p.Path { + key = &Key{ + Namespace: namespace, + Kind: el.Kind, + ID: el.GetId(), + Name: el.GetName(), + Parent: key, + } + } + if !key.valid() { // Also detects key == nil. + return key, ErrInvalidKey + } + return key, nil +} + +// multiKeyToProto is a batch version of keyToProto. +func multiKeyToProto(keys []*Key) []*pb.Key { + ret := make([]*pb.Key, len(keys)) + for i, k := range keys { + ret[i] = keyToProto(k) + } + return ret +} + +// multiKeyToProto is a batch version of keyToProto. +func multiProtoToKey(keys []*pb.Key) ([]*Key, error) { + hasErr := false + ret := make([]*Key, len(keys)) + err := make(MultiError, len(keys)) + for i, k := range keys { + ret[i], err[i] = protoToKey(k) + if err[i] != nil { + hasErr = true + } + } + if hasErr { + return nil, err + } + return ret, nil +} + +// multiValid is a batch version of Key.valid. It returns an error, not a +// []bool. +func multiValid(key []*Key) error { + invalid := false + for _, k := range key { + if !k.valid() { + invalid = true + break + } + } + if !invalid { + return nil + } + err := make(MultiError, len(key)) + for i, k := range key { + if !k.valid() { + err[i] = ErrInvalidKey + } + } + return err +} + +// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct +// type S, for some interface type I, or some non-interface non-pointer type P +// such that P or *P implements PropertyLoadSaver. +// +// It returns what category the slice's elements are, and the reflect.Type +// that represents S, I or P. +// +// As a special case, PropertyList is an invalid type for v. +func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) { + // TODO(djd): multiArg is very confusing. Fold this logic into the + // relevant Put/Get methods to make the logic less opaque. + if v.Kind() != reflect.Slice { + return multiArgTypeInvalid, nil + } + if v.Type() == typeOfPropertyList { + return multiArgTypeInvalid, nil + } + elemType = v.Type().Elem() + if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) { + return multiArgTypePropertyLoadSaver, elemType + } + switch elemType.Kind() { + case reflect.Struct: + return multiArgTypeStruct, elemType + case reflect.Interface: + return multiArgTypeInterface, elemType + case reflect.Ptr: + elemType = elemType.Elem() + if elemType.Kind() == reflect.Struct { + return multiArgTypeStructPtr, elemType + } + } + return multiArgTypeInvalid, nil +} + +// Close closes the Client. +func (c *Client) Close() error { + return c.conn.Close() +} + +// Get loads the entity stored for key into dst, which must be a struct pointer +// or implement PropertyLoadSaver. If there is no such entity for the key, Get +// returns ErrNoSuchEntity. +// +// The values of dst's unmatched struct fields are not modified, and matching +// slice-typed fields are not reset before appending to them. In particular, it +// is recommended to pass a pointer to a zero valued struct on each Get call. +// +// ErrFieldMismatch is returned when a field is to be loaded into a different +// type than the one it was stored from, or when a field is missing or +// unexported in the destination struct. ErrFieldMismatch is only returned if +// dst is a struct pointer. +func (c *Client) Get(ctx context.Context, key *Key, dst interface{}) (err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.Get") + defer func() { trace.EndSpan(ctx, err) }() + + if dst == nil { // get catches nil interfaces; we need to catch nil ptr here + return ErrInvalidEntityType + } + err = c.get(ctx, []*Key{key}, []interface{}{dst}, nil) + if me, ok := err.(MultiError); ok { + return me[0] + } + return err +} + +// GetMulti is a batch version of Get. +// +// dst must be a []S, []*S, []I or []P, for some struct type S, some interface +// type I, or some non-interface non-pointer type P such that P or *P +// implements PropertyLoadSaver. If an []I, each element must be a valid dst +// for Get: it must be a struct pointer or implement PropertyLoadSaver. +// +// As a special case, PropertyList is an invalid type for dst, even though a +// PropertyList is a slice of structs. It is treated as invalid to avoid being +// mistakenly passed when []PropertyList was intended. +// +// err may be a MultiError. See ExampleMultiError to check it. +func (c *Client) GetMulti(ctx context.Context, keys []*Key, dst interface{}) (err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.GetMulti") + defer func() { trace.EndSpan(ctx, err) }() + + return c.get(ctx, keys, dst, nil) +} + +func (c *Client) get(ctx context.Context, keys []*Key, dst interface{}, opts *pb.ReadOptions) error { + v := reflect.ValueOf(dst) + multiArgType, _ := checkMultiArg(v) + + // Sanity checks + if multiArgType == multiArgTypeInvalid { + return errors.New("datastore: dst has invalid type") + } + if len(keys) != v.Len() { + return errors.New("datastore: keys and dst slices have different length") + } + if len(keys) == 0 { + return nil + } + + // Go through keys, validate them, serialize then, and create a dict mapping them to their indices. + // Equal keys are deduped. + multiErr, any := make(MultiError, len(keys)), false + keyMap := make(map[string][]int, len(keys)) + pbKeys := make([]*pb.Key, 0, len(keys)) + for i, k := range keys { + if !k.valid() { + multiErr[i] = ErrInvalidKey + any = true + } else if k.Incomplete() { + multiErr[i] = fmt.Errorf("datastore: can't get the incomplete key: %v", k) + any = true + } else { + ks := k.String() + if _, ok := keyMap[ks]; !ok { + pbKeys = append(pbKeys, keyToProto(k)) + } + keyMap[ks] = append(keyMap[ks], i) + } + } + if any { + return multiErr + } + req := &pb.LookupRequest{ + ProjectId: c.dataset, + Keys: pbKeys, + ReadOptions: opts, + } + resp, err := c.client.Lookup(ctx, req) + if err != nil { + return err + } + found := resp.Found + missing := resp.Missing + // Upper bound 100 iterations to prevent infinite loop. + // We choose 100 iterations somewhat logically: + // Max number of Entities you can request from Datastore is 1,000. + // Max size for a Datastore Entity is 1 MiB. + // Max request size is 10 MiB, so we assume max response size is also 10 MiB. + // 1,000 / 10 = 100. + // Note that if ctx has a deadline, the deadline will probably + // be hit before we reach 100 iterations. + for i := 0; len(resp.Deferred) > 0 && i < 100; i++ { + req.Keys = resp.Deferred + resp, err = c.client.Lookup(ctx, req) + if err != nil { + return err + } + found = append(found, resp.Found...) + missing = append(missing, resp.Missing...) + } + + filled := 0 + for _, e := range found { + k, err := protoToKey(e.Entity.Key) + if err != nil { + return errors.New("datastore: internal error: server returned an invalid key") + } + filled += len(keyMap[k.String()]) + for _, index := range keyMap[k.String()] { + elem := v.Index(index) + if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct { + elem = elem.Addr() + } + if multiArgType == multiArgTypeStructPtr && elem.IsNil() { + elem.Set(reflect.New(elem.Type().Elem())) + } + if err := loadEntityProto(elem.Interface(), e.Entity); err != nil { + multiErr[index] = err + any = true + } + } + } + for _, e := range missing { + k, err := protoToKey(e.Entity.Key) + if err != nil { + return errors.New("datastore: internal error: server returned an invalid key") + } + filled += len(keyMap[k.String()]) + for _, index := range keyMap[k.String()] { + multiErr[index] = ErrNoSuchEntity + } + any = true + } + + if filled != len(keys) { + return errors.New("datastore: internal error: server returned the wrong number of entities") + } + + if any { + return multiErr + } + return nil +} + +// Put saves the entity src into the datastore with the given key. src must be +// a struct pointer or implement PropertyLoadSaver; if the struct pointer has +// any unexported fields they will be skipped. If the key is incomplete, the +// returned key will be a unique key generated by the datastore. +func (c *Client) Put(ctx context.Context, key *Key, src interface{}) (*Key, error) { + k, err := c.PutMulti(ctx, []*Key{key}, []interface{}{src}) + if err != nil { + if me, ok := err.(MultiError); ok { + return nil, me[0] + } + return nil, err + } + return k[0], nil +} + +// PutMulti is a batch version of Put. +// +// src must satisfy the same conditions as the dst argument to GetMulti. +// err may be a MultiError. See ExampleMultiError to check it. +func (c *Client) PutMulti(ctx context.Context, keys []*Key, src interface{}) (ret []*Key, err error) { + // TODO(jba): rewrite in terms of Mutate. + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.PutMulti") + defer func() { trace.EndSpan(ctx, err) }() + + mutations, err := putMutations(keys, src) + if err != nil { + return nil, err + } + + // Make the request. + req := &pb.CommitRequest{ + ProjectId: c.dataset, + Mutations: mutations, + Mode: pb.CommitRequest_NON_TRANSACTIONAL, + } + resp, err := c.client.Commit(ctx, req) + if err != nil { + return nil, err + } + + // Copy any newly minted keys into the returned keys. + ret = make([]*Key, len(keys)) + for i, key := range keys { + if key.Incomplete() { + // This key is in the mutation results. + ret[i], err = protoToKey(resp.MutationResults[i].Key) + if err != nil { + return nil, errors.New("datastore: internal error: server returned an invalid key") + } + } else { + ret[i] = key + } + } + return ret, nil +} + +func putMutations(keys []*Key, src interface{}) ([]*pb.Mutation, error) { + v := reflect.ValueOf(src) + multiArgType, _ := checkMultiArg(v) + if multiArgType == multiArgTypeInvalid { + return nil, errors.New("datastore: src has invalid type") + } + if len(keys) != v.Len() { + return nil, errors.New("datastore: key and src slices have different length") + } + if len(keys) == 0 { + return nil, nil + } + if err := multiValid(keys); err != nil { + return nil, err + } + mutations := make([]*pb.Mutation, 0, len(keys)) + multiErr := make(MultiError, len(keys)) + hasErr := false + for i, k := range keys { + elem := v.Index(i) + // Two cases where we need to take the address: + // 1) multiArgTypePropertyLoadSaver => &elem implements PLS + // 2) multiArgTypeStruct => saveEntity needs *struct + if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct { + elem = elem.Addr() + } + p, err := saveEntity(k, elem.Interface()) + if err != nil { + multiErr[i] = err + hasErr = true + } + var mut *pb.Mutation + if k.Incomplete() { + mut = &pb.Mutation{Operation: &pb.Mutation_Insert{Insert: p}} + } else { + mut = &pb.Mutation{Operation: &pb.Mutation_Upsert{Upsert: p}} + } + mutations = append(mutations, mut) + } + if hasErr { + return nil, multiErr + } + return mutations, nil +} + +// Delete deletes the entity for the given key. +func (c *Client) Delete(ctx context.Context, key *Key) error { + err := c.DeleteMulti(ctx, []*Key{key}) + if me, ok := err.(MultiError); ok { + return me[0] + } + return err +} + +// DeleteMulti is a batch version of Delete. +// +// err may be a MultiError. See ExampleMultiError to check it. +func (c *Client) DeleteMulti(ctx context.Context, keys []*Key) (err error) { + // TODO(jba): rewrite in terms of Mutate. + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.DeleteMulti") + defer func() { trace.EndSpan(ctx, err) }() + + mutations, err := deleteMutations(keys) + if err != nil { + return err + } + + req := &pb.CommitRequest{ + ProjectId: c.dataset, + Mutations: mutations, + Mode: pb.CommitRequest_NON_TRANSACTIONAL, + } + _, err = c.client.Commit(ctx, req) + return err +} + +func deleteMutations(keys []*Key) ([]*pb.Mutation, error) { + mutations := make([]*pb.Mutation, 0, len(keys)) + set := make(map[string]bool, len(keys)) + multiErr := make(MultiError, len(keys)) + hasErr := false + for i, k := range keys { + if !k.valid() { + multiErr[i] = ErrInvalidKey + hasErr = true + } else if k.Incomplete() { + multiErr[i] = fmt.Errorf("datastore: can't delete the incomplete key: %v", k) + hasErr = true + } else { + ks := k.String() + if !set[ks] { + mutations = append(mutations, &pb.Mutation{ + Operation: &pb.Mutation_Delete{Delete: keyToProto(k)}, + }) + } + set[ks] = true + } + } + if hasErr { + return nil, multiErr + } + return mutations, nil +} + +// Mutate applies one or more mutations atomically. +// It returns the keys of the argument Mutations, in the same order. +// +// If any of the mutations are invalid, Mutate returns a MultiError with the errors. +// Mutate returns a MultiError in this case even if there is only one Mutation. +// See ExampleMultiError to check it. +func (c *Client) Mutate(ctx context.Context, muts ...*Mutation) (ret []*Key, err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.Mutate") + defer func() { trace.EndSpan(ctx, err) }() + + pmuts, err := mutationProtos(muts) + if err != nil { + return nil, err + } + req := &pb.CommitRequest{ + ProjectId: c.dataset, + Mutations: pmuts, + Mode: pb.CommitRequest_NON_TRANSACTIONAL, + } + resp, err := c.client.Commit(ctx, req) + if err != nil { + return nil, err + } + // Copy any newly minted keys into the returned keys. + ret = make([]*Key, len(muts)) + for i, mut := range muts { + if mut.key.Incomplete() { + // This key is in the mutation results. + ret[i], err = protoToKey(resp.MutationResults[i].Key) + if err != nil { + return nil, errors.New("datastore: internal error: server returned an invalid key") + } + } else { + ret[i] = mut.key + } + } + return ret, nil +} diff --git a/vendor/cloud.google.com/go/datastore/datastore.replay b/vendor/cloud.google.com/go/datastore/datastore.replay new file mode 100644 index 0000000000000000000000000000000000000000..25235ecd8ab8eb6ca0ba7e283c5fef35004218ef GIT binary patch literal 3335560 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%0AZ%V_$nB51f5Fe@%#93N5HUV-;ysh6OrA7p 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 literal 0 HcmV?d00001 diff --git a/vendor/cloud.google.com/go/datastore/doc.go b/vendor/cloud.google.com/go/datastore/doc.go new file mode 100644 index 0000000..7cf890f --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/doc.go @@ -0,0 +1,497 @@ +// Copyright 2016 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* +Package datastore provides a client for Google Cloud Datastore. + +See https://godoc.org/cloud.google.com/go for authentication, timeouts, +connection pooling and similar aspects of this package. + + +Basic Operations + +Entities are the unit of storage and are associated with a key. A key +consists of an optional parent key, a string application ID, a string kind +(also known as an entity type), and either a StringID or an IntID. A +StringID is also known as an entity name or key name. + +It is valid to create a key with a zero StringID and a zero IntID; this is +called an incomplete key, and does not refer to any saved entity. Putting an +entity into the datastore under an incomplete key will cause a unique key +to be generated for that entity, with a non-zero IntID. + +An entity's contents are a mapping from case-sensitive field names to values. +Valid value types are: + - Signed integers (int, int8, int16, int32 and int64) + - bool + - string + - float32 and float64 + - []byte (up to 1 megabyte in length) + - Any type whose underlying type is one of the above predeclared types + - *Key + - GeoPoint + - time.Time (stored with microsecond precision, retrieved as local time) + - Structs whose fields are all valid value types + - Pointers to structs whose fields are all valid value types + - Slices of any of the above + - Pointers to a signed integer, bool, string, float32, or float64 + +Slices of structs are valid, as are structs that contain slices. + +The Get and Put functions load and save an entity's contents. An entity's +contents are typically represented by a struct pointer. + +Example code: + + type Entity struct { + Value string + } + + func main() { + ctx := context.Background() + + // Create a datastore client. In a typical application, you would create + // a single client which is reused for every datastore operation. + dsClient, err := datastore.NewClient(ctx, "my-project") + if err != nil { + // Handle error. + } + + k := datastore.NameKey("Entity", "stringID", nil) + e := new(Entity) + if err := dsClient.Get(ctx, k, e); err != nil { + // Handle error. + } + + old := e.Value + e.Value = "Hello World!" + + if _, err := dsClient.Put(ctx, k, e); err != nil { + // Handle error. + } + + fmt.Printf("Updated value from %q to %q\n", old, e.Value) + } + +GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and +Delete functions. They take a []*Key instead of a *Key, and may return a +datastore.MultiError when encountering partial failure. + +Mutate generalizes PutMulti and DeleteMulti to a sequence of any Datastore mutations. +It takes a series of mutations created with NewInsert, NewUpdate, NewUpsert and +NewDelete and applies them atomically. + + +Properties + +An entity's contents can be represented by a variety of types. These are +typically struct pointers, but can also be any type that implements the +PropertyLoadSaver interface. If using a struct pointer, you do not have to +explicitly implement the PropertyLoadSaver interface; the datastore will +automatically convert via reflection. If a struct pointer does implement +PropertyLoadSaver then those methods will be used in preference to the default +behavior for struct pointers. Struct pointers are more strongly typed and are +easier to use; PropertyLoadSavers are more flexible. + +The actual types passed do not have to match between Get and Put calls or even +across different calls to datastore. It is valid to put a *PropertyList and +get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1. +Conceptually, any entity is saved as a sequence of properties, and is loaded +into the destination value on a property-by-property basis. When loading into +a struct pointer, an entity that cannot be completely represented (such as a +missing field) will result in an ErrFieldMismatch error but it is up to the +caller whether this error is fatal, recoverable or ignorable. + +By default, for struct pointers, all properties are potentially indexed, and +the property name is the same as the field name (and hence must start with an +upper case letter). + +Fields may have a `datastore:"name,options"` tag. The tag name is the +property name, which must be one or more valid Go identifiers joined by ".", +but may start with a lower case letter. An empty tag name means to just use the +field name. A "-" tag name means that the datastore will ignore that field. + +The only valid options are "omitempty", "noindex" and "flatten". + +If the options include "omitempty" and the value of the field is a zero value, +then the field will be omitted on Save. Zero values are best defined in the +golang spec (https://golang.org/ref/spec#The_zero_value). Struct field values +will never be empty, except for nil pointers. + +If options include "noindex" then the field will not be indexed. All fields +are indexed by default. Strings or byte slices longer than 1500 bytes cannot +be indexed; fields used to store long strings and byte slices must be tagged +with "noindex" or they will cause Put operations to fail. + +For a nested struct field, the options may also include "flatten". This +indicates that the immediate fields and any nested substruct fields of the +nested struct should be flattened. See below for examples. + +To use multiple options together, separate them by a comma. +The order does not matter. + +If the options is "" then the comma may be omitted. + +Example code: + + // A and B are renamed to a and b. + // A, C and J are not indexed. + // D's tag is equivalent to having no tag at all (E). + // I is ignored entirely by the datastore. + // J has tag information for both the datastore and json packages. + type TaggedStruct struct { + A int `datastore:"a,noindex"` + B int `datastore:"b"` + C int `datastore:",noindex"` + D int `datastore:""` + E int + I int `datastore:"-"` + J int `datastore:",noindex" json:"j"` + } + + +Slice Fields + +A field of slice type corresponds to a Datastore array property, except for []byte, which corresponds +to a Datastore blob. + +Zero-length slice fields are not saved. Slice fields of length 1 or greater are saved +as Datastore arrays. When a zero-length Datastore array is loaded into a slice field, +the slice field remains unchanged. + +If a non-array value is loaded into a slice field, the result will be a slice with +one element, containing the value. + +Loading Nulls + +Loading a Datastore Null into a basic type (int, float, etc.) results in a zero value. +Loading a Null into a slice of basic type results in a slice of size 1 containing the zero value. +Loading a Null into a pointer field results in nil. +Loading a Null into a field of struct type is an error. + +Pointer Fields + +A struct field can be a pointer to a signed integer, floating-point number, string or +bool. Putting a non-nil pointer will store its dereferenced value. Putting a nil +pointer will store a Datastore Null property, unless the field is marked omitempty, +in which case no property will be stored. + +Loading a Null into a pointer field sets the pointer to nil. Loading any other value +allocates new storage with the value, and sets the field to point to it. + + +Key Field + +If the struct contains a *datastore.Key field tagged with the name "__key__", +its value will be ignored on Put. When reading the Entity back into the Go struct, +the field will be populated with the *datastore.Key value used to query for +the Entity. + +Example code: + + type MyEntity struct { + A int + K *datastore.Key `datastore:"__key__"` + } + + func main() { + ctx := context.Background() + dsClient, err := datastore.NewClient(ctx, "my-project") + if err != nil { + // Handle error. + } + + k := datastore.NameKey("Entity", "stringID", nil) + e := MyEntity{A: 12} + if _, err := dsClient.Put(ctx, k, &e); err != nil { + // Handle error. + } + + var entities []MyEntity + q := datastore.NewQuery("Entity").Filter("A =", 12).Limit(1) + if _, err := dsClient.GetAll(ctx, q, &entities); err != nil { + // Handle error + } + + log.Println(entities[0]) + // Prints {12 /Entity,stringID} + } + + + +Structured Properties + +If the struct pointed to contains other structs, then the nested or embedded +structs are themselves saved as Entity values. For example, given these definitions: + + type Inner struct { + W int32 + X string + } + + type Outer struct { + I Inner + } + +then an Outer would have one property, Inner, encoded as an Entity value. + +If an outer struct is tagged "noindex" then all of its implicit flattened +fields are effectively "noindex". + +If the Inner struct contains a *Key field with the name "__key__", like so: + + type Inner struct { + W int32 + X string + K *datastore.Key `datastore:"__key__"` + } + + type Outer struct { + I Inner + } + +then the value of K will be used as the Key for Inner, represented +as an Entity value in datastore. + +If any nested struct fields should be flattened, instead of encoded as +Entity values, the nested struct field should be tagged with the "flatten" +option. For example, given the following: + + type Inner1 struct { + W int32 + X string + } + + type Inner2 struct { + Y float64 + } + + type Inner3 struct { + Z bool + } + + type Inner4 struct { + WW int + } + + type Inner5 struct { + X Inner4 + } + + type Outer struct { + A int16 + I []Inner1 `datastore:",flatten"` + J Inner2 `datastore:",flatten"` + K Inner5 `datastore:",flatten"` + Inner3 `datastore:",flatten"` + } + +an Outer's properties would be equivalent to those of: + + type OuterEquivalent struct { + A int16 + IDotW []int32 `datastore:"I.W"` + IDotX []string `datastore:"I.X"` + JDotY float64 `datastore:"J.Y"` + KDotXDotWW int `datastore:"K.X.WW"` + Z bool + } + +Note that the "flatten" option cannot be used for Entity value fields or +PropertyLoadSaver implementers. The server will reject any dotted field names +for an Entity value. + + +The PropertyLoadSaver Interface + +An entity's contents can also be represented by any type that implements the +PropertyLoadSaver interface. This type may be a struct pointer, but it does +not have to be. The datastore package will call Load when getting the entity's +contents, and Save when putting the entity's contents. +Possible uses include deriving non-stored fields, verifying fields, or indexing +a field only if its value is positive. + +Example code: + + type CustomPropsExample struct { + I, J int + // Sum is not stored, but should always be equal to I + J. + Sum int `datastore:"-"` + } + + func (x *CustomPropsExample) Load(ps []datastore.Property) error { + // Load I and J as usual. + if err := datastore.LoadStruct(x, ps); err != nil { + return err + } + // Derive the Sum field. + x.Sum = x.I + x.J + return nil + } + + func (x *CustomPropsExample) Save() ([]datastore.Property, error) { + // Validate the Sum field. + if x.Sum != x.I + x.J { + return nil, errors.New("CustomPropsExample has inconsistent sum") + } + // Save I and J as usual. The code below is equivalent to calling + // "return datastore.SaveStruct(x)", but is done manually for + // demonstration purposes. + return []datastore.Property{ + { + Name: "I", + Value: int64(x.I), + }, + { + Name: "J", + Value: int64(x.J), + }, + }, nil + } + +The *PropertyList type implements PropertyLoadSaver, and can therefore hold an +arbitrary entity's contents. + +The KeyLoader Interface + +If a type implements the PropertyLoadSaver interface, it may +also want to implement the KeyLoader interface. +The KeyLoader interface exists to allow implementations of PropertyLoadSaver +to also load an Entity's Key into the Go type. This type may be a struct +pointer, but it does not have to be. The datastore package will call LoadKey +when getting the entity's contents, after calling Load. + +Example code: + + type WithKeyExample struct { + I int + Key *datastore.Key + } + + func (x *WithKeyExample) LoadKey(k *datastore.Key) error { + x.Key = k + return nil + } + + func (x *WithKeyExample) Load(ps []datastore.Property) error { + // Load I as usual. + return datastore.LoadStruct(x, ps) + } + + func (x *WithKeyExample) Save() ([]datastore.Property, error) { + // Save I as usual. + return datastore.SaveStruct(x) + } + +To load a Key into a struct which does not implement the PropertyLoadSaver +interface, see the "Key Field" section above. + + +Queries + +Queries retrieve entities based on their properties or key's ancestry. Running +a query yields an iterator of results: either keys or (key, entity) pairs. +Queries are re-usable and it is safe to call Query.Run from concurrent +goroutines. Iterators are not safe for concurrent use. + +Queries are immutable, and are either created by calling NewQuery, or derived +from an existing query by calling a method like Filter or Order that returns a +new query value. A query is typically constructed by calling NewQuery followed +by a chain of zero or more such methods. These methods are: + - Ancestor and Filter constrain the entities returned by running a query. + - Order affects the order in which they are returned. + - Project constrains the fields returned. + - Distinct de-duplicates projected entities. + - KeysOnly makes the iterator return only keys, not (key, entity) pairs. + - Start, End, Offset and Limit define which sub-sequence of matching entities + to return. Start and End take cursors, Offset and Limit take integers. Start + and Offset affect the first result, End and Limit affect the last result. + If both Start and Offset are set, then the offset is relative to Start. + If both End and Limit are set, then the earliest constraint wins. Limit is + relative to Start+Offset, not relative to End. As a special case, a + negative limit means unlimited. + +Example code: + + type Widget struct { + Description string + Price int + } + + func printWidgets(ctx context.Context, client *datastore.Client) { + q := datastore.NewQuery("Widget"). + Filter("Price <", 1000). + Order("-Price") + + t := client.Run(ctx, q) + for { + var x Widget + key, err := t.Next(&x) + if err == iterator.Done { + break + } + if err != nil { + // Handle error. + } + fmt.Printf("Key=%v\nWidget=%#v\n\n", key, x) + } + } + + +Transactions + +Client.RunInTransaction runs a function in a transaction. + +Example code: + + type Counter struct { + Count int + } + + func incCount(ctx context.Context, client *datastore.Client) { + 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 { + // Handle error. + } + // The value of count is only valid once the transaction is successful + // (RunInTransaction has returned nil). + fmt.Printf("Count=%d\n", count) + } + +Pass the ReadOnly option to RunInTransaction if your transaction is used only for Get, +GetMulti or queries. Read-only transactions are more efficient. + +Google Cloud Datastore Emulator + +This package supports the Cloud Datastore emulator, which is useful for testing and +development. Environment variables are used to indicate that datastore traffic should be +directed to the emulator instead of the production Datastore service. + +To install and set up the emulator and its environment variables, see the documentation +at https://cloud.google.com/datastore/docs/tools/datastore-emulator. +*/ +package datastore // import "cloud.google.com/go/datastore" diff --git a/vendor/cloud.google.com/go/datastore/errors.go b/vendor/cloud.google.com/go/datastore/errors.go new file mode 100644 index 0000000..ee1f002 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/errors.go @@ -0,0 +1,47 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This file provides error functions for common API failure modes. + +package datastore + +import ( + "fmt" +) + +// MultiError is returned by batch operations when there are errors with +// particular elements. Errors will be in a one-to-one correspondence with +// the input elements; successful elements will have a nil entry. +type MultiError []error + +func (m MultiError) Error() string { + s, n := "", 0 + for _, e := range m { + if e != nil { + if n == 0 { + s = e.Error() + } + n++ + } + } + switch n { + case 0: + return "(0 errors)" + case 1: + return s + case 2: + return s + " (and 1 other error)" + } + return fmt.Sprintf("%s (and %d other errors)", s, n-1) +} diff --git a/vendor/cloud.google.com/go/datastore/key.go b/vendor/cloud.google.com/go/datastore/key.go new file mode 100644 index 0000000..778fa26 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/key.go @@ -0,0 +1,280 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/gob" + "errors" + "strconv" + "strings" + + "github.com/golang/protobuf/proto" + pb "google.golang.org/genproto/googleapis/datastore/v1" +) + +// Key represents the datastore key for a stored entity. +type Key struct { + // Kind cannot be empty. + Kind string + // Either ID or Name must be zero for the Key to be valid. + // If both are zero, the Key is incomplete. + ID int64 + Name string + // Parent must either be a complete Key or nil. + Parent *Key + + // Namespace provides the ability to partition your data for multiple + // tenants. In most cases, it is not necessary to specify a namespace. + // See docs on datastore multitenancy for details: + // https://cloud.google.com/datastore/docs/concepts/multitenancy + Namespace string +} + +// Incomplete reports whether the key does not refer to a stored entity. +func (k *Key) Incomplete() bool { + return k.Name == "" && k.ID == 0 +} + +// valid returns whether the key is valid. +func (k *Key) valid() bool { + if k == nil { + return false + } + for ; k != nil; k = k.Parent { + if k.Kind == "" { + return false + } + if k.Name != "" && k.ID != 0 { + return false + } + if k.Parent != nil { + if k.Parent.Incomplete() { + return false + } + if k.Parent.Namespace != k.Namespace { + return false + } + } + } + return true +} + +// Equal reports whether two keys are equal. Two keys are equal if they are +// both nil, or if their kinds, IDs, names, namespaces and parents are equal. +func (k *Key) Equal(o *Key) bool { + for { + if k == nil || o == nil { + return k == o // if either is nil, both must be nil + } + if k.Namespace != o.Namespace || k.Name != o.Name || k.ID != o.ID || k.Kind != o.Kind { + return false + } + if k.Parent == nil && o.Parent == nil { + return true + } + k = k.Parent + o = o.Parent + } +} + +// marshal marshals the key's string representation to the buffer. +func (k *Key) marshal(b *bytes.Buffer) { + if k.Parent != nil { + k.Parent.marshal(b) + } + b.WriteByte('/') + b.WriteString(k.Kind) + b.WriteByte(',') + if k.Name != "" { + b.WriteString(k.Name) + } else { + b.WriteString(strconv.FormatInt(k.ID, 10)) + } +} + +// String returns a string representation of the key. +func (k *Key) String() string { + if k == nil { + return "" + } + b := bytes.NewBuffer(make([]byte, 0, 512)) + k.marshal(b) + return b.String() +} + +// Note: Fields not renamed compared to appengine gobKey struct +// This ensures gobs created by appengine can be read here, and vice/versa +type gobKey struct { + Kind string + StringID string + IntID int64 + Parent *gobKey + AppID string + Namespace string +} + +func keyToGobKey(k *Key) *gobKey { + if k == nil { + return nil + } + return &gobKey{ + Kind: k.Kind, + StringID: k.Name, + IntID: k.ID, + Parent: keyToGobKey(k.Parent), + Namespace: k.Namespace, + } +} + +func gobKeyToKey(gk *gobKey) *Key { + if gk == nil { + return nil + } + return &Key{ + Kind: gk.Kind, + Name: gk.StringID, + ID: gk.IntID, + Parent: gobKeyToKey(gk.Parent), + Namespace: gk.Namespace, + } +} + +// GobEncode marshals the key into a sequence of bytes +// using an encoding/gob.Encoder. +func (k *Key) GobEncode() ([]byte, error) { + buf := new(bytes.Buffer) + if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// GobDecode unmarshals a sequence of bytes using an encoding/gob.Decoder. +func (k *Key) GobDecode(buf []byte) error { + gk := new(gobKey) + if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil { + return err + } + *k = *gobKeyToKey(gk) + return nil +} + +// MarshalJSON marshals the key into JSON. +func (k *Key) MarshalJSON() ([]byte, error) { + return []byte(`"` + k.Encode() + `"`), nil +} + +// UnmarshalJSON unmarshals a key JSON object into a Key. +func (k *Key) UnmarshalJSON(buf []byte) error { + if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' { + return errors.New("datastore: bad JSON key") + } + k2, err := DecodeKey(string(buf[1 : len(buf)-1])) + if err != nil { + return err + } + *k = *k2 + return nil +} + +// Encode returns an opaque representation of the key +// suitable for use in HTML and URLs. +// This is compatible with the Python and Java runtimes. +func (k *Key) Encode() string { + pKey := keyToProto(k) + + b, err := proto.Marshal(pKey) + if err != nil { + panic(err) + } + + // Trailing padding is stripped. + return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=") +} + +// DecodeKey decodes a key from the opaque representation returned by Encode. +func DecodeKey(encoded string) (*Key, error) { + // Re-add padding. + if m := len(encoded) % 4; m != 0 { + encoded += strings.Repeat("=", 4-m) + } + + b, err := base64.URLEncoding.DecodeString(encoded) + if err != nil { + return nil, err + } + + pKey := new(pb.Key) + if err := proto.Unmarshal(b, pKey); err != nil { + return nil, err + } + return protoToKey(pKey) +} + +// AllocateIDs accepts a slice of incomplete keys and returns a +// slice of complete keys that are guaranteed to be valid in the datastore. +func (c *Client) AllocateIDs(ctx context.Context, keys []*Key) ([]*Key, error) { + if keys == nil { + return nil, nil + } + + req := &pb.AllocateIdsRequest{ + ProjectId: c.dataset, + Keys: multiKeyToProto(keys), + } + resp, err := c.client.AllocateIds(ctx, req) + if err != nil { + return nil, err + } + + return multiProtoToKey(resp.Keys) +} + +// IncompleteKey creates a new incomplete key. +// The supplied kind cannot be empty. +// The namespace of the new key is empty. +func IncompleteKey(kind string, parent *Key) *Key { + return &Key{ + Kind: kind, + Parent: parent, + } +} + +// NameKey creates a new key with a name. +// The supplied kind cannot be empty. +// The supplied parent must either be a complete key or nil. +// The namespace of the new key is empty. +func NameKey(kind, name string, parent *Key) *Key { + return &Key{ + Kind: kind, + Name: name, + Parent: parent, + } +} + +// IDKey creates a new key with an ID. +// The supplied kind cannot be empty. +// The supplied parent must either be a complete key or nil. +// The namespace of the new key is empty. +func IDKey(kind string, id int64, parent *Key) *Key { + return &Key{ + Kind: kind, + ID: id, + Parent: parent, + } +} diff --git a/vendor/cloud.google.com/go/datastore/load.go b/vendor/cloud.google.com/go/datastore/load.go new file mode 100644 index 0000000..b03cb2d --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/load.go @@ -0,0 +1,521 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "fmt" + "reflect" + "strings" + "time" + + "cloud.google.com/go/internal/fields" + pb "google.golang.org/genproto/googleapis/datastore/v1" +) + +var ( + typeOfByteSlice = reflect.TypeOf([]byte(nil)) + typeOfTime = reflect.TypeOf(time.Time{}) + typeOfGeoPoint = reflect.TypeOf(GeoPoint{}) + typeOfKeyPtr = reflect.TypeOf(&Key{}) +) + +// typeMismatchReason returns a string explaining why the property p could not +// be stored in an entity field of type v.Type(). +func typeMismatchReason(p Property, v reflect.Value) string { + entityType := "empty" + switch p.Value.(type) { + case int64: + entityType = "int" + case bool: + entityType = "bool" + case string: + entityType = "string" + case float64: + entityType = "float" + case *Key: + entityType = "*datastore.Key" + case *Entity: + entityType = "*datastore.Entity" + case GeoPoint: + entityType = "GeoPoint" + case time.Time: + entityType = "time.Time" + case []byte: + entityType = "[]byte" + } + + return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type()) +} + +func overflowReason(x interface{}, v reflect.Value) string { + return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type()) +} + +type propertyLoader struct { + // m holds the number of times a substruct field like "Foo.Bar.Baz" has + // been seen so far. The map is constructed lazily. + m map[string]int +} + +func (l *propertyLoader) load(codec fields.List, structValue reflect.Value, p Property, prev map[string]struct{}) string { + sl, ok := p.Value.([]interface{}) + if !ok { + return l.loadOneElement(codec, structValue, p, prev) + } + for _, val := range sl { + p.Value = val + if errStr := l.loadOneElement(codec, structValue, p, prev); errStr != "" { + return errStr + } + } + return "" +} + +// loadOneElement loads the value of Property p into structValue based on the provided +// codec. codec is used to find the field in structValue into which p should be loaded. +// prev is the set of property names already seen for structValue. +func (l *propertyLoader) loadOneElement(codec fields.List, structValue reflect.Value, p Property, prev map[string]struct{}) string { + var sliceOk bool + var sliceIndex int + var v reflect.Value + + name := p.Name + fieldNames := strings.Split(name, ".") + + for len(fieldNames) > 0 { + var field *fields.Field + + // Start by trying to find a field with name. If none found, + // cut off the last field (delimited by ".") and find its parent + // in the codec. + // eg. for name "A.B.C.D", split off "A.B.C" and try to + // find a field in the codec with this name. + // Loop again with "A.B", etc. + for i := len(fieldNames); i > 0; i-- { + parent := strings.Join(fieldNames[:i], ".") + field = codec.Match(parent) + if field != nil { + fieldNames = fieldNames[i:] + break + } + } + + // If we never found a matching field in the codec, return + // error message. + if field == nil { + return "no such struct field" + } + + v = initField(structValue, field.Index) + if !v.IsValid() { + return "no such struct field" + } + if !v.CanSet() { + return "cannot set struct field" + } + + // If field implements PLS, we delegate loading to the PLS's Load early, + // and stop iterating through fields. + ok, err := plsFieldLoad(v, p, fieldNames) + if err != nil { + return err.Error() + } + if ok { + return "" + } + + if field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct { + codec, err = structCache.Fields(field.Type.Elem()) + if err != nil { + return err.Error() + } + + // Init value if its nil + if v.IsNil() { + v.Set(reflect.New(field.Type.Elem())) + } + structValue = v.Elem() + } + + if field.Type.Kind() == reflect.Struct { + codec, err = structCache.Fields(field.Type) + if err != nil { + return err.Error() + } + structValue = v + } + + // If the element is a slice, we need to accommodate it. + if v.Kind() == reflect.Slice && v.Type() != typeOfByteSlice { + if l.m == nil { + l.m = make(map[string]int) + } + sliceIndex = l.m[p.Name] + l.m[p.Name] = sliceIndex + 1 + for v.Len() <= sliceIndex { + v.Set(reflect.Append(v, reflect.New(v.Type().Elem()).Elem())) + } + structValue = v.Index(sliceIndex) + + // If structValue implements PLS, we delegate loading to the PLS's + // Load early, and stop iterating through fields. + ok, err := plsFieldLoad(structValue, p, fieldNames) + if err != nil { + return err.Error() + } + if ok { + return "" + } + + if structValue.Type().Kind() == reflect.Struct { + codec, err = structCache.Fields(structValue.Type()) + if err != nil { + return err.Error() + } + } + sliceOk = true + } + } + + var slice reflect.Value + if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 { + slice = v + v = reflect.New(v.Type().Elem()).Elem() + } else if _, ok := prev[p.Name]; ok && !sliceOk { + // Zero the field back out that was set previously, turns out + // it's a slice and we don't know what to do with it + v.Set(reflect.Zero(v.Type())) + return "multiple-valued property requires a slice field type" + } + + prev[p.Name] = struct{}{} + + if errReason := setVal(v, p); errReason != "" { + // Set the slice back to its zero value. + if slice.IsValid() { + slice.Set(reflect.Zero(slice.Type())) + } + return errReason + } + + if slice.IsValid() { + slice.Index(sliceIndex).Set(v) + } + + return "" +} + +// plsFieldLoad first tries to converts v's value to a PLS, then v's addressed +// value to a PLS. If neither succeeds, plsFieldLoad returns false for first return +// value. Otherwise, the first return value will be true. +// If v is successfully converted to a PLS, plsFieldLoad will then try to Load +// the property p into v (by way of the PLS's Load method). +// +// If the field v has been flattened, the Property's name must be altered +// before calling Load to reflect the field v. +// For example, if our original field name was "A.B.C.D", +// and at this point in iteration we had initialized the field +// corresponding to "A" and have moved into the struct, so that now +// v corresponds to the field named "B", then we want to let the +// PLS handle this field (B)'s subfields ("C", "D"), +// so we send the property to the PLS's Load, renamed to "C.D". +// +// If subfields are present, the field v has been flattened. +func plsFieldLoad(v reflect.Value, p Property, subfields []string) (ok bool, err error) { + vpls, err := plsForLoad(v) + if err != nil { + return false, err + } + + if vpls == nil { + return false, nil + } + + // If Entity, load properties as well as key. + if e, ok := p.Value.(*Entity); ok { + err = loadEntity(vpls, e) + return true, err + } + + // If flattened, we must alter the property's name to reflect + // the field v. + if len(subfields) > 0 { + p.Name = strings.Join(subfields, ".") + } + + return true, vpls.Load([]Property{p}) +} + +// setVal sets 'v' to the value of the Property 'p'. +func setVal(v reflect.Value, p Property) (s string) { + pValue := p.Value + switch v.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + x, ok := pValue.(int64) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + if v.OverflowInt(x) { + return overflowReason(x, v) + } + v.SetInt(x) + case reflect.Bool: + x, ok := pValue.(bool) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + v.SetBool(x) + case reflect.String: + x, ok := pValue.(string) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + v.SetString(x) + case reflect.Float32, reflect.Float64: + x, ok := pValue.(float64) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + if v.OverflowFloat(x) { + return overflowReason(x, v) + } + v.SetFloat(x) + case reflect.Ptr: + // v must be a pointer to either a Key, an Entity, or one of the supported basic types. + if v.Type() != typeOfKeyPtr && v.Type().Elem().Kind() != reflect.Struct && !isValidPointerType(v.Type().Elem()) { + return typeMismatchReason(p, v) + } + + if pValue == nil { + // If v is populated already, set it to nil. + if !v.IsNil() { + v.Set(reflect.New(v.Type()).Elem()) + } + return "" + } + + if x, ok := p.Value.(*Key); ok { + if _, ok := v.Interface().(*Key); !ok { + return typeMismatchReason(p, v) + } + v.Set(reflect.ValueOf(x)) + return "" + } + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + switch x := pValue.(type) { + case *Entity: + err := loadEntity(v.Interface(), x) + if err != nil { + return err.Error() + } + case int64: + if v.Elem().OverflowInt(x) { + return overflowReason(x, v.Elem()) + } + v.Elem().SetInt(x) + case float64: + if v.Elem().OverflowFloat(x) { + return overflowReason(x, v.Elem()) + } + v.Elem().SetFloat(x) + case bool: + v.Elem().SetBool(x) + case string: + v.Elem().SetString(x) + case GeoPoint, time.Time: + v.Elem().Set(reflect.ValueOf(x)) + default: + return typeMismatchReason(p, v) + } + case reflect.Struct: + switch v.Type() { + case typeOfTime: + x, ok := pValue.(time.Time) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + v.Set(reflect.ValueOf(x)) + case typeOfGeoPoint: + x, ok := pValue.(GeoPoint) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + v.Set(reflect.ValueOf(x)) + default: + ent, ok := pValue.(*Entity) + if !ok { + return typeMismatchReason(p, v) + } + err := loadEntity(v.Addr().Interface(), ent) + if err != nil { + return err.Error() + } + } + case reflect.Slice: + x, ok := pValue.([]byte) + if !ok && pValue != nil { + return typeMismatchReason(p, v) + } + if v.Type().Elem().Kind() != reflect.Uint8 { + return typeMismatchReason(p, v) + } + v.SetBytes(x) + default: + return typeMismatchReason(p, v) + } + return "" +} + +// initField is similar to reflect's Value.FieldByIndex, in that it +// returns the nested struct field corresponding to index, but it +// initialises any nil pointers encountered when traversing the structure. +func initField(val reflect.Value, index []int) reflect.Value { + for _, i := range index[:len(index)-1] { + val = val.Field(i) + if val.Kind() == reflect.Ptr { + if val.IsNil() { + val.Set(reflect.New(val.Type().Elem())) + } + val = val.Elem() + } + } + return val.Field(index[len(index)-1]) +} + +// loadEntityProto loads an EntityProto into PropertyLoadSaver or struct pointer. +func loadEntityProto(dst interface{}, src *pb.Entity) error { + ent, err := protoToEntity(src) + if err != nil { + return err + } + return loadEntity(dst, ent) +} + +func loadEntity(dst interface{}, ent *Entity) error { + if pls, ok := dst.(PropertyLoadSaver); ok { + err := pls.Load(ent.Properties) + if err != nil { + return err + } + if e, ok := dst.(KeyLoader); ok { + err = e.LoadKey(ent.Key) + } + return err + } + return loadEntityToStruct(dst, ent) +} + +func loadEntityToStruct(dst interface{}, ent *Entity) error { + pls, err := newStructPLS(dst) + if err != nil { + return err + } + + // Try and load key. + keyField := pls.codec.Match(keyFieldName) + if keyField != nil && ent.Key != nil { + pls.v.FieldByIndex(keyField.Index).Set(reflect.ValueOf(ent.Key)) + } + + // Load properties. + return pls.Load(ent.Properties) +} + +func (s structPLS) Load(props []Property) error { + var fieldName, errReason string + var l propertyLoader + + prev := make(map[string]struct{}) + for _, p := range props { + if errStr := l.load(s.codec, s.v, p, prev); errStr != "" { + // We don't return early, as we try to load as many properties as possible. + // It is valid to load an entity into a struct that cannot fully represent it. + // That case returns an error, but the caller is free to ignore it. + fieldName, errReason = p.Name, errStr + } + } + if errReason != "" { + return &ErrFieldMismatch{ + StructType: s.v.Type(), + FieldName: fieldName, + Reason: errReason, + } + } + return nil +} + +func protoToEntity(src *pb.Entity) (*Entity, error) { + props := make([]Property, 0, len(src.Properties)) + for name, val := range src.Properties { + v, err := propToValue(val) + if err != nil { + return nil, err + } + props = append(props, Property{ + Name: name, + Value: v, + NoIndex: val.ExcludeFromIndexes, + }) + } + var key *Key + if src.Key != nil { + // Ignore any error, since nested entity values + // are allowed to have an invalid key. + key, _ = protoToKey(src.Key) + } + + return &Entity{key, props}, nil +} + +// propToValue returns a Go value that represents the PropertyValue. For +// example, a TimestampValue becomes a time.Time. +func propToValue(v *pb.Value) (interface{}, error) { + switch v := v.ValueType.(type) { + case *pb.Value_NullValue: + return nil, nil + case *pb.Value_BooleanValue: + return v.BooleanValue, nil + case *pb.Value_IntegerValue: + return v.IntegerValue, nil + case *pb.Value_DoubleValue: + return v.DoubleValue, nil + case *pb.Value_TimestampValue: + return time.Unix(v.TimestampValue.Seconds, int64(v.TimestampValue.Nanos)), nil + case *pb.Value_KeyValue: + return protoToKey(v.KeyValue) + case *pb.Value_StringValue: + return v.StringValue, nil + case *pb.Value_BlobValue: + return []byte(v.BlobValue), nil + case *pb.Value_GeoPointValue: + return GeoPoint{Lat: v.GeoPointValue.Latitude, Lng: v.GeoPointValue.Longitude}, nil + case *pb.Value_EntityValue: + return protoToEntity(v.EntityValue) + case *pb.Value_ArrayValue: + arr := make([]interface{}, 0, len(v.ArrayValue.Values)) + for _, v := range v.ArrayValue.Values { + vv, err := propToValue(v) + if err != nil { + return nil, err + } + arr = append(arr, vv) + } + return arr, nil + default: + return nil, nil + } +} diff --git a/vendor/cloud.google.com/go/datastore/mutation.go b/vendor/cloud.google.com/go/datastore/mutation.go new file mode 100644 index 0000000..f80f964 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/mutation.go @@ -0,0 +1,129 @@ +// Copyright 2018 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "fmt" + + pb "google.golang.org/genproto/googleapis/datastore/v1" +) + +// A Mutation represents a change to a Datastore entity. +type Mutation struct { + key *Key // needed for transaction PendingKeys and to dedup deletions + mut *pb.Mutation + err error +} + +func (m *Mutation) isDelete() bool { + _, ok := m.mut.Operation.(*pb.Mutation_Delete) + return ok +} + +// NewInsert creates a mutation that will save the entity src into the datastore with +// key k, returning an error if k already exists. +// See Client.Put for valid values of src. +func NewInsert(k *Key, src interface{}) *Mutation { + if !k.valid() { + return &Mutation{err: ErrInvalidKey} + } + p, err := saveEntity(k, src) + if err != nil { + return &Mutation{err: err} + } + return &Mutation{ + key: k, + mut: &pb.Mutation{Operation: &pb.Mutation_Insert{Insert: p}}, + } +} + +// NewUpsert creates a mutation that saves the entity src into the datastore with key +// k, whether or not k exists. See Client.Put for valid values of src. +func NewUpsert(k *Key, src interface{}) *Mutation { + if !k.valid() { + return &Mutation{err: ErrInvalidKey} + } + p, err := saveEntity(k, src) + if err != nil { + return &Mutation{err: err} + } + return &Mutation{ + key: k, + mut: &pb.Mutation{Operation: &pb.Mutation_Upsert{Upsert: p}}, + } +} + +// NewUpdate creates a mutation that replaces the entity in the datastore with key k, +// returning an error if k does not exist. See Client.Put for valid values of src. +func NewUpdate(k *Key, src interface{}) *Mutation { + if !k.valid() { + return &Mutation{err: ErrInvalidKey} + } + if k.Incomplete() { + return &Mutation{err: fmt.Errorf("datastore: can't update the incomplete key: %v", k)} + } + p, err := saveEntity(k, src) + if err != nil { + return &Mutation{err: err} + } + return &Mutation{ + key: k, + mut: &pb.Mutation{Operation: &pb.Mutation_Update{Update: p}}, + } +} + +// NewDelete creates a mutation that deletes the entity with key k. +func NewDelete(k *Key) *Mutation { + if !k.valid() { + return &Mutation{err: ErrInvalidKey} + } + if k.Incomplete() { + return &Mutation{err: fmt.Errorf("datastore: can't delete the incomplete key: %v", k)} + } + return &Mutation{ + key: k, + mut: &pb.Mutation{Operation: &pb.Mutation_Delete{Delete: keyToProto(k)}}, + } +} + +func mutationProtos(muts []*Mutation) ([]*pb.Mutation, error) { + // If any of the mutations have errors, collect and return them. + var merr MultiError + for i, m := range muts { + if m.err != nil { + if merr == nil { + merr = make(MultiError, len(muts)) + } + merr[i] = m.err + } + } + if merr != nil { + return nil, merr + } + var protos []*pb.Mutation + // Collect protos. Remove duplicate deletions (see deleteMutations). + seen := map[string]bool{} + for _, m := range muts { + if m.isDelete() { + ks := m.key.String() + if seen[ks] { + continue + } + seen[ks] = true + } + protos = append(protos, m.mut) + } + return protos, nil +} diff --git a/vendor/cloud.google.com/go/datastore/prop.go b/vendor/cloud.google.com/go/datastore/prop.go new file mode 100644 index 0000000..645b99a --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/prop.go @@ -0,0 +1,339 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "fmt" + "reflect" + "strings" + "unicode" + + "cloud.google.com/go/internal/fields" +) + +// Entities with more than this many indexed properties will not be saved. +const maxIndexedProperties = 20000 + +// Property is a name/value pair plus some metadata. A datastore entity's +// contents are loaded and saved as a sequence of Properties. Each property +// name must be unique within an entity. +type Property struct { + // Name is the property name. + Name string + // Value is the property value. The valid types are: + // - int64 + // - bool + // - string + // - float64 + // - *Key + // - time.Time (retrieved as local time) + // - GeoPoint + // - []byte (up to 1 megabyte in length) + // - *Entity (representing a nested struct) + // Value can also be: + // - []interface{} where each element is one of the above types + // This set is smaller than the set of valid struct field types that the + // datastore can load and save. A Value's type must be explicitly on + // the list above; it is not sufficient for the underlying type to be + // on that list. For example, a Value of "type myInt64 int64" is + // invalid. Smaller-width integers and floats are also invalid. Again, + // this is more restrictive than the set of valid struct field types. + // + // A Value will have an opaque type when loading entities from an index, + // such as via a projection query. Load entities into a struct instead + // of a PropertyLoadSaver when using a projection query. + // + // A Value may also be the nil interface value; this is equivalent to + // Python's None but not directly representable by a Go struct. Loading + // a nil-valued property into a struct will set that field to the zero + // value. + Value interface{} + // NoIndex is whether the datastore cannot index this property. + // If NoIndex is set to false, []byte and string values are limited to + // 1500 bytes. + NoIndex bool +} + +// An Entity is the value type for a nested struct. +// This type is only used for a Property's Value. +type Entity struct { + Key *Key + Properties []Property +} + +// PropertyLoadSaver can be converted from and to a slice of Properties. +type PropertyLoadSaver interface { + Load([]Property) error + Save() ([]Property, error) +} + +// KeyLoader can store a Key. +type KeyLoader interface { + // PropertyLoadSaver is embedded because a KeyLoader + // must also always implement PropertyLoadSaver. + PropertyLoadSaver + LoadKey(k *Key) error +} + +// PropertyList converts a []Property to implement PropertyLoadSaver. +type PropertyList []Property + +var ( + typeOfPropertyLoadSaver = reflect.TypeOf((*PropertyLoadSaver)(nil)).Elem() + typeOfPropertyList = reflect.TypeOf(PropertyList(nil)) +) + +// Load loads all of the provided properties into l. +// It does not first reset *l to an empty slice. +func (l *PropertyList) Load(p []Property) error { + *l = append(*l, p...) + return nil +} + +// Save saves all of l's properties as a slice of Properties. +func (l *PropertyList) Save() ([]Property, error) { + return *l, nil +} + +// validPropertyName returns whether name consists of one or more valid Go +// identifiers joined by ".". +func validPropertyName(name string) bool { + if name == "" { + return false + } + for _, s := range strings.Split(name, ".") { + if s == "" { + return false + } + first := true + for _, c := range s { + if first { + first = false + if c != '_' && !unicode.IsLetter(c) { + return false + } + } else { + if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) { + return false + } + } + } + } + return true +} + +// parseTag interprets datastore struct field tags +func parseTag(t reflect.StructTag) (name string, keep bool, other interface{}, err error) { + s := t.Get("datastore") + parts := strings.Split(s, ",") + if parts[0] == "-" && len(parts) == 1 { + return "", false, nil, nil + } + if parts[0] != "" && !validPropertyName(parts[0]) { + err = fmt.Errorf("datastore: struct tag has invalid property name: %q", parts[0]) + return "", false, nil, err + } + + var opts saveOpts + if len(parts) > 1 { + for _, p := range parts[1:] { + switch p { + case "flatten": + opts.flatten = true + case "omitempty": + opts.omitEmpty = true + case "noindex": + opts.noIndex = true + default: + err = fmt.Errorf("datastore: struct tag has invalid option: %q", p) + return "", false, nil, err + } + } + other = opts + } + return parts[0], true, other, nil +} + +func validateType(t reflect.Type) error { + if t.Kind() != reflect.Struct { + return fmt.Errorf("datastore: validate called with non-struct type %s", t) + } + + return validateChildType(t, "", false, false, map[reflect.Type]bool{}) +} + +// validateChildType is a recursion helper func for validateType +func validateChildType(t reflect.Type, fieldName string, flatten, prevSlice bool, prevTypes map[reflect.Type]bool) error { + if prevTypes[t] { + return nil + } + prevTypes[t] = true + + switch t.Kind() { + case reflect.Slice: + if flatten && prevSlice { + return fmt.Errorf("datastore: flattening nested structs leads to a slice of slices: field %q", fieldName) + } + return validateChildType(t.Elem(), fieldName, flatten, true, prevTypes) + case reflect.Struct: + if t == typeOfTime || t == typeOfGeoPoint { + return nil + } + + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + + // If a named field is unexported, ignore it. An anonymous + // unexported field is processed, because it may contain + // exported fields, which are visible. + exported := (f.PkgPath == "") + if !exported && !f.Anonymous { + continue + } + + _, keep, other, err := parseTag(f.Tag) + // Handle error from parseTag now instead of later (in cache.Fields call). + if err != nil { + return err + } + if !keep { + continue + } + if other != nil { + opts := other.(saveOpts) + flatten = flatten || opts.flatten + } + if err := validateChildType(f.Type, f.Name, flatten, prevSlice, prevTypes); err != nil { + return err + } + } + case reflect.Ptr: + if t == typeOfKeyPtr { + return nil + } + return validateChildType(t.Elem(), fieldName, flatten, prevSlice, prevTypes) + } + return nil +} + +// isLeafType determines whether or not a type is a 'leaf type' +// and should not be recursed into, but considered one field. +func isLeafType(t reflect.Type) bool { + return t == typeOfTime || t == typeOfGeoPoint +} + +// structCache collects the structs whose fields have already been calculated. +var structCache = fields.NewCache(parseTag, validateType, isLeafType) + +// structPLS adapts a struct to be a PropertyLoadSaver. +type structPLS struct { + v reflect.Value + codec fields.List +} + +// newStructPLS returns a structPLS, which implements the +// PropertyLoadSaver interface, for the struct pointer p. +func newStructPLS(p interface{}) (*structPLS, error) { + v := reflect.ValueOf(p) + if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct { + return nil, ErrInvalidEntityType + } + v = v.Elem() + f, err := structCache.Fields(v.Type()) + if err != nil { + return nil, err + } + return &structPLS{v, f}, nil +} + +// LoadStruct loads the properties from p to dst. +// dst must be a struct pointer. +// +// The values of dst's unmatched struct fields are not modified, +// and matching slice-typed fields are not reset before appending to +// them. In particular, it is recommended to pass a pointer to a zero +// valued struct on each LoadStruct call. +func LoadStruct(dst interface{}, p []Property) error { + x, err := newStructPLS(dst) + if err != nil { + return err + } + return x.Load(p) +} + +// SaveStruct returns the properties from src as a slice of Properties. +// src must be a struct pointer. +func SaveStruct(src interface{}) ([]Property, error) { + x, err := newStructPLS(src) + if err != nil { + return nil, err + } + return x.Save() +} + +// plsForLoad tries to convert v to a PropertyLoadSaver. +// If successful, plsForLoad returns a settable v as a PropertyLoadSaver. +// +// plsForLoad is intended to be used with nested struct fields which +// may implement PropertyLoadSaver. +// +// v must be settable. +func plsForLoad(v reflect.Value) (PropertyLoadSaver, error) { + var nilPtr bool + if v.Kind() == reflect.Ptr && v.IsNil() { + nilPtr = true + v.Set(reflect.New(v.Type().Elem())) + } + + vpls, err := pls(v) + if nilPtr && (vpls == nil || err != nil) { + // unset v + v.Set(reflect.Zero(v.Type())) + } + + return vpls, err +} + +// plsForSave tries to convert v to a PropertyLoadSaver. +// If successful, plsForSave returns v as a PropertyLoadSaver. +// +// plsForSave is intended to be used with nested struct fields which +// may implement PropertyLoadSaver. +// +// v must be settable. +func plsForSave(v reflect.Value) (PropertyLoadSaver, error) { + switch v.Kind() { + case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Interface, reflect.Chan, reflect.Func: + // If v is nil, return early. v contains no data to save. + if v.IsNil() { + return nil, nil + } + } + + return pls(v) +} + +func pls(v reflect.Value) (PropertyLoadSaver, error) { + if v.Kind() != reflect.Ptr { + if _, ok := v.Interface().(PropertyLoadSaver); ok { + return nil, fmt.Errorf("datastore: PropertyLoadSaver methods must be implemented on a pointer to %T", v.Interface()) + } + + v = v.Addr() + } + + vpls, _ := v.Interface().(PropertyLoadSaver) + return vpls, nil +} diff --git a/vendor/cloud.google.com/go/datastore/query.go b/vendor/cloud.google.com/go/datastore/query.go new file mode 100644 index 0000000..5851662 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/query.go @@ -0,0 +1,786 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "context" + "encoding/base64" + "errors" + "fmt" + "math" + "reflect" + "strconv" + "strings" + + "cloud.google.com/go/internal/trace" + wrapperspb "github.com/golang/protobuf/ptypes/wrappers" + "google.golang.org/api/iterator" + pb "google.golang.org/genproto/googleapis/datastore/v1" +) + +type operator int + +const ( + lessThan operator = iota + 1 + lessEq + equal + greaterEq + greaterThan + + keyFieldName = "__key__" +) + +var operatorToProto = map[operator]pb.PropertyFilter_Operator{ + lessThan: pb.PropertyFilter_LESS_THAN, + lessEq: pb.PropertyFilter_LESS_THAN_OR_EQUAL, + equal: pb.PropertyFilter_EQUAL, + greaterEq: pb.PropertyFilter_GREATER_THAN_OR_EQUAL, + greaterThan: pb.PropertyFilter_GREATER_THAN, +} + +// filter is a conditional filter on query results. +type filter struct { + FieldName string + Op operator + Value interface{} +} + +type sortDirection bool + +const ( + ascending sortDirection = false + descending sortDirection = true +) + +var sortDirectionToProto = map[sortDirection]pb.PropertyOrder_Direction{ + ascending: pb.PropertyOrder_ASCENDING, + descending: pb.PropertyOrder_DESCENDING, +} + +// order is a sort order on query results. +type order struct { + FieldName string + Direction sortDirection +} + +// NewQuery creates a new Query for a specific entity kind. +// +// An empty kind means to return all entities, including entities created and +// managed by other App Engine features, and is called a kindless query. +// Kindless queries cannot include filters or sort orders on property values. +func NewQuery(kind string) *Query { + return &Query{ + kind: kind, + limit: -1, + } +} + +// Query represents a datastore query. +type Query struct { + kind string + ancestor *Key + filter []filter + order []order + projection []string + + distinct bool + distinctOn []string + keysOnly bool + eventual bool + limit int32 + offset int32 + start []byte + end []byte + + namespace string + + trans *Transaction + + err error +} + +func (q *Query) clone() *Query { + x := *q + // Copy the contents of the slice-typed fields to a new backing store. + if len(q.filter) > 0 { + x.filter = make([]filter, len(q.filter)) + copy(x.filter, q.filter) + } + if len(q.order) > 0 { + x.order = make([]order, len(q.order)) + copy(x.order, q.order) + } + return &x +} + +// Ancestor returns a derivative query with an ancestor filter. +// The ancestor should not be nil. +func (q *Query) Ancestor(ancestor *Key) *Query { + q = q.clone() + if ancestor == nil { + q.err = errors.New("datastore: nil query ancestor") + return q + } + q.ancestor = ancestor + return q +} + +// EventualConsistency returns a derivative query that returns eventually +// consistent results. +// It only has an effect on ancestor queries. +func (q *Query) EventualConsistency() *Query { + q = q.clone() + q.eventual = true + return q +} + +// Namespace returns a derivative query that is associated with the given +// namespace. +// +// A namespace may be used to partition data for multi-tenant applications. +// For details, see https://cloud.google.com/datastore/docs/concepts/multitenancy. +func (q *Query) Namespace(ns string) *Query { + q = q.clone() + q.namespace = ns + return q +} + +// Transaction returns a derivative query that is associated with the given +// transaction. +// +// All reads performed as part of the transaction will come from a single +// consistent snapshot. Furthermore, if the transaction is set to a +// serializable isolation level, another transaction cannot concurrently modify +// the data that is read or modified by this transaction. +func (q *Query) Transaction(t *Transaction) *Query { + q = q.clone() + q.trans = t + return q +} + +// Filter returns a derivative query with a field-based filter. +// The filterStr argument must be a field name followed by optional space, +// followed by an operator, one of ">", "<", ">=", "<=", or "=". +// Fields are compared against the provided value using the operator. +// Multiple filters are AND'ed together. +// Field names which contain spaces, quote marks, or operator characters +// should be passed as quoted Go string literals as returned by strconv.Quote +// or the fmt package's %q verb. +func (q *Query) Filter(filterStr string, value interface{}) *Query { + q = q.clone() + filterStr = strings.TrimSpace(filterStr) + if filterStr == "" { + q.err = fmt.Errorf("datastore: invalid filter %q", filterStr) + return q + } + f := filter{ + FieldName: strings.TrimRight(filterStr, " ><=!"), + Value: value, + } + switch op := strings.TrimSpace(filterStr[len(f.FieldName):]); op { + case "<=": + f.Op = lessEq + case ">=": + f.Op = greaterEq + case "<": + f.Op = lessThan + case ">": + f.Op = greaterThan + case "=": + f.Op = equal + default: + q.err = fmt.Errorf("datastore: invalid operator %q in filter %q", op, filterStr) + return q + } + var err error + f.FieldName, err = unquote(f.FieldName) + if err != nil { + q.err = fmt.Errorf("datastore: invalid syntax for quoted field name %q", f.FieldName) + return q + } + q.filter = append(q.filter, f) + return q +} + +// Order returns a derivative query with a field-based sort order. Orders are +// applied in the order they are added. The default order is ascending; to sort +// in descending order prefix the fieldName with a minus sign (-). +// Field names which contain spaces, quote marks, or the minus sign +// should be passed as quoted Go string literals as returned by strconv.Quote +// or the fmt package's %q verb. +func (q *Query) Order(fieldName string) *Query { + q = q.clone() + fieldName, dir := strings.TrimSpace(fieldName), ascending + if strings.HasPrefix(fieldName, "-") { + fieldName, dir = strings.TrimSpace(fieldName[1:]), descending + } else if strings.HasPrefix(fieldName, "+") { + q.err = fmt.Errorf("datastore: invalid order: %q", fieldName) + return q + } + fieldName, err := unquote(fieldName) + if err != nil { + q.err = fmt.Errorf("datastore: invalid syntax for quoted field name %q", fieldName) + return q + } + if fieldName == "" { + q.err = errors.New("datastore: empty order") + return q + } + q.order = append(q.order, order{ + Direction: dir, + FieldName: fieldName, + }) + return q +} + +// unquote optionally interprets s as a double-quoted or backquoted Go +// string literal if it begins with the relevant character. +func unquote(s string) (string, error) { + if s == "" || (s[0] != '`' && s[0] != '"') { + return s, nil + } + return strconv.Unquote(s) +} + +// Project returns a derivative query that yields only the given fields. It +// cannot be used with KeysOnly. +func (q *Query) Project(fieldNames ...string) *Query { + q = q.clone() + q.projection = append([]string(nil), fieldNames...) + return q +} + +// Distinct returns a derivative query that yields de-duplicated entities with +// respect to the set of projected fields. It is only used for projection +// queries. Distinct cannot be used with DistinctOn. +func (q *Query) Distinct() *Query { + q = q.clone() + q.distinct = true + return q +} + +// DistinctOn returns a derivative query that yields de-duplicated entities with +// respect to the set of the specified fields. It is only used for projection +// queries. The field list should be a subset of the projected field list. +// DistinctOn cannot be used with Distinct. +func (q *Query) DistinctOn(fieldNames ...string) *Query { + q = q.clone() + q.distinctOn = fieldNames + return q +} + +// KeysOnly returns a derivative query that yields only keys, not keys and +// entities. It cannot be used with projection queries. +func (q *Query) KeysOnly() *Query { + q = q.clone() + q.keysOnly = true + return q +} + +// Limit returns a derivative query that has a limit on the number of results +// returned. A negative value means unlimited. +func (q *Query) Limit(limit int) *Query { + q = q.clone() + if limit < math.MinInt32 || limit > math.MaxInt32 { + q.err = errors.New("datastore: query limit overflow") + return q + } + q.limit = int32(limit) + return q +} + +// Offset returns a derivative query that has an offset of how many keys to +// skip over before returning results. A negative value is invalid. +func (q *Query) Offset(offset int) *Query { + q = q.clone() + if offset < 0 { + q.err = errors.New("datastore: negative query offset") + return q + } + if offset > math.MaxInt32 { + q.err = errors.New("datastore: query offset overflow") + return q + } + q.offset = int32(offset) + return q +} + +// Start returns a derivative query with the given start point. +func (q *Query) Start(c Cursor) *Query { + q = q.clone() + q.start = c.cc + return q +} + +// End returns a derivative query with the given end point. +func (q *Query) End(c Cursor) *Query { + q = q.clone() + q.end = c.cc + return q +} + +// toProto converts the query to a protocol buffer. +func (q *Query) toProto(req *pb.RunQueryRequest) error { + if len(q.projection) != 0 && q.keysOnly { + return errors.New("datastore: query cannot both project and be keys-only") + } + if len(q.distinctOn) != 0 && q.distinct { + return errors.New("datastore: query cannot be both distinct and distinct-on") + } + dst := &pb.Query{} + if q.kind != "" { + dst.Kind = []*pb.KindExpression{{Name: q.kind}} + } + if q.projection != nil { + for _, propertyName := range q.projection { + dst.Projection = append(dst.Projection, &pb.Projection{Property: &pb.PropertyReference{Name: propertyName}}) + } + + for _, propertyName := range q.distinctOn { + dst.DistinctOn = append(dst.DistinctOn, &pb.PropertyReference{Name: propertyName}) + } + + if q.distinct { + for _, propertyName := range q.projection { + dst.DistinctOn = append(dst.DistinctOn, &pb.PropertyReference{Name: propertyName}) + } + } + } + if q.keysOnly { + dst.Projection = []*pb.Projection{{Property: &pb.PropertyReference{Name: keyFieldName}}} + } + + var filters []*pb.Filter + for _, qf := range q.filter { + if qf.FieldName == "" { + return errors.New("datastore: empty query filter field name") + } + v, err := interfaceToProto(reflect.ValueOf(qf.Value).Interface(), false) + if err != nil { + return fmt.Errorf("datastore: bad query filter value type: %v", err) + } + op, ok := operatorToProto[qf.Op] + if !ok { + return errors.New("datastore: unknown query filter operator") + } + xf := &pb.PropertyFilter{ + Op: op, + Property: &pb.PropertyReference{Name: qf.FieldName}, + Value: v, + } + filters = append(filters, &pb.Filter{ + FilterType: &pb.Filter_PropertyFilter{PropertyFilter: xf}, + }) + } + + if q.ancestor != nil { + filters = append(filters, &pb.Filter{ + FilterType: &pb.Filter_PropertyFilter{PropertyFilter: &pb.PropertyFilter{ + Property: &pb.PropertyReference{Name: keyFieldName}, + Op: pb.PropertyFilter_HAS_ANCESTOR, + Value: &pb.Value{ValueType: &pb.Value_KeyValue{KeyValue: keyToProto(q.ancestor)}}, + }}}) + } + + if len(filters) == 1 { + dst.Filter = filters[0] + } else if len(filters) > 1 { + dst.Filter = &pb.Filter{FilterType: &pb.Filter_CompositeFilter{CompositeFilter: &pb.CompositeFilter{ + Op: pb.CompositeFilter_AND, + Filters: filters, + }}} + } + + for _, qo := range q.order { + if qo.FieldName == "" { + return errors.New("datastore: empty query order field name") + } + xo := &pb.PropertyOrder{ + Property: &pb.PropertyReference{Name: qo.FieldName}, + Direction: sortDirectionToProto[qo.Direction], + } + dst.Order = append(dst.Order, xo) + } + if q.limit >= 0 { + dst.Limit = &wrapperspb.Int32Value{Value: q.limit} + } + dst.Offset = q.offset + dst.StartCursor = q.start + dst.EndCursor = q.end + + if t := q.trans; t != nil { + if t.id == nil { + return errExpiredTransaction + } + if q.eventual { + return errors.New("datastore: cannot use EventualConsistency query in a transaction") + } + req.ReadOptions = &pb.ReadOptions{ + ConsistencyType: &pb.ReadOptions_Transaction{Transaction: t.id}, + } + } + + if q.eventual { + req.ReadOptions = &pb.ReadOptions{ConsistencyType: &pb.ReadOptions_ReadConsistency_{ReadConsistency: pb.ReadOptions_EVENTUAL}} + } + + req.QueryType = &pb.RunQueryRequest_Query{Query: dst} + return nil +} + +// Count returns the number of results for the given query. +// +// The running time and number of API calls made by Count scale linearly with +// the sum of the query's offset and limit. Unless the result count is +// expected to be small, it is best to specify a limit; otherwise Count will +// continue until it finishes counting or the provided context expires. +func (c *Client) Count(ctx context.Context, q *Query) (n int, err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.Query.Count") + defer func() { trace.EndSpan(ctx, err) }() + + // Check that the query is well-formed. + if q.err != nil { + return 0, q.err + } + + // Create a copy of the query, with keysOnly true (if we're not a projection, + // since the two are incompatible). + newQ := q.clone() + newQ.keysOnly = len(newQ.projection) == 0 + + // Create an iterator and use it to walk through the batches of results + // directly. + it := c.Run(ctx, newQ) + for { + err := it.nextBatch() + if err == iterator.Done { + return n, nil + } + if err != nil { + return 0, err + } + n += len(it.results) + } +} + +// GetAll runs the provided query in the given context and returns all keys +// that match that query, as well as appending the values to dst. +// +// dst must have type *[]S or *[]*S or *[]P, for some struct type S or some non- +// interface, non-pointer type P such that P or *P implements PropertyLoadSaver. +// +// As a special case, *PropertyList is an invalid type for dst, even though a +// PropertyList is a slice of structs. It is treated as invalid to avoid being +// mistakenly passed when *[]PropertyList was intended. +// +// The keys returned by GetAll will be in a 1-1 correspondence with the entities +// added to dst. +// +// If q is a ``keys-only'' query, GetAll ignores dst and only returns the keys. +// +// The running time and number of API calls made by GetAll scale linearly with +// with the sum of the query's offset and limit. Unless the result count is +// expected to be small, it is best to specify a limit; otherwise GetAll will +// continue until it finishes collecting results or the provided context +// expires. +func (c *Client) GetAll(ctx context.Context, q *Query, dst interface{}) (keys []*Key, err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.Query.GetAll") + defer func() { trace.EndSpan(ctx, err) }() + + var ( + dv reflect.Value + mat multiArgType + elemType reflect.Type + errFieldMismatch error + ) + if !q.keysOnly { + dv = reflect.ValueOf(dst) + if dv.Kind() != reflect.Ptr || dv.IsNil() { + return nil, ErrInvalidEntityType + } + dv = dv.Elem() + mat, elemType = checkMultiArg(dv) + if mat == multiArgTypeInvalid || mat == multiArgTypeInterface { + return nil, ErrInvalidEntityType + } + } + + for t := c.Run(ctx, q); ; { + k, e, err := t.next() + if err == iterator.Done { + break + } + if err != nil { + return keys, err + } + if !q.keysOnly { + ev := reflect.New(elemType) + if elemType.Kind() == reflect.Map { + // This is a special case. The zero values of a map type are + // not immediately useful; they have to be make'd. + // + // Funcs and channels are similar, in that a zero value is not useful, + // but even a freshly make'd channel isn't useful: there's no fixed + // channel buffer size that is always going to be large enough, and + // there's no goroutine to drain the other end. Theoretically, these + // types could be supported, for example by sniffing for a constructor + // method or requiring prior registration, but for now it's not a + // frequent enough concern to be worth it. Programmers can work around + // it by explicitly using Iterator.Next instead of the Query.GetAll + // convenience method. + x := reflect.MakeMap(elemType) + ev.Elem().Set(x) + } + if err = loadEntityProto(ev.Interface(), e); err != nil { + if _, ok := err.(*ErrFieldMismatch); ok { + // We continue loading entities even in the face of field mismatch errors. + // If we encounter any other error, that other error is returned. Otherwise, + // an ErrFieldMismatch is returned. + errFieldMismatch = err + } else { + return keys, err + } + } + if mat != multiArgTypeStructPtr { + ev = ev.Elem() + } + dv.Set(reflect.Append(dv, ev)) + } + keys = append(keys, k) + } + return keys, errFieldMismatch +} + +// Run runs the given query in the given context. +func (c *Client) Run(ctx context.Context, q *Query) *Iterator { + if q.err != nil { + return &Iterator{err: q.err} + } + t := &Iterator{ + ctx: ctx, + client: c, + limit: q.limit, + offset: q.offset, + keysOnly: q.keysOnly, + pageCursor: q.start, + entityCursor: q.start, + req: &pb.RunQueryRequest{ + ProjectId: c.dataset, + }, + } + + if q.namespace != "" { + t.req.PartitionId = &pb.PartitionId{ + NamespaceId: q.namespace, + } + } + + if err := q.toProto(t.req); err != nil { + t.err = err + } + return t +} + +// Iterator is the result of running a query. +type Iterator struct { + ctx context.Context + client *Client + err error + + // results is the list of EntityResults still to be iterated over from the + // most recent API call. It will be nil if no requests have yet been issued. + results []*pb.EntityResult + // req is the request to send. It may be modified and used multiple times. + req *pb.RunQueryRequest + + // limit is the limit on the number of results this iterator should return. + // The zero value is used to prevent further fetches from the server. + // A negative value means unlimited. + limit int32 + // offset is the number of results that still need to be skipped. + offset int32 + // keysOnly records whether the query was keys-only (skip entity loading). + keysOnly bool + + // pageCursor is the compiled cursor for the next batch/page of result. + // TODO(djd): Can we delete this in favour of paging with the last + // entityCursor from each batch? + pageCursor []byte + // entityCursor is the compiled cursor of the next result. + entityCursor []byte +} + +// Next returns the key of the next result. When there are no more results, +// iterator.Done is returned as the error. +// +// If the query is not keys only and dst is non-nil, it also loads the entity +// stored for that key into the struct pointer or PropertyLoadSaver dst, with +// the same semantics and possible errors as for the Get function. +func (t *Iterator) Next(dst interface{}) (k *Key, err error) { + k, e, err := t.next() + if err != nil { + return nil, err + } + if dst != nil && !t.keysOnly { + err = loadEntityProto(dst, e) + } + return k, err +} + +func (t *Iterator) next() (*Key, *pb.Entity, error) { + // Fetch additional batches while there are no more results. + for t.err == nil && len(t.results) == 0 { + t.err = t.nextBatch() + } + if t.err != nil { + return nil, nil, t.err + } + + // Extract the next result, update cursors, and parse the entity's key. + e := t.results[0] + t.results = t.results[1:] + t.entityCursor = e.Cursor + if len(t.results) == 0 { + t.entityCursor = t.pageCursor // At the end of the batch. + } + if e.Entity.Key == nil { + return nil, nil, errors.New("datastore: internal error: server did not return a key") + } + k, err := protoToKey(e.Entity.Key) + if err != nil || k.Incomplete() { + return nil, nil, errors.New("datastore: internal error: server returned an invalid key") + } + + return k, e.Entity, nil +} + +// nextBatch makes a single call to the server for a batch of results. +func (t *Iterator) nextBatch() error { + if t.err != nil { + return t.err + } + + if t.limit == 0 { + return iterator.Done // Short-circuits the zero-item response. + } + + // Adjust the query with the latest start cursor, limit and offset. + q := t.req.GetQuery() + q.StartCursor = t.pageCursor + q.Offset = t.offset + if t.limit >= 0 { + q.Limit = &wrapperspb.Int32Value{Value: t.limit} + } else { + q.Limit = nil + } + + // Run the query. + resp, err := t.client.client.RunQuery(t.ctx, t.req) + if err != nil { + return err + } + + // Adjust any offset from skipped results. + skip := resp.Batch.SkippedResults + if skip < 0 { + return errors.New("datastore: internal error: negative number of skipped_results") + } + t.offset -= skip + if t.offset < 0 { + return errors.New("datastore: internal error: query skipped too many results") + } + if t.offset > 0 && len(resp.Batch.EntityResults) > 0 { + return errors.New("datastore: internal error: query returned results before requested offset") + } + + // Adjust the limit. + if t.limit >= 0 { + t.limit -= int32(len(resp.Batch.EntityResults)) + if t.limit < 0 { + return errors.New("datastore: internal error: query returned more results than the limit") + } + } + + // If there are no more results available, set limit to zero to prevent + // further fetches. Otherwise, check that there is a next page cursor available. + if resp.Batch.MoreResults != pb.QueryResultBatch_NOT_FINISHED { + t.limit = 0 + } else if resp.Batch.EndCursor == nil { + return errors.New("datastore: internal error: server did not return a cursor") + } + + // Update cursors. + // If any results were skipped, use the SkippedCursor as the next entity cursor. + if skip > 0 { + t.entityCursor = resp.Batch.SkippedCursor + } else { + t.entityCursor = q.StartCursor + } + t.pageCursor = resp.Batch.EndCursor + + t.results = resp.Batch.EntityResults + return nil +} + +// Cursor returns a cursor for the iterator's current location. +func (t *Iterator) Cursor() (c Cursor, err error) { + t.ctx = trace.StartSpan(t.ctx, "cloud.google.com/go/datastore.Query.Cursor") + defer func() { trace.EndSpan(t.ctx, err) }() + + // If there is still an offset, we need to the skip those results first. + for t.err == nil && t.offset > 0 { + t.err = t.nextBatch() + } + + if t.err != nil && t.err != iterator.Done { + return Cursor{}, t.err + } + + return Cursor{t.entityCursor}, nil +} + +// Cursor is an iterator's position. It can be converted to and from an opaque +// string. A cursor can be used from different HTTP requests, but only with a +// query with the same kind, ancestor, filter and order constraints. +// +// The zero Cursor can be used to indicate that there is no start and/or end +// constraint for a query. +type Cursor struct { + cc []byte +} + +// String returns a base-64 string representation of a cursor. +func (c Cursor) String() string { + if c.cc == nil { + return "" + } + + return strings.TrimRight(base64.URLEncoding.EncodeToString(c.cc), "=") +} + +// DecodeCursor decodes a cursor from its base-64 string representation. +func DecodeCursor(s string) (Cursor, error) { + if s == "" { + return Cursor{}, nil + } + if n := len(s) % 4; n != 0 { + s += strings.Repeat("=", 4-n) + } + b, err := base64.URLEncoding.DecodeString(s) + if err != nil { + return Cursor{}, err + } + return Cursor{b}, nil +} diff --git a/vendor/cloud.google.com/go/datastore/save.go b/vendor/cloud.google.com/go/datastore/save.go new file mode 100644 index 0000000..2a44469 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/save.go @@ -0,0 +1,470 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "errors" + "fmt" + "reflect" + "time" + "unicode/utf8" + + timepb "github.com/golang/protobuf/ptypes/timestamp" + pb "google.golang.org/genproto/googleapis/datastore/v1" + llpb "google.golang.org/genproto/googleapis/type/latlng" +) + +type saveOpts struct { + noIndex bool + flatten bool + omitEmpty bool +} + +// saveEntity saves an EntityProto into a PropertyLoadSaver or struct pointer. +func saveEntity(key *Key, src interface{}) (*pb.Entity, error) { + var err error + var props []Property + if e, ok := src.(PropertyLoadSaver); ok { + props, err = e.Save() + } else { + props, err = SaveStruct(src) + } + if err != nil { + return nil, err + } + return propertiesToProto(key, props) +} + +// TODO(djd): Convert this and below to return ([]Property, error). +func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect.Value) error { + p := Property{ + Name: name, + NoIndex: opts.noIndex, + } + + if opts.omitEmpty && isEmptyValue(v) { + return nil + } + + // First check if field type implements PLS. If so, use PLS to + // save. + ok, err := plsFieldSave(props, p, name, opts, v) + if err != nil { + return err + } + if ok { + return nil + } + + switch x := v.Interface().(type) { + case *Key, time.Time, GeoPoint: + p.Value = x + default: + switch v.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + p.Value = v.Int() + case reflect.Bool: + p.Value = v.Bool() + case reflect.String: + p.Value = v.String() + case reflect.Float32, reflect.Float64: + p.Value = v.Float() + case reflect.Slice: + if v.Type().Elem().Kind() == reflect.Uint8 { + p.Value = v.Bytes() + } else { + return saveSliceProperty(props, name, opts, v) + } + case reflect.Ptr: + if isValidPointerType(v.Type().Elem()) { + if v.IsNil() { + // Nil pointer becomes a nil property value (unless omitempty, handled above). + p.Value = nil + *props = append(*props, p) + return nil + } + // When we recurse on the derefenced pointer, omitempty no longer applies: + // we already know the pointer is not empty, it doesn't matter if its referent + // is empty or not. + opts.omitEmpty = false + return saveStructProperty(props, name, opts, v.Elem()) + } + if v.Type().Elem().Kind() != reflect.Struct { + return fmt.Errorf("datastore: unsupported struct field type: %s", v.Type()) + } + // Pointer to struct is a special case. + if v.IsNil() { + return nil + } + v = v.Elem() + fallthrough + case reflect.Struct: + if !v.CanAddr() { + return fmt.Errorf("datastore: unsupported struct field: value is unaddressable") + } + vi := v.Addr().Interface() + + sub, err := newStructPLS(vi) + if err != nil { + return fmt.Errorf("datastore: unsupported struct field: %v", err) + } + + if opts.flatten { + return sub.save(props, opts, name+".") + } + + var subProps []Property + err = sub.save(&subProps, opts, "") + if err != nil { + return err + } + subKey, err := sub.key(v) + if err != nil { + return err + } + + p.Value = &Entity{ + Key: subKey, + Properties: subProps, + } + } + } + if p.Value == nil { + return fmt.Errorf("datastore: unsupported struct field type: %v", v.Type()) + } + *props = append(*props, p) + return nil +} + +// plsFieldSave first tries to converts v's value to a PLS, then v's addressed +// value to a PLS. If neither succeeds, plsFieldSave returns false for first return +// value. +// If v is successfully converted to a PLS, plsFieldSave will then add the +// Value to property p by way of the PLS's Save method, and append it to props. +// +// If the flatten option is present in opts, name must be prepended to each property's +// name before it is appended to props. Eg. if name were "A" and a subproperty's name +// were "B", the resultant name of the property to be appended to props would be "A.B". +func plsFieldSave(props *[]Property, p Property, name string, opts saveOpts, v reflect.Value) (ok bool, err error) { + vpls, err := plsForSave(v) + if err != nil { + return false, err + } + + if vpls == nil { + return false, nil + } + + subProps, err := vpls.Save() + if err != nil { + return true, err + } + + if opts.flatten { + for _, subp := range subProps { + subp.Name = name + "." + subp.Name + *props = append(*props, subp) + } + return true, nil + } + + p.Value = &Entity{Properties: subProps} + *props = append(*props, p) + + return true, nil +} + +// key extracts the *Key struct field from struct v based on the structCodec of s. +func (s structPLS) key(v reflect.Value) (*Key, error) { + if v.Kind() != reflect.Struct { + return nil, errors.New("datastore: cannot save key of non-struct type") + } + + keyField := s.codec.Match(keyFieldName) + + if keyField == nil { + return nil, nil + } + + f := v.FieldByIndex(keyField.Index) + k, ok := f.Interface().(*Key) + if !ok { + return nil, fmt.Errorf("datastore: %s field on struct %T is not a *datastore.Key", keyFieldName, v.Interface()) + } + + return k, nil +} + +func saveSliceProperty(props *[]Property, name string, opts saveOpts, v reflect.Value) error { + // Easy case: if the slice is empty, we're done. + if v.Len() == 0 { + return nil + } + // Work out the properties generated by the first element in the slice. This will + // usually be a single property, but will be more if this is a slice of structs. + var headProps []Property + if err := saveStructProperty(&headProps, name, opts, v.Index(0)); err != nil { + return err + } + + // Convert the first element's properties into slice properties, and + // keep track of the values in a map. + values := make(map[string][]interface{}, len(headProps)) + for _, p := range headProps { + values[p.Name] = append(make([]interface{}, 0, v.Len()), p.Value) + } + + // Find the elements for the subsequent elements. + for i := 1; i < v.Len(); i++ { + elemProps := make([]Property, 0, len(headProps)) + if err := saveStructProperty(&elemProps, name, opts, v.Index(i)); err != nil { + return err + } + for _, p := range elemProps { + v, ok := values[p.Name] + if !ok { + return fmt.Errorf("datastore: unexpected property %q in elem %d of slice", p.Name, i) + } + values[p.Name] = append(v, p.Value) + } + } + + // Convert to the final properties. + for _, p := range headProps { + p.Value = values[p.Name] + *props = append(*props, p) + } + return nil +} + +func (s structPLS) Save() ([]Property, error) { + var props []Property + if err := s.save(&props, saveOpts{}, ""); err != nil { + return nil, err + } + return props, nil +} + +func (s structPLS) save(props *[]Property, opts saveOpts, prefix string) error { + for _, f := range s.codec { + name := prefix + f.Name + v := getField(s.v, f.Index) + if !v.IsValid() || !v.CanSet() { + continue + } + + var tagOpts saveOpts + if f.ParsedTag != nil { + tagOpts = f.ParsedTag.(saveOpts) + } + + var opts1 saveOpts + opts1.noIndex = opts.noIndex || tagOpts.noIndex + opts1.flatten = opts.flatten || tagOpts.flatten + opts1.omitEmpty = tagOpts.omitEmpty // don't propagate + if err := saveStructProperty(props, name, opts1, v); err != nil { + return err + } + } + return nil +} + +// getField returns the field from v at the given index path. +// If it encounters a nil-valued field in the path, getField +// stops and returns a zero-valued reflect.Value, preventing the +// panic that would have been caused by reflect's FieldByIndex. +func getField(v reflect.Value, index []int) reflect.Value { + var zero reflect.Value + if v.Type().Kind() != reflect.Struct { + return zero + } + + for _, i := range index { + if v.Kind() == reflect.Ptr && v.Type().Elem().Kind() == reflect.Struct { + if v.IsNil() { + return zero + } + v = v.Elem() + } + v = v.Field(i) + } + return v +} + +func propertiesToProto(key *Key, props []Property) (*pb.Entity, error) { + e := &pb.Entity{ + Key: keyToProto(key), + Properties: map[string]*pb.Value{}, + } + indexedProps := 0 + for _, p := range props { + // Do not send a Key value a field to datastore. + if p.Name == keyFieldName { + continue + } + + val, err := interfaceToProto(p.Value, p.NoIndex) + if err != nil { + return nil, fmt.Errorf("datastore: %v for a Property with Name %q", err, p.Name) + } + if !p.NoIndex { + rVal := reflect.ValueOf(p.Value) + if rVal.Kind() == reflect.Slice && rVal.Type().Elem().Kind() != reflect.Uint8 { + indexedProps += rVal.Len() + } else { + indexedProps++ + } + } + if indexedProps > maxIndexedProperties { + return nil, errors.New("datastore: too many indexed properties") + } + + if _, ok := e.Properties[p.Name]; ok { + return nil, fmt.Errorf("datastore: duplicate Property with Name %q", p.Name) + } + e.Properties[p.Name] = val + } + return e, nil +} + +func interfaceToProto(iv interface{}, noIndex bool) (*pb.Value, error) { + val := &pb.Value{ExcludeFromIndexes: noIndex} + switch v := iv.(type) { + case int: + val.ValueType = &pb.Value_IntegerValue{IntegerValue: int64(v)} + case int32: + val.ValueType = &pb.Value_IntegerValue{IntegerValue: int64(v)} + case int64: + val.ValueType = &pb.Value_IntegerValue{IntegerValue: v} + case bool: + val.ValueType = &pb.Value_BooleanValue{BooleanValue: v} + case string: + if len(v) > 1500 && !noIndex { + return nil, errors.New("string property too long to index") + } + if !utf8.ValidString(v) { + return nil, fmt.Errorf("string is not valid utf8: %q", v) + } + val.ValueType = &pb.Value_StringValue{StringValue: v} + case float32: + val.ValueType = &pb.Value_DoubleValue{DoubleValue: float64(v)} + case float64: + val.ValueType = &pb.Value_DoubleValue{DoubleValue: v} + case *Key: + if v == nil { + val.ValueType = &pb.Value_NullValue{} + } else { + val.ValueType = &pb.Value_KeyValue{KeyValue: keyToProto(v)} + } + case GeoPoint: + if !v.Valid() { + return nil, errors.New("invalid GeoPoint value") + } + val.ValueType = &pb.Value_GeoPointValue{GeoPointValue: &llpb.LatLng{ + Latitude: v.Lat, + Longitude: v.Lng, + }} + case time.Time: + if v.Before(minTime) || v.After(maxTime) { + return nil, errors.New("time value out of range") + } + val.ValueType = &pb.Value_TimestampValue{TimestampValue: &timepb.Timestamp{ + Seconds: v.Unix(), + Nanos: int32(v.Nanosecond()), + }} + case []byte: + if len(v) > 1500 && !noIndex { + return nil, errors.New("[]byte property too long to index") + } + val.ValueType = &pb.Value_BlobValue{BlobValue: v} + case *Entity: + e, err := propertiesToProto(v.Key, v.Properties) + if err != nil { + return nil, err + } + val.ValueType = &pb.Value_EntityValue{EntityValue: e} + case []interface{}: + arr := make([]*pb.Value, 0, len(v)) + for i, v := range v { + elem, err := interfaceToProto(v, noIndex) + if err != nil { + return nil, fmt.Errorf("%v at index %d", err, i) + } + arr = append(arr, elem) + } + val.ValueType = &pb.Value_ArrayValue{ArrayValue: &pb.ArrayValue{Values: arr}} + // ArrayValues have ExcludeFromIndexes set on the individual items, rather + // than the top-level value. + val.ExcludeFromIndexes = false + default: + rv := reflect.ValueOf(iv) + if !rv.IsValid() { + val.ValueType = &pb.Value_NullValue{} + } else if rv.Kind() == reflect.Ptr { // non-nil pointer: dereference + if rv.IsNil() { + val.ValueType = &pb.Value_NullValue{} + return val, nil + } + return interfaceToProto(rv.Elem().Interface(), noIndex) + } else { + return nil, fmt.Errorf("invalid Value type %T", iv) + } + } + // TODO(jbd): Support EntityValue. + return val, nil +} + +// isEmptyValue is taken from the encoding/json package in the +// standard library. +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + case reflect.Struct: + if t, ok := v.Interface().(time.Time); ok { + return t.IsZero() + } + } + return false +} + +// isValidPointerType reports whether a struct field can be a pointer to type t +// for the purposes of saving and loading. +func isValidPointerType(t reflect.Type) bool { + if t == typeOfTime || t == typeOfGeoPoint { + return true + } + switch t.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return true + case reflect.Bool: + return true + case reflect.String: + return true + case reflect.Float32, reflect.Float64: + return true + } + return false +} diff --git a/vendor/cloud.google.com/go/datastore/time.go b/vendor/cloud.google.com/go/datastore/time.go new file mode 100644 index 0000000..da6c780 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/time.go @@ -0,0 +1,36 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "math" + "time" +) + +var ( + minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3) + maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3) +) + +func toUnixMicro(t time.Time) int64 { + // We cannot use t.UnixNano() / 1e3 because we want to handle times more than + // 2^63 nanoseconds (which is about 292 years) away from 1970, and those cannot + // be represented in the numerator of a single int64 divide. + return t.Unix()*1e6 + int64(t.Nanosecond()/1e3) +} + +func fromUnixMicro(t int64) time.Time { + return time.Unix(t/1e6, (t%1e6)*1e3) +} diff --git a/vendor/cloud.google.com/go/datastore/transaction.go b/vendor/cloud.google.com/go/datastore/transaction.go new file mode 100644 index 0000000..d734f01 --- /dev/null +++ b/vendor/cloud.google.com/go/datastore/transaction.go @@ -0,0 +1,402 @@ +// Copyright 2014 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package datastore + +import ( + "context" + "errors" + + "cloud.google.com/go/internal/trace" + pb "google.golang.org/genproto/googleapis/datastore/v1" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" +) + +// ErrConcurrentTransaction is returned when a transaction is rolled back due +// to a conflict with a concurrent transaction. +var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction") + +var errExpiredTransaction = errors.New("datastore: transaction expired") + +type transactionSettings struct { + attempts int + readOnly bool + prevID []byte // ID of the transaction to retry +} + +// newTransactionSettings creates a transactionSettings with a given TransactionOption slice. +// Unconfigured options will be set to default values. +func newTransactionSettings(opts []TransactionOption) *transactionSettings { + s := &transactionSettings{attempts: 3} + for _, o := range opts { + o.apply(s) + } + return s +} + +// TransactionOption configures the way a transaction is executed. +type TransactionOption interface { + apply(*transactionSettings) +} + +// MaxAttempts returns a TransactionOption that overrides the default 3 attempt times. +func MaxAttempts(attempts int) TransactionOption { + return maxAttempts(attempts) +} + +type maxAttempts int + +func (w maxAttempts) apply(s *transactionSettings) { + if w > 0 { + s.attempts = int(w) + } +} + +// ReadOnly is a TransactionOption that marks the transaction as read-only. +var ReadOnly TransactionOption + +func init() { + ReadOnly = readOnly{} +} + +type readOnly struct{} + +func (readOnly) apply(s *transactionSettings) { + s.readOnly = true +} + +// Transaction represents a set of datastore operations to be committed atomically. +// +// Operations are enqueued by calling the Put and Delete methods on Transaction +// (or their Multi-equivalents). These operations are only committed when the +// Commit method is invoked. To ensure consistency, reads must be performed by +// using Transaction's Get method or by using the Transaction method when +// building a query. +// +// A Transaction must be committed or rolled back exactly once. +type Transaction struct { + id []byte + client *Client + ctx context.Context + mutations []*pb.Mutation // The mutations to apply. + pending map[int]*PendingKey // Map from mutation index to incomplete keys pending transaction completion. +} + +// NewTransaction starts a new transaction. +func (c *Client) NewTransaction(ctx context.Context, opts ...TransactionOption) (t *Transaction, err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.NewTransaction") + defer func() { trace.EndSpan(ctx, err) }() + + for _, o := range opts { + if _, ok := o.(maxAttempts); ok { + return nil, errors.New("datastore: NewTransaction does not accept MaxAttempts option") + } + } + return c.newTransaction(ctx, newTransactionSettings(opts)) +} + +func (c *Client) newTransaction(ctx context.Context, s *transactionSettings) (*Transaction, error) { + req := &pb.BeginTransactionRequest{ProjectId: c.dataset} + if s.readOnly { + req.TransactionOptions = &pb.TransactionOptions{ + Mode: &pb.TransactionOptions_ReadOnly_{ReadOnly: &pb.TransactionOptions_ReadOnly{}}, + } + } else if s.prevID != nil { + req.TransactionOptions = &pb.TransactionOptions{ + Mode: &pb.TransactionOptions_ReadWrite_{ReadWrite: &pb.TransactionOptions_ReadWrite{ + PreviousTransaction: s.prevID, + }}, + } + } + resp, err := c.client.BeginTransaction(ctx, req) + if err != nil { + return nil, err + } + return &Transaction{ + id: resp.Transaction, + ctx: ctx, + client: c, + mutations: nil, + pending: make(map[int]*PendingKey), + }, nil +} + +// RunInTransaction runs f in a transaction. f is invoked with a Transaction +// that f should use for all the transaction's datastore operations. +// +// f must not call Commit or Rollback on the provided Transaction. +// +// If f returns nil, RunInTransaction commits the transaction, +// returning the Commit and a nil error if it succeeds. If the commit fails due +// to a conflicting transaction, RunInTransaction retries f with a new +// Transaction. It gives up and returns ErrConcurrentTransaction after three +// failed attempts (or as configured with MaxAttempts). +// +// If f returns non-nil, then the transaction will be rolled back and +// RunInTransaction will return the same error. The function f is not retried. +// +// Note that when f returns, the transaction is not committed. Calling code +// must not assume that any of f's changes have been committed until +// RunInTransaction returns nil. +// +// Since f may be called multiple times, f should usually be idempotent – that +// is, it should have the same result when called multiple times. Note that +// Transaction.Get will append when unmarshalling slice fields, so it is not +// necessarily idempotent. +func (c *Client) RunInTransaction(ctx context.Context, f func(tx *Transaction) error, opts ...TransactionOption) (cmt *Commit, err error) { + ctx = trace.StartSpan(ctx, "cloud.google.com/go/datastore.RunInTransaction") + defer func() { trace.EndSpan(ctx, err) }() + + settings := newTransactionSettings(opts) + for n := 0; n < settings.attempts; n++ { + tx, err := c.newTransaction(ctx, settings) + if err != nil { + return nil, err + } + if err := f(tx); err != nil { + _ = tx.Rollback() + return nil, err + } + if cmt, err := tx.Commit(); err != ErrConcurrentTransaction { + return cmt, err + } + // Pass this transaction's ID to the retry transaction to preserve + // transaction priority. + if !settings.readOnly { + settings.prevID = tx.id + } + } + return nil, ErrConcurrentTransaction +} + +// Commit applies the enqueued operations atomically. +func (t *Transaction) Commit() (c *Commit, err error) { + t.ctx = trace.StartSpan(t.ctx, "cloud.google.com/go/datastore.Transaction.Commit") + defer func() { trace.EndSpan(t.ctx, err) }() + + if t.id == nil { + return nil, errExpiredTransaction + } + req := &pb.CommitRequest{ + ProjectId: t.client.dataset, + TransactionSelector: &pb.CommitRequest_Transaction{Transaction: t.id}, + Mutations: t.mutations, + Mode: pb.CommitRequest_TRANSACTIONAL, + } + resp, err := t.client.client.Commit(t.ctx, req) + if grpc.Code(err) == codes.Aborted { + return nil, ErrConcurrentTransaction + } + t.id = nil // mark the transaction as expired + if err != nil { + return nil, err + } + + // Copy any newly minted keys into the returned keys. + for i, p := range t.pending { + if i >= len(resp.MutationResults) || resp.MutationResults[i].Key == nil { + return nil, errors.New("datastore: internal error: server returned the wrong mutation results") + } + key, err := protoToKey(resp.MutationResults[i].Key) + if err != nil { + return nil, errors.New("datastore: internal error: server returned an invalid key") + } + p.key = key + p.commit = c + } + + return c, nil +} + +// Rollback abandons a pending transaction. +func (t *Transaction) Rollback() (err error) { + t.ctx = trace.StartSpan(t.ctx, "cloud.google.com/go/datastore.Transaction.Rollback") + defer func() { trace.EndSpan(t.ctx, err) }() + + if t.id == nil { + return errExpiredTransaction + } + id := t.id + t.id = nil + _, err = t.client.client.Rollback(t.ctx, &pb.RollbackRequest{ + ProjectId: t.client.dataset, + Transaction: id, + }) + return err +} + +// Get is the transaction-specific version of the package function Get. +// All reads performed during the transaction will come from a single consistent +// snapshot. Furthermore, if the transaction is set to a serializable isolation +// level, another transaction cannot concurrently modify the data that is read +// or modified by this transaction. +func (t *Transaction) Get(key *Key, dst interface{}) (err error) { + t.ctx = trace.StartSpan(t.ctx, "cloud.google.com/go/datastore.Transaction.Get") + defer func() { trace.EndSpan(t.ctx, err) }() + + opts := &pb.ReadOptions{ + ConsistencyType: &pb.ReadOptions_Transaction{Transaction: t.id}, + } + err = t.client.get(t.ctx, []*Key{key}, []interface{}{dst}, opts) + if me, ok := err.(MultiError); ok { + return me[0] + } + return err +} + +// GetMulti is a batch version of Get. +func (t *Transaction) GetMulti(keys []*Key, dst interface{}) (err error) { + t.ctx = trace.StartSpan(t.ctx, "cloud.google.com/go/datastore.Transaction.GetMulti") + defer func() { trace.EndSpan(t.ctx, err) }() + + if t.id == nil { + return errExpiredTransaction + } + opts := &pb.ReadOptions{ + ConsistencyType: &pb.ReadOptions_Transaction{Transaction: t.id}, + } + return t.client.get(t.ctx, keys, dst, opts) +} + +// Put is the transaction-specific version of the package function Put. +// +// Put returns a PendingKey which can be resolved into a Key using the +// return value from a successful Commit. If key is an incomplete key, the +// returned pending key will resolve to a unique key generated by the +// datastore. +func (t *Transaction) Put(key *Key, src interface{}) (*PendingKey, error) { + h, err := t.PutMulti([]*Key{key}, []interface{}{src}) + if err != nil { + if me, ok := err.(MultiError); ok { + return nil, me[0] + } + return nil, err + } + return h[0], nil +} + +// PutMulti is a batch version of Put. One PendingKey is returned for each +// element of src in the same order. +// TODO(jba): rewrite in terms of Mutate. +func (t *Transaction) PutMulti(keys []*Key, src interface{}) (ret []*PendingKey, err error) { + if t.id == nil { + return nil, errExpiredTransaction + } + mutations, err := putMutations(keys, src) + if err != nil { + return nil, err + } + origin := len(t.mutations) + t.mutations = append(t.mutations, mutations...) + + // Prepare the returned handles, pre-populating where possible. + ret = make([]*PendingKey, len(keys)) + for i, key := range keys { + p := &PendingKey{} + if key.Incomplete() { + // This key will be in the final commit result. + t.pending[origin+i] = p + } else { + p.key = key + } + ret[i] = p + } + + return ret, nil +} + +// Delete is the transaction-specific version of the package function Delete. +// Delete enqueues the deletion of the entity for the given key, to be +// committed atomically upon calling Commit. +func (t *Transaction) Delete(key *Key) error { + err := t.DeleteMulti([]*Key{key}) + if me, ok := err.(MultiError); ok { + return me[0] + } + return err +} + +// DeleteMulti is a batch version of Delete. +// TODO(jba): rewrite in terms of Mutate. +func (t *Transaction) DeleteMulti(keys []*Key) (err error) { + if t.id == nil { + return errExpiredTransaction + } + mutations, err := deleteMutations(keys) + if err != nil { + return err + } + t.mutations = append(t.mutations, mutations...) + return nil +} + +// Mutate adds the mutations to the transaction. They will all be applied atomically +// upon calling Commit. Mutate returns a PendingKey for each Mutation in the argument +// list, in the same order. PendingKeys for Delete mutations are always nil. +// +// If any of the mutations are invalid, Mutate returns a MultiError with the errors. +// Mutate returns a MultiError in this case even if there is only one Mutation. +// +// For an example, see Client.Mutate. +func (t *Transaction) Mutate(muts ...*Mutation) ([]*PendingKey, error) { + if t.id == nil { + return nil, errExpiredTransaction + } + pmuts, err := mutationProtos(muts) + if err != nil { + return nil, err + } + origin := len(t.mutations) + t.mutations = append(t.mutations, pmuts...) + // Prepare the returned handles, pre-populating where possible. + ret := make([]*PendingKey, len(muts)) + for i, mut := range muts { + if mut.isDelete() { + continue + } + p := &PendingKey{} + if mut.key.Incomplete() { + // This key will be in the final commit result. + t.pending[origin+i] = p + } else { + p.key = mut.key + } + ret[i] = p + } + return ret, nil +} + +// Commit represents the result of a committed transaction. +type Commit struct{} + +// Key resolves a pending key handle into a final key. +func (c *Commit) Key(p *PendingKey) *Key { + if p == nil { // if called on a *PendingKey from a Delete mutation + return nil + } + // If p.commit is nil, the PendingKey did not come from an incomplete key, + // so p.key is valid. + if p.commit != nil && c != p.commit { + panic("PendingKey was not created by corresponding transaction") + } + return p.key +} + +// PendingKey represents the key for newly-inserted entity. It can be +// resolved into a Key by calling the Key method of Commit. +type PendingKey struct { + key *Key + commit *Commit +} diff --git a/vendor/cloud.google.com/go/internal/fields/fields.go b/vendor/cloud.google.com/go/internal/fields/fields.go new file mode 100644 index 0000000..05f95ea --- /dev/null +++ b/vendor/cloud.google.com/go/internal/fields/fields.go @@ -0,0 +1,480 @@ +// Copyright 2016 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package fields provides a view of the fields of a struct that follows the Go +// rules, amended to consider tags and case insensitivity. +// +// Usage +// +// First define a function that interprets tags: +// +// func parseTag(st reflect.StructTag) (name string, keep bool, other interface{}, err error) { ... } +// +// The function's return values describe whether to ignore the field +// completely or provide an alternate name, as well as other data from the +// parse that is stored to avoid re-parsing. +// +// Then define a function to validate the type: +// +// func validate(t reflect.Type) error { ... } +// +// Then, if necessary, define a function to specify leaf types - types +// which should be considered one field and not be recursed into: +// +// func isLeafType(t reflect.Type) bool { ... } +// +// eg: +// +// func isLeafType(t reflect.Type) bool { +// return t == reflect.TypeOf(time.Time{}) +// } +// +// Next, construct a Cache, passing your functions. As its name suggests, a +// Cache remembers validation and field information for a type, so subsequent +// calls with the same type are very fast. +// +// cache := fields.NewCache(parseTag, validate, isLeafType) +// +// To get the fields of a struct type as determined by the above rules, call +// the Fields method: +// +// fields, err := cache.Fields(reflect.TypeOf(MyStruct{})) +// +// The return value can be treated as a slice of Fields. +// +// Given a string, such as a key or column name obtained during unmarshalling, +// call Match on the list of fields to find a field whose name is the best +// match: +// +// field := fields.Match(name) +// +// Match looks for an exact match first, then falls back to a case-insensitive +// comparison. +package fields + +import ( + "bytes" + "errors" + "reflect" + "sort" + "strings" + "sync" +) + +// A Field records information about a struct field. +type Field struct { + Name string // effective field name + NameFromTag bool // did Name come from a tag? + Type reflect.Type // field type + Index []int // index sequence, for reflect.Value.FieldByIndex + ParsedTag interface{} // third return value of the parseTag function + + nameBytes []byte + equalFold func(s, t []byte) bool +} + +// ParseTagFunc is a function that accepts a struct tag and returns four values: an alternative name for the field +// extracted from the tag, a boolean saying whether to keep the field or ignore it, additional data that is stored +// with the field information to avoid having to parse the tag again, and an error. +type ParseTagFunc func(reflect.StructTag) (name string, keep bool, other interface{}, err error) + +// ValidateFunc is a function that accepts a reflect.Type and returns an error if the struct type is invalid in any +// way. +type ValidateFunc func(reflect.Type) error + +// LeafTypesFunc is a function that accepts a reflect.Type and returns true if the struct type a leaf, or false if not. +// TODO(deklerk) is this description accurate? +type LeafTypesFunc func(reflect.Type) bool + +// A Cache records information about the fields of struct types. +// +// A Cache is safe for use by multiple goroutines. +type Cache struct { + parseTag ParseTagFunc + validate ValidateFunc + leafTypes LeafTypesFunc + cache sync.Map // from reflect.Type to cacheValue +} + +// NewCache constructs a Cache. +// +// Its first argument should be a function that accepts +// a struct tag and returns four values: an alternative name for the field +// extracted from the tag, a boolean saying whether to keep the field or ignore +// it, additional data that is stored with the field information to avoid +// having to parse the tag again, and an error. +// +// Its second argument should be a function that accepts a reflect.Type and +// returns an error if the struct type is invalid in any way. For example, it +// may check that all of the struct field tags are valid, or that all fields +// are of an appropriate type. +func NewCache(parseTag ParseTagFunc, validate ValidateFunc, leafTypes LeafTypesFunc) *Cache { + if parseTag == nil { + parseTag = func(reflect.StructTag) (string, bool, interface{}, error) { + return "", true, nil, nil + } + } + if validate == nil { + validate = func(reflect.Type) error { + return nil + } + } + if leafTypes == nil { + leafTypes = func(reflect.Type) bool { + return false + } + } + + return &Cache{ + parseTag: parseTag, + validate: validate, + leafTypes: leafTypes, + } +} + +// A fieldScan represents an item on the fieldByNameFunc scan work list. +type fieldScan struct { + typ reflect.Type + index []int +} + +// Fields returns all the exported fields of t, which must be a struct type. It +// follows the standard Go rules for embedded fields, modified by the presence +// of tags. The result is sorted lexicographically by index. +// +// These rules apply in the absence of tags: +// Anonymous struct fields are treated as if their inner exported fields were +// fields in the outer struct (embedding). The result includes all fields that +// aren't shadowed by fields at higher level of embedding. If more than one +// field with the same name exists at the same level of embedding, it is +// excluded. An anonymous field that is not of struct type is treated as having +// its type as its name. +// +// Tags modify these rules as follows: +// A field's tag is used as its name. +// An anonymous struct field with a name given in its tag is treated as +// a field having that name, rather than an embedded struct (the struct's +// fields will not be returned). +// If more than one field with the same name exists at the same level of embedding, +// but exactly one of them is tagged, then the tagged field is reported and the others +// are ignored. +func (c *Cache) Fields(t reflect.Type) (List, error) { + if t.Kind() != reflect.Struct { + panic("fields: Fields of non-struct type") + } + return c.cachedTypeFields(t) +} + +// A List is a list of Fields. +type List []Field + +// Match returns the field in the list whose name best matches the supplied +// name, nor nil if no field does. If there is a field with the exact name, it +// is returned. Otherwise the first field (sorted by index) whose name matches +// case-insensitively is returned. +func (l List) Match(name string) *Field { + return l.MatchBytes([]byte(name)) +} + +// MatchBytes is identical to Match, except that the argument is a byte slice. +func (l List) MatchBytes(name []byte) *Field { + var f *Field + for i := range l { + ff := &l[i] + if bytes.Equal(ff.nameBytes, name) { + return ff + } + if f == nil && ff.equalFold(ff.nameBytes, name) { + f = ff + } + } + return f +} + +type cacheValue struct { + fields List + err error +} + +// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. +// This code has been copied and modified from +// https://go.googlesource.com/go/+/go1.7.3/src/encoding/json/encode.go. +func (c *Cache) cachedTypeFields(t reflect.Type) (List, error) { + var cv cacheValue + x, ok := c.cache.Load(t) + if ok { + cv = x.(cacheValue) + } else { + if err := c.validate(t); err != nil { + cv = cacheValue{nil, err} + } else { + f, err := c.typeFields(t) + cv = cacheValue{List(f), err} + } + c.cache.Store(t, cv) + } + return cv.fields, cv.err +} + +func (c *Cache) typeFields(t reflect.Type) ([]Field, error) { + fields, err := c.listFields(t) + if err != nil { + return nil, err + } + sort.Sort(byName(fields)) + // Delete all fields that are hidden by the Go rules for embedded fields. + + // The fields are sorted in primary order of name, secondary order of field + // index length. So the first field with a given name is the dominant one. + var out []Field + for advance, i := 0, 0; i < len(fields); i += advance { + // One iteration per name. + // Find the sequence of fields with the name of this first field. + fi := fields[i] + name := fi.Name + for advance = 1; i+advance < len(fields); advance++ { + fj := fields[i+advance] + if fj.Name != name { + break + } + } + // Find the dominant field, if any, out of all fields that have the same name. + dominant, ok := dominantField(fields[i : i+advance]) + if ok { + out = append(out, dominant) + } + } + sort.Sort(byIndex(out)) + return out, nil +} + +func (c *Cache) listFields(t reflect.Type) ([]Field, error) { + // This uses the same condition that the Go language does: there must be a unique instance + // of the match at a given depth level. If there are multiple instances of a match at the + // same depth, they annihilate each other and inhibit any possible match at a lower level. + // The algorithm is breadth first search, one depth level at a time. + + // The current and next slices are work queues: + // current lists the fields to visit on this depth level, + // and next lists the fields on the next lower level. + current := []fieldScan{} + next := []fieldScan{{typ: t}} + + // nextCount records the number of times an embedded type has been + // encountered and considered for queueing in the 'next' slice. + // We only queue the first one, but we increment the count on each. + // If a struct type T can be reached more than once at a given depth level, + // then it annihilates itself and need not be considered at all when we + // process that next depth level. + var nextCount map[reflect.Type]int + + // visited records the structs that have been considered already. + // Embedded pointer fields can create cycles in the graph of + // reachable embedded types; visited avoids following those cycles. + // It also avoids duplicated effort: if we didn't find the field in an + // embedded type T at level 2, we won't find it in one at level 4 either. + visited := map[reflect.Type]bool{} + + var fields []Field // Fields found. + + for len(next) > 0 { + current, next = next, current[:0] + count := nextCount + nextCount = nil + + // Process all the fields at this depth, now listed in 'current'. + // The loop queues embedded fields found in 'next', for processing during the next + // iteration. The multiplicity of the 'current' field counts is recorded + // in 'count'; the multiplicity of the 'next' field counts is recorded in 'nextCount'. + for _, scan := range current { + t := scan.typ + if visited[t] { + // We've looked through this type before, at a higher level. + // That higher level would shadow the lower level we're now at, + // so this one can't be useful to us. Ignore it. + continue + } + visited[t] = true + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + + exported := (f.PkgPath == "") + + // If a named field is unexported, ignore it. An anonymous + // unexported field is processed, because it may contain + // exported fields, which are visible. + if !exported && !f.Anonymous { + continue + } + + // Examine the tag. + tagName, keep, other, err := c.parseTag(f.Tag) + if err != nil { + return nil, err + } + if !keep { + continue + } + if c.leafTypes(f.Type) { + fields = append(fields, newField(f, tagName, other, scan.index, i)) + continue + } + + var ntyp reflect.Type + if f.Anonymous { + // Anonymous field of type T or *T. + ntyp = f.Type + if ntyp.Kind() == reflect.Ptr { + ntyp = ntyp.Elem() + } + } + + // Record fields with a tag name, non-anonymous fields, or + // anonymous non-struct fields. + if tagName != "" || ntyp == nil || ntyp.Kind() != reflect.Struct { + if !exported { + continue + } + fields = append(fields, newField(f, tagName, other, scan.index, i)) + if count[t] > 1 { + // If there were multiple instances, add a second, + // so that the annihilation code will see a duplicate. + fields = append(fields, fields[len(fields)-1]) + } + continue + } + + // Queue embedded struct fields for processing with next level, + // but only if the embedded types haven't already been queued. + if nextCount[ntyp] > 0 { + nextCount[ntyp] = 2 // exact multiple doesn't matter + continue + } + if nextCount == nil { + nextCount = map[reflect.Type]int{} + } + nextCount[ntyp] = 1 + if count[t] > 1 { + nextCount[ntyp] = 2 // exact multiple doesn't matter + } + var index []int + index = append(index, scan.index...) + index = append(index, i) + next = append(next, fieldScan{ntyp, index}) + } + } + } + return fields, nil +} + +func newField(f reflect.StructField, tagName string, other interface{}, index []int, i int) Field { + name := tagName + if name == "" { + name = f.Name + } + sf := Field{ + Name: name, + NameFromTag: tagName != "", + Type: f.Type, + ParsedTag: other, + nameBytes: []byte(name), + } + sf.equalFold = foldFunc(sf.nameBytes) + sf.Index = append(sf.Index, index...) + sf.Index = append(sf.Index, i) + return sf +} + +// byName sorts fields using the following criteria, in order: +// 1. name +// 2. embedding depth +// 3. tag presence (preferring a tagged field) +// 4. index sequence. +type byName []Field + +func (x byName) Len() int { return len(x) } + +func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byName) Less(i, j int) bool { + if x[i].Name != x[j].Name { + return x[i].Name < x[j].Name + } + if len(x[i].Index) != len(x[j].Index) { + return len(x[i].Index) < len(x[j].Index) + } + if x[i].NameFromTag != x[j].NameFromTag { + return x[i].NameFromTag + } + return byIndex(x).Less(i, j) +} + +// byIndex sorts field by index sequence. +type byIndex []Field + +func (x byIndex) Len() int { return len(x) } + +func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byIndex) Less(i, j int) bool { + xi := x[i].Index + xj := x[j].Index + ln := len(xi) + if l := len(xj); l < ln { + ln = l + } + for k := 0; k < ln; k++ { + if xi[k] != xj[k] { + return xi[k] < xj[k] + } + } + return len(xi) < len(xj) +} + +// dominantField looks through the fields, all of which are known to have the +// same name, to find the single field that dominates the others using Go's +// embedding rules, modified by the presence of tags. If there are multiple +// top-level fields, the boolean will be false: This condition is an error in +// Go and we skip all the fields. +func dominantField(fs []Field) (Field, bool) { + // The fields are sorted in increasing index-length order, then by presence of tag. + // That means that the first field is the dominant one. We need only check + // for error cases: two fields at top level, either both tagged or neither tagged. + if len(fs) > 1 && len(fs[0].Index) == len(fs[1].Index) && fs[0].NameFromTag == fs[1].NameFromTag { + return Field{}, false + } + return fs[0], true +} + +// ParseStandardTag extracts the sub-tag named by key, then parses it using the +// de facto standard format introduced in encoding/json: +// "-" means "ignore this tag". It must occur by itself. (parseStandardTag returns an error +// in this case, whereas encoding/json accepts the "-" even if it is not alone.) +// "" provides an alternative name for the field +// ",opt1,opt2,..." specifies options after the name. +// The options are returned as a []string. +func ParseStandardTag(key string, t reflect.StructTag) (name string, keep bool, options []string, err error) { + s := t.Get(key) + parts := strings.Split(s, ",") + if parts[0] == "-" { + if len(parts) > 1 { + return "", false, nil, errors.New(`"-" field tag with options`) + } + return "", false, nil, nil + } + if len(parts) > 1 { + options = parts[1:] + } + return parts[0], true, options, nil +} diff --git a/vendor/cloud.google.com/go/internal/fields/fold.go b/vendor/cloud.google.com/go/internal/fields/fold.go new file mode 100644 index 0000000..68e2588 --- /dev/null +++ b/vendor/cloud.google.com/go/internal/fields/fold.go @@ -0,0 +1,156 @@ +// Copyright 2016 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package fields + +// This file was copied from https://go.googlesource.com/go/+/go1.7.3/src/encoding/json/fold.go. +// Only the license and package were changed. + +import ( + "bytes" + "unicode/utf8" +) + +const ( + caseMask = ^byte(0x20) // Mask to ignore case in ASCII. + kelvin = '\u212a' + smallLongEss = '\u017f' +) + +// foldFunc returns one of four different case folding equivalence +// functions, from most general (and slow) to fastest: +// +// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8 +// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S') +// 3) asciiEqualFold, no special, but includes non-letters (including _) +// 4) simpleLetterEqualFold, no specials, no non-letters. +// +// The letters S and K are special because they map to 3 runes, not just 2: +// * S maps to s and to U+017F 'ſ' Latin small letter long s +// * k maps to K and to U+212A 'K' Kelvin sign +// See https://play.golang.org/p/tTxjOc0OGo +// +// The returned function is specialized for matching against s and +// should only be given s. It's not curried for performance reasons. +func foldFunc(s []byte) func(s, t []byte) bool { + nonLetter := false + special := false // special letter + for _, b := range s { + if b >= utf8.RuneSelf { + return bytes.EqualFold + } + upper := b & caseMask + if upper < 'A' || upper > 'Z' { + nonLetter = true + } else if upper == 'K' || upper == 'S' { + // See above for why these letters are special. + special = true + } + } + if special { + return equalFoldRight + } + if nonLetter { + return asciiEqualFold + } + return simpleLetterEqualFold +} + +// equalFoldRight is a specialization of bytes.EqualFold when s is +// known to be all ASCII (including punctuation), but contains an 's', +// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t. +// See comments on foldFunc. +func equalFoldRight(s, t []byte) bool { + for _, sb := range s { + if len(t) == 0 { + return false + } + tb := t[0] + if tb < utf8.RuneSelf { + if sb != tb { + sbUpper := sb & caseMask + if 'A' <= sbUpper && sbUpper <= 'Z' { + if sbUpper != tb&caseMask { + return false + } + } else { + return false + } + } + t = t[1:] + continue + } + // sb is ASCII and t is not. t must be either kelvin + // sign or long s; sb must be s, S, k, or K. + tr, size := utf8.DecodeRune(t) + switch sb { + case 's', 'S': + if tr != smallLongEss { + return false + } + case 'k', 'K': + if tr != kelvin { + return false + } + default: + return false + } + t = t[size:] + + } + if len(t) > 0 { + return false + } + return true +} + +// asciiEqualFold is a specialization of bytes.EqualFold for use when +// s is all ASCII (but may contain non-letters) and contains no +// special-folding letters. +// See comments on foldFunc. +func asciiEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, sb := range s { + tb := t[i] + if sb == tb { + continue + } + if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') { + if sb&caseMask != tb&caseMask { + return false + } + } else { + return false + } + } + return true +} + +// simpleLetterEqualFold is a specialization of bytes.EqualFold for +// use when s is all ASCII letters (no underscores, etc) and also +// doesn't contain 'k', 'K', 's', or 'S'. +// See comments on foldFunc. +func simpleLetterEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, b := range s { + if b&caseMask != t[i]&caseMask { + return false + } + } + return true +} diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go new file mode 100644 index 0000000..add19a1 --- /dev/null +++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go @@ -0,0 +1,461 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/protobuf/wrappers.proto + +package wrappers + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +// Wrapper message for `double`. +// +// The JSON representation for `DoubleValue` is JSON number. +type DoubleValue struct { + // The double value. + Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DoubleValue) Reset() { *m = DoubleValue{} } +func (m *DoubleValue) String() string { return proto.CompactTextString(m) } +func (*DoubleValue) ProtoMessage() {} +func (*DoubleValue) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{0} +} + +func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" } + +func (m *DoubleValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DoubleValue.Unmarshal(m, b) +} +func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic) +} +func (m *DoubleValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_DoubleValue.Merge(m, src) +} +func (m *DoubleValue) XXX_Size() int { + return xxx_messageInfo_DoubleValue.Size(m) +} +func (m *DoubleValue) XXX_DiscardUnknown() { + xxx_messageInfo_DoubleValue.DiscardUnknown(m) +} + +var xxx_messageInfo_DoubleValue proto.InternalMessageInfo + +func (m *DoubleValue) GetValue() float64 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `float`. +// +// The JSON representation for `FloatValue` is JSON number. +type FloatValue struct { + // The float value. + Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FloatValue) Reset() { *m = FloatValue{} } +func (m *FloatValue) String() string { return proto.CompactTextString(m) } +func (*FloatValue) ProtoMessage() {} +func (*FloatValue) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{1} +} + +func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" } + +func (m *FloatValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FloatValue.Unmarshal(m, b) +} +func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic) +} +func (m *FloatValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_FloatValue.Merge(m, src) +} +func (m *FloatValue) XXX_Size() int { + return xxx_messageInfo_FloatValue.Size(m) +} +func (m *FloatValue) XXX_DiscardUnknown() { + xxx_messageInfo_FloatValue.DiscardUnknown(m) +} + +var xxx_messageInfo_FloatValue proto.InternalMessageInfo + +func (m *FloatValue) GetValue() float32 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `int64`. +// +// The JSON representation for `Int64Value` is JSON string. +type Int64Value struct { + // The int64 value. + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Int64Value) Reset() { *m = Int64Value{} } +func (m *Int64Value) String() string { return proto.CompactTextString(m) } +func (*Int64Value) ProtoMessage() {} +func (*Int64Value) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{2} +} + +func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" } + +func (m *Int64Value) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Int64Value.Unmarshal(m, b) +} +func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic) +} +func (m *Int64Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_Int64Value.Merge(m, src) +} +func (m *Int64Value) XXX_Size() int { + return xxx_messageInfo_Int64Value.Size(m) +} +func (m *Int64Value) XXX_DiscardUnknown() { + xxx_messageInfo_Int64Value.DiscardUnknown(m) +} + +var xxx_messageInfo_Int64Value proto.InternalMessageInfo + +func (m *Int64Value) GetValue() int64 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `uint64`. +// +// The JSON representation for `UInt64Value` is JSON string. +type UInt64Value struct { + // The uint64 value. + Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UInt64Value) Reset() { *m = UInt64Value{} } +func (m *UInt64Value) String() string { return proto.CompactTextString(m) } +func (*UInt64Value) ProtoMessage() {} +func (*UInt64Value) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{3} +} + +func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" } + +func (m *UInt64Value) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UInt64Value.Unmarshal(m, b) +} +func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic) +} +func (m *UInt64Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_UInt64Value.Merge(m, src) +} +func (m *UInt64Value) XXX_Size() int { + return xxx_messageInfo_UInt64Value.Size(m) +} +func (m *UInt64Value) XXX_DiscardUnknown() { + xxx_messageInfo_UInt64Value.DiscardUnknown(m) +} + +var xxx_messageInfo_UInt64Value proto.InternalMessageInfo + +func (m *UInt64Value) GetValue() uint64 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `int32`. +// +// The JSON representation for `Int32Value` is JSON number. +type Int32Value struct { + // The int32 value. + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Int32Value) Reset() { *m = Int32Value{} } +func (m *Int32Value) String() string { return proto.CompactTextString(m) } +func (*Int32Value) ProtoMessage() {} +func (*Int32Value) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{4} +} + +func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" } + +func (m *Int32Value) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Int32Value.Unmarshal(m, b) +} +func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic) +} +func (m *Int32Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_Int32Value.Merge(m, src) +} +func (m *Int32Value) XXX_Size() int { + return xxx_messageInfo_Int32Value.Size(m) +} +func (m *Int32Value) XXX_DiscardUnknown() { + xxx_messageInfo_Int32Value.DiscardUnknown(m) +} + +var xxx_messageInfo_Int32Value proto.InternalMessageInfo + +func (m *Int32Value) GetValue() int32 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `uint32`. +// +// The JSON representation for `UInt32Value` is JSON number. +type UInt32Value struct { + // The uint32 value. + Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UInt32Value) Reset() { *m = UInt32Value{} } +func (m *UInt32Value) String() string { return proto.CompactTextString(m) } +func (*UInt32Value) ProtoMessage() {} +func (*UInt32Value) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{5} +} + +func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" } + +func (m *UInt32Value) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UInt32Value.Unmarshal(m, b) +} +func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic) +} +func (m *UInt32Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_UInt32Value.Merge(m, src) +} +func (m *UInt32Value) XXX_Size() int { + return xxx_messageInfo_UInt32Value.Size(m) +} +func (m *UInt32Value) XXX_DiscardUnknown() { + xxx_messageInfo_UInt32Value.DiscardUnknown(m) +} + +var xxx_messageInfo_UInt32Value proto.InternalMessageInfo + +func (m *UInt32Value) GetValue() uint32 { + if m != nil { + return m.Value + } + return 0 +} + +// Wrapper message for `bool`. +// +// The JSON representation for `BoolValue` is JSON `true` and `false`. +type BoolValue struct { + // The bool value. + Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BoolValue) Reset() { *m = BoolValue{} } +func (m *BoolValue) String() string { return proto.CompactTextString(m) } +func (*BoolValue) ProtoMessage() {} +func (*BoolValue) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{6} +} + +func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" } + +func (m *BoolValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BoolValue.Unmarshal(m, b) +} +func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic) +} +func (m *BoolValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_BoolValue.Merge(m, src) +} +func (m *BoolValue) XXX_Size() int { + return xxx_messageInfo_BoolValue.Size(m) +} +func (m *BoolValue) XXX_DiscardUnknown() { + xxx_messageInfo_BoolValue.DiscardUnknown(m) +} + +var xxx_messageInfo_BoolValue proto.InternalMessageInfo + +func (m *BoolValue) GetValue() bool { + if m != nil { + return m.Value + } + return false +} + +// Wrapper message for `string`. +// +// The JSON representation for `StringValue` is JSON string. +type StringValue struct { + // The string value. + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StringValue) Reset() { *m = StringValue{} } +func (m *StringValue) String() string { return proto.CompactTextString(m) } +func (*StringValue) ProtoMessage() {} +func (*StringValue) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{7} +} + +func (*StringValue) XXX_WellKnownType() string { return "StringValue" } + +func (m *StringValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StringValue.Unmarshal(m, b) +} +func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StringValue.Marshal(b, m, deterministic) +} +func (m *StringValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_StringValue.Merge(m, src) +} +func (m *StringValue) XXX_Size() int { + return xxx_messageInfo_StringValue.Size(m) +} +func (m *StringValue) XXX_DiscardUnknown() { + xxx_messageInfo_StringValue.DiscardUnknown(m) +} + +var xxx_messageInfo_StringValue proto.InternalMessageInfo + +func (m *StringValue) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +// Wrapper message for `bytes`. +// +// The JSON representation for `BytesValue` is JSON string. +type BytesValue struct { + // The bytes value. + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BytesValue) Reset() { *m = BytesValue{} } +func (m *BytesValue) String() string { return proto.CompactTextString(m) } +func (*BytesValue) ProtoMessage() {} +func (*BytesValue) Descriptor() ([]byte, []int) { + return fileDescriptor_5377b62bda767935, []int{8} +} + +func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" } + +func (m *BytesValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BytesValue.Unmarshal(m, b) +} +func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic) +} +func (m *BytesValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_BytesValue.Merge(m, src) +} +func (m *BytesValue) XXX_Size() int { + return xxx_messageInfo_BytesValue.Size(m) +} +func (m *BytesValue) XXX_DiscardUnknown() { + xxx_messageInfo_BytesValue.DiscardUnknown(m) +} + +var xxx_messageInfo_BytesValue proto.InternalMessageInfo + +func (m *BytesValue) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue") + proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue") + proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value") + proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value") + proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value") + proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value") + proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue") + proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue") + proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue") +} + +func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935) } + +var fileDescriptor_5377b62bda767935 = []byte{ + // 259 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, + 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c, + 0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca, + 0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c, + 0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5, + 0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13, + 0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8, + 0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca, + 0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a, + 0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d, + 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24, + 0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f, + 0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c, + 0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, + 0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, + 0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe, + 0x01, 0x00, 0x00, +} diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto new file mode 100644 index 0000000..0194763 --- /dev/null +++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto @@ -0,0 +1,118 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Wrappers for primitive (non-message) types. These types are useful +// for embedding primitives in the `google.protobuf.Any` type and for places +// where we need to distinguish between the absence of a primitive +// typed field and its default value. + +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/wrappers"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "WrappersProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; + +// Wrapper message for `double`. +// +// The JSON representation for `DoubleValue` is JSON number. +message DoubleValue { + // The double value. + double value = 1; +} + +// Wrapper message for `float`. +// +// The JSON representation for `FloatValue` is JSON number. +message FloatValue { + // The float value. + float value = 1; +} + +// Wrapper message for `int64`. +// +// The JSON representation for `Int64Value` is JSON string. +message Int64Value { + // The int64 value. + int64 value = 1; +} + +// Wrapper message for `uint64`. +// +// The JSON representation for `UInt64Value` is JSON string. +message UInt64Value { + // The uint64 value. + uint64 value = 1; +} + +// Wrapper message for `int32`. +// +// The JSON representation for `Int32Value` is JSON number. +message Int32Value { + // The int32 value. + int32 value = 1; +} + +// Wrapper message for `uint32`. +// +// The JSON representation for `UInt32Value` is JSON number. +message UInt32Value { + // The uint32 value. + uint32 value = 1; +} + +// Wrapper message for `bool`. +// +// The JSON representation for `BoolValue` is JSON `true` and `false`. +message BoolValue { + // The bool value. + bool value = 1; +} + +// Wrapper message for `string`. +// +// The JSON representation for `StringValue` is JSON string. +message StringValue { + // The string value. + string value = 1; +} + +// Wrapper message for `bytes`. +// +// The JSON representation for `BytesValue` is JSON string. +message BytesValue { + // The bytes value. + bytes value = 1; +} diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go new file mode 100644 index 0000000..5a7be60 --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go @@ -0,0 +1,2116 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/datastore/v1/datastore.proto + +package datastore // import "google.golang.org/genproto/googleapis/datastore/v1" + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "google.golang.org/genproto/googleapis/api/annotations" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// The modes available for commits. +type CommitRequest_Mode int32 + +const ( + // Unspecified. This value must not be used. + CommitRequest_MODE_UNSPECIFIED CommitRequest_Mode = 0 + // Transactional: The mutations are either all applied, or none are applied. + // Learn about transactions + // [here](https://cloud.google.com/datastore/docs/concepts/transactions). + CommitRequest_TRANSACTIONAL CommitRequest_Mode = 1 + // Non-transactional: The mutations may not apply as all or none. + CommitRequest_NON_TRANSACTIONAL CommitRequest_Mode = 2 +) + +var CommitRequest_Mode_name = map[int32]string{ + 0: "MODE_UNSPECIFIED", + 1: "TRANSACTIONAL", + 2: "NON_TRANSACTIONAL", +} +var CommitRequest_Mode_value = map[string]int32{ + "MODE_UNSPECIFIED": 0, + "TRANSACTIONAL": 1, + "NON_TRANSACTIONAL": 2, +} + +func (x CommitRequest_Mode) String() string { + return proto.EnumName(CommitRequest_Mode_name, int32(x)) +} +func (CommitRequest_Mode) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{8, 0} +} + +// The possible values for read consistencies. +type ReadOptions_ReadConsistency int32 + +const ( + // Unspecified. This value must not be used. + ReadOptions_READ_CONSISTENCY_UNSPECIFIED ReadOptions_ReadConsistency = 0 + // Strong consistency. + ReadOptions_STRONG ReadOptions_ReadConsistency = 1 + // Eventual consistency. + ReadOptions_EVENTUAL ReadOptions_ReadConsistency = 2 +) + +var ReadOptions_ReadConsistency_name = map[int32]string{ + 0: "READ_CONSISTENCY_UNSPECIFIED", + 1: "STRONG", + 2: "EVENTUAL", +} +var ReadOptions_ReadConsistency_value = map[string]int32{ + "READ_CONSISTENCY_UNSPECIFIED": 0, + "STRONG": 1, + "EVENTUAL": 2, +} + +func (x ReadOptions_ReadConsistency) String() string { + return proto.EnumName(ReadOptions_ReadConsistency_name, int32(x)) +} +func (ReadOptions_ReadConsistency) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{16, 0} +} + +// The request for [Datastore.Lookup][google.datastore.v1.Datastore.Lookup]. +type LookupRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // The options for this lookup request. + ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options,json=readOptions,proto3" json:"read_options,omitempty"` + // Keys of entities to look up. + Keys []*Key `protobuf:"bytes,3,rep,name=keys,proto3" json:"keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LookupRequest) Reset() { *m = LookupRequest{} } +func (m *LookupRequest) String() string { return proto.CompactTextString(m) } +func (*LookupRequest) ProtoMessage() {} +func (*LookupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{0} +} +func (m *LookupRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LookupRequest.Unmarshal(m, b) +} +func (m *LookupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LookupRequest.Marshal(b, m, deterministic) +} +func (dst *LookupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LookupRequest.Merge(dst, src) +} +func (m *LookupRequest) XXX_Size() int { + return xxx_messageInfo_LookupRequest.Size(m) +} +func (m *LookupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LookupRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LookupRequest proto.InternalMessageInfo + +func (m *LookupRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *LookupRequest) GetReadOptions() *ReadOptions { + if m != nil { + return m.ReadOptions + } + return nil +} + +func (m *LookupRequest) GetKeys() []*Key { + if m != nil { + return m.Keys + } + return nil +} + +// The response for [Datastore.Lookup][google.datastore.v1.Datastore.Lookup]. +type LookupResponse struct { + // Entities found as `ResultType.FULL` entities. The order of results in this + // field is undefined and has no relation to the order of the keys in the + // input. + Found []*EntityResult `protobuf:"bytes,1,rep,name=found,proto3" json:"found,omitempty"` + // Entities not found as `ResultType.KEY_ONLY` entities. The order of results + // in this field is undefined and has no relation to the order of the keys + // in the input. + Missing []*EntityResult `protobuf:"bytes,2,rep,name=missing,proto3" json:"missing,omitempty"` + // A list of keys that were not looked up due to resource constraints. The + // order of results in this field is undefined and has no relation to the + // order of the keys in the input. + Deferred []*Key `protobuf:"bytes,3,rep,name=deferred,proto3" json:"deferred,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LookupResponse) Reset() { *m = LookupResponse{} } +func (m *LookupResponse) String() string { return proto.CompactTextString(m) } +func (*LookupResponse) ProtoMessage() {} +func (*LookupResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{1} +} +func (m *LookupResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LookupResponse.Unmarshal(m, b) +} +func (m *LookupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LookupResponse.Marshal(b, m, deterministic) +} +func (dst *LookupResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LookupResponse.Merge(dst, src) +} +func (m *LookupResponse) XXX_Size() int { + return xxx_messageInfo_LookupResponse.Size(m) +} +func (m *LookupResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LookupResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LookupResponse proto.InternalMessageInfo + +func (m *LookupResponse) GetFound() []*EntityResult { + if m != nil { + return m.Found + } + return nil +} + +func (m *LookupResponse) GetMissing() []*EntityResult { + if m != nil { + return m.Missing + } + return nil +} + +func (m *LookupResponse) GetDeferred() []*Key { + if m != nil { + return m.Deferred + } + return nil +} + +// The request for [Datastore.RunQuery][google.datastore.v1.Datastore.RunQuery]. +type RunQueryRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // Entities are partitioned into subsets, identified by a partition ID. + // Queries are scoped to a single partition. + // This partition ID is normalized with the standard default context + // partition ID. + PartitionId *PartitionId `protobuf:"bytes,2,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"` + // The options for this query. + ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options,json=readOptions,proto3" json:"read_options,omitempty"` + // The type of query. + // + // Types that are valid to be assigned to QueryType: + // *RunQueryRequest_Query + // *RunQueryRequest_GqlQuery + QueryType isRunQueryRequest_QueryType `protobuf_oneof:"query_type"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunQueryRequest) Reset() { *m = RunQueryRequest{} } +func (m *RunQueryRequest) String() string { return proto.CompactTextString(m) } +func (*RunQueryRequest) ProtoMessage() {} +func (*RunQueryRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{2} +} +func (m *RunQueryRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunQueryRequest.Unmarshal(m, b) +} +func (m *RunQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunQueryRequest.Marshal(b, m, deterministic) +} +func (dst *RunQueryRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunQueryRequest.Merge(dst, src) +} +func (m *RunQueryRequest) XXX_Size() int { + return xxx_messageInfo_RunQueryRequest.Size(m) +} +func (m *RunQueryRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RunQueryRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RunQueryRequest proto.InternalMessageInfo + +func (m *RunQueryRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *RunQueryRequest) GetPartitionId() *PartitionId { + if m != nil { + return m.PartitionId + } + return nil +} + +func (m *RunQueryRequest) GetReadOptions() *ReadOptions { + if m != nil { + return m.ReadOptions + } + return nil +} + +type isRunQueryRequest_QueryType interface { + isRunQueryRequest_QueryType() +} + +type RunQueryRequest_Query struct { + Query *Query `protobuf:"bytes,3,opt,name=query,proto3,oneof"` +} + +type RunQueryRequest_GqlQuery struct { + GqlQuery *GqlQuery `protobuf:"bytes,7,opt,name=gql_query,json=gqlQuery,proto3,oneof"` +} + +func (*RunQueryRequest_Query) isRunQueryRequest_QueryType() {} + +func (*RunQueryRequest_GqlQuery) isRunQueryRequest_QueryType() {} + +func (m *RunQueryRequest) GetQueryType() isRunQueryRequest_QueryType { + if m != nil { + return m.QueryType + } + return nil +} + +func (m *RunQueryRequest) GetQuery() *Query { + if x, ok := m.GetQueryType().(*RunQueryRequest_Query); ok { + return x.Query + } + return nil +} + +func (m *RunQueryRequest) GetGqlQuery() *GqlQuery { + if x, ok := m.GetQueryType().(*RunQueryRequest_GqlQuery); ok { + return x.GqlQuery + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*RunQueryRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _RunQueryRequest_OneofMarshaler, _RunQueryRequest_OneofUnmarshaler, _RunQueryRequest_OneofSizer, []interface{}{ + (*RunQueryRequest_Query)(nil), + (*RunQueryRequest_GqlQuery)(nil), + } +} + +func _RunQueryRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*RunQueryRequest) + // query_type + switch x := m.QueryType.(type) { + case *RunQueryRequest_Query: + b.EncodeVarint(3<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Query); err != nil { + return err + } + case *RunQueryRequest_GqlQuery: + b.EncodeVarint(7<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.GqlQuery); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("RunQueryRequest.QueryType has unexpected type %T", x) + } + return nil +} + +func _RunQueryRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*RunQueryRequest) + switch tag { + case 3: // query_type.query + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Query) + err := b.DecodeMessage(msg) + m.QueryType = &RunQueryRequest_Query{msg} + return true, err + case 7: // query_type.gql_query + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(GqlQuery) + err := b.DecodeMessage(msg) + m.QueryType = &RunQueryRequest_GqlQuery{msg} + return true, err + default: + return false, nil + } +} + +func _RunQueryRequest_OneofSizer(msg proto.Message) (n int) { + m := msg.(*RunQueryRequest) + // query_type + switch x := m.QueryType.(type) { + case *RunQueryRequest_Query: + s := proto.Size(x.Query) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *RunQueryRequest_GqlQuery: + s := proto.Size(x.GqlQuery) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// The response for +// [Datastore.RunQuery][google.datastore.v1.Datastore.RunQuery]. +type RunQueryResponse struct { + // A batch of query results (always present). + Batch *QueryResultBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + // The parsed form of the `GqlQuery` from the request, if it was set. + Query *Query `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunQueryResponse) Reset() { *m = RunQueryResponse{} } +func (m *RunQueryResponse) String() string { return proto.CompactTextString(m) } +func (*RunQueryResponse) ProtoMessage() {} +func (*RunQueryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{3} +} +func (m *RunQueryResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunQueryResponse.Unmarshal(m, b) +} +func (m *RunQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunQueryResponse.Marshal(b, m, deterministic) +} +func (dst *RunQueryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunQueryResponse.Merge(dst, src) +} +func (m *RunQueryResponse) XXX_Size() int { + return xxx_messageInfo_RunQueryResponse.Size(m) +} +func (m *RunQueryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RunQueryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RunQueryResponse proto.InternalMessageInfo + +func (m *RunQueryResponse) GetBatch() *QueryResultBatch { + if m != nil { + return m.Batch + } + return nil +} + +func (m *RunQueryResponse) GetQuery() *Query { + if m != nil { + return m.Query + } + return nil +} + +// The request for +// [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction]. +type BeginTransactionRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // Options for a new transaction. + TransactionOptions *TransactionOptions `protobuf:"bytes,10,opt,name=transaction_options,json=transactionOptions,proto3" json:"transaction_options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } +func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) } +func (*BeginTransactionRequest) ProtoMessage() {} +func (*BeginTransactionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{4} +} +func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b) +} +func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic) +} +func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BeginTransactionRequest.Merge(dst, src) +} +func (m *BeginTransactionRequest) XXX_Size() int { + return xxx_messageInfo_BeginTransactionRequest.Size(m) +} +func (m *BeginTransactionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo + +func (m *BeginTransactionRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *BeginTransactionRequest) GetTransactionOptions() *TransactionOptions { + if m != nil { + return m.TransactionOptions + } + return nil +} + +// The response for +// [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction]. +type BeginTransactionResponse struct { + // The transaction identifier (always present). + Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BeginTransactionResponse) Reset() { *m = BeginTransactionResponse{} } +func (m *BeginTransactionResponse) String() string { return proto.CompactTextString(m) } +func (*BeginTransactionResponse) ProtoMessage() {} +func (*BeginTransactionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{5} +} +func (m *BeginTransactionResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BeginTransactionResponse.Unmarshal(m, b) +} +func (m *BeginTransactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BeginTransactionResponse.Marshal(b, m, deterministic) +} +func (dst *BeginTransactionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BeginTransactionResponse.Merge(dst, src) +} +func (m *BeginTransactionResponse) XXX_Size() int { + return xxx_messageInfo_BeginTransactionResponse.Size(m) +} +func (m *BeginTransactionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BeginTransactionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BeginTransactionResponse proto.InternalMessageInfo + +func (m *BeginTransactionResponse) GetTransaction() []byte { + if m != nil { + return m.Transaction + } + return nil +} + +// The request for [Datastore.Rollback][google.datastore.v1.Datastore.Rollback]. +type RollbackRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // The transaction identifier, returned by a call to + // [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction]. + Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RollbackRequest) Reset() { *m = RollbackRequest{} } +func (m *RollbackRequest) String() string { return proto.CompactTextString(m) } +func (*RollbackRequest) ProtoMessage() {} +func (*RollbackRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{6} +} +func (m *RollbackRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RollbackRequest.Unmarshal(m, b) +} +func (m *RollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RollbackRequest.Marshal(b, m, deterministic) +} +func (dst *RollbackRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RollbackRequest.Merge(dst, src) +} +func (m *RollbackRequest) XXX_Size() int { + return xxx_messageInfo_RollbackRequest.Size(m) +} +func (m *RollbackRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RollbackRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RollbackRequest proto.InternalMessageInfo + +func (m *RollbackRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *RollbackRequest) GetTransaction() []byte { + if m != nil { + return m.Transaction + } + return nil +} + +// The response for +// [Datastore.Rollback][google.datastore.v1.Datastore.Rollback]. (an empty +// message). +type RollbackResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RollbackResponse) Reset() { *m = RollbackResponse{} } +func (m *RollbackResponse) String() string { return proto.CompactTextString(m) } +func (*RollbackResponse) ProtoMessage() {} +func (*RollbackResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{7} +} +func (m *RollbackResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RollbackResponse.Unmarshal(m, b) +} +func (m *RollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RollbackResponse.Marshal(b, m, deterministic) +} +func (dst *RollbackResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RollbackResponse.Merge(dst, src) +} +func (m *RollbackResponse) XXX_Size() int { + return xxx_messageInfo_RollbackResponse.Size(m) +} +func (m *RollbackResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RollbackResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RollbackResponse proto.InternalMessageInfo + +// The request for [Datastore.Commit][google.datastore.v1.Datastore.Commit]. +type CommitRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // The type of commit to perform. Defaults to `TRANSACTIONAL`. + Mode CommitRequest_Mode `protobuf:"varint,5,opt,name=mode,proto3,enum=google.datastore.v1.CommitRequest_Mode" json:"mode,omitempty"` + // Must be set when mode is `TRANSACTIONAL`. + // + // Types that are valid to be assigned to TransactionSelector: + // *CommitRequest_Transaction + TransactionSelector isCommitRequest_TransactionSelector `protobuf_oneof:"transaction_selector"` + // The mutations to perform. + // + // When mode is `TRANSACTIONAL`, mutations affecting a single entity are + // applied in order. The following sequences of mutations affecting a single + // entity are not permitted in a single `Commit` request: + // + // - `insert` followed by `insert` + // - `update` followed by `insert` + // - `upsert` followed by `insert` + // - `delete` followed by `update` + // + // When mode is `NON_TRANSACTIONAL`, no two mutations may affect a single + // entity. + Mutations []*Mutation `protobuf:"bytes,6,rep,name=mutations,proto3" json:"mutations,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CommitRequest) Reset() { *m = CommitRequest{} } +func (m *CommitRequest) String() string { return proto.CompactTextString(m) } +func (*CommitRequest) ProtoMessage() {} +func (*CommitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{8} +} +func (m *CommitRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CommitRequest.Unmarshal(m, b) +} +func (m *CommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CommitRequest.Marshal(b, m, deterministic) +} +func (dst *CommitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitRequest.Merge(dst, src) +} +func (m *CommitRequest) XXX_Size() int { + return xxx_messageInfo_CommitRequest.Size(m) +} +func (m *CommitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CommitRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitRequest proto.InternalMessageInfo + +func (m *CommitRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *CommitRequest) GetMode() CommitRequest_Mode { + if m != nil { + return m.Mode + } + return CommitRequest_MODE_UNSPECIFIED +} + +type isCommitRequest_TransactionSelector interface { + isCommitRequest_TransactionSelector() +} + +type CommitRequest_Transaction struct { + Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3,oneof"` +} + +func (*CommitRequest_Transaction) isCommitRequest_TransactionSelector() {} + +func (m *CommitRequest) GetTransactionSelector() isCommitRequest_TransactionSelector { + if m != nil { + return m.TransactionSelector + } + return nil +} + +func (m *CommitRequest) GetTransaction() []byte { + if x, ok := m.GetTransactionSelector().(*CommitRequest_Transaction); ok { + return x.Transaction + } + return nil +} + +func (m *CommitRequest) GetMutations() []*Mutation { + if m != nil { + return m.Mutations + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CommitRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _CommitRequest_OneofMarshaler, _CommitRequest_OneofUnmarshaler, _CommitRequest_OneofSizer, []interface{}{ + (*CommitRequest_Transaction)(nil), + } +} + +func _CommitRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CommitRequest) + // transaction_selector + switch x := m.TransactionSelector.(type) { + case *CommitRequest_Transaction: + b.EncodeVarint(1<<3 | proto.WireBytes) + b.EncodeRawBytes(x.Transaction) + case nil: + default: + return fmt.Errorf("CommitRequest.TransactionSelector has unexpected type %T", x) + } + return nil +} + +func _CommitRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CommitRequest) + switch tag { + case 1: // transaction_selector.transaction + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TransactionSelector = &CommitRequest_Transaction{x} + return true, err + default: + return false, nil + } +} + +func _CommitRequest_OneofSizer(msg proto.Message) (n int) { + m := msg.(*CommitRequest) + // transaction_selector + switch x := m.TransactionSelector.(type) { + case *CommitRequest_Transaction: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(len(x.Transaction))) + n += len(x.Transaction) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// The response for [Datastore.Commit][google.datastore.v1.Datastore.Commit]. +type CommitResponse struct { + // The result of performing the mutations. + // The i-th mutation result corresponds to the i-th mutation in the request. + MutationResults []*MutationResult `protobuf:"bytes,3,rep,name=mutation_results,json=mutationResults,proto3" json:"mutation_results,omitempty"` + // The number of index entries updated during the commit, or zero if none were + // updated. + IndexUpdates int32 `protobuf:"varint,4,opt,name=index_updates,json=indexUpdates,proto3" json:"index_updates,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CommitResponse) Reset() { *m = CommitResponse{} } +func (m *CommitResponse) String() string { return proto.CompactTextString(m) } +func (*CommitResponse) ProtoMessage() {} +func (*CommitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{9} +} +func (m *CommitResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CommitResponse.Unmarshal(m, b) +} +func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic) +} +func (dst *CommitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitResponse.Merge(dst, src) +} +func (m *CommitResponse) XXX_Size() int { + return xxx_messageInfo_CommitResponse.Size(m) +} +func (m *CommitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CommitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitResponse proto.InternalMessageInfo + +func (m *CommitResponse) GetMutationResults() []*MutationResult { + if m != nil { + return m.MutationResults + } + return nil +} + +func (m *CommitResponse) GetIndexUpdates() int32 { + if m != nil { + return m.IndexUpdates + } + return 0 +} + +// The request for +// [Datastore.AllocateIds][google.datastore.v1.Datastore.AllocateIds]. +type AllocateIdsRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // A list of keys with incomplete key paths for which to allocate IDs. + // No key may be reserved/read-only. + Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} } +func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) } +func (*AllocateIdsRequest) ProtoMessage() {} +func (*AllocateIdsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{10} +} +func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b) +} +func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic) +} +func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllocateIdsRequest.Merge(dst, src) +} +func (m *AllocateIdsRequest) XXX_Size() int { + return xxx_messageInfo_AllocateIdsRequest.Size(m) +} +func (m *AllocateIdsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo + +func (m *AllocateIdsRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *AllocateIdsRequest) GetKeys() []*Key { + if m != nil { + return m.Keys + } + return nil +} + +// The response for +// [Datastore.AllocateIds][google.datastore.v1.Datastore.AllocateIds]. +type AllocateIdsResponse struct { + // The keys specified in the request (in the same order), each with + // its key path completed with a newly allocated ID. + Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} } +func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) } +func (*AllocateIdsResponse) ProtoMessage() {} +func (*AllocateIdsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{11} +} +func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b) +} +func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic) +} +func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllocateIdsResponse.Merge(dst, src) +} +func (m *AllocateIdsResponse) XXX_Size() int { + return xxx_messageInfo_AllocateIdsResponse.Size(m) +} +func (m *AllocateIdsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo + +func (m *AllocateIdsResponse) GetKeys() []*Key { + if m != nil { + return m.Keys + } + return nil +} + +// The request for +// [Datastore.ReserveIds][google.datastore.v1.Datastore.ReserveIds]. +type ReserveIdsRequest struct { + // The ID of the project against which to make the request. + ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // If not empty, the ID of the database against which to make the request. + DatabaseId string `protobuf:"bytes,9,opt,name=database_id,json=databaseId,proto3" json:"database_id,omitempty"` + // A list of keys with complete key paths whose numeric IDs should not be + // auto-allocated. + Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReserveIdsRequest) Reset() { *m = ReserveIdsRequest{} } +func (m *ReserveIdsRequest) String() string { return proto.CompactTextString(m) } +func (*ReserveIdsRequest) ProtoMessage() {} +func (*ReserveIdsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{12} +} +func (m *ReserveIdsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReserveIdsRequest.Unmarshal(m, b) +} +func (m *ReserveIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReserveIdsRequest.Marshal(b, m, deterministic) +} +func (dst *ReserveIdsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReserveIdsRequest.Merge(dst, src) +} +func (m *ReserveIdsRequest) XXX_Size() int { + return xxx_messageInfo_ReserveIdsRequest.Size(m) +} +func (m *ReserveIdsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReserveIdsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ReserveIdsRequest proto.InternalMessageInfo + +func (m *ReserveIdsRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *ReserveIdsRequest) GetDatabaseId() string { + if m != nil { + return m.DatabaseId + } + return "" +} + +func (m *ReserveIdsRequest) GetKeys() []*Key { + if m != nil { + return m.Keys + } + return nil +} + +// The response for +// [Datastore.ReserveIds][google.datastore.v1.Datastore.ReserveIds]. +type ReserveIdsResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReserveIdsResponse) Reset() { *m = ReserveIdsResponse{} } +func (m *ReserveIdsResponse) String() string { return proto.CompactTextString(m) } +func (*ReserveIdsResponse) ProtoMessage() {} +func (*ReserveIdsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{13} +} +func (m *ReserveIdsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReserveIdsResponse.Unmarshal(m, b) +} +func (m *ReserveIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReserveIdsResponse.Marshal(b, m, deterministic) +} +func (dst *ReserveIdsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReserveIdsResponse.Merge(dst, src) +} +func (m *ReserveIdsResponse) XXX_Size() int { + return xxx_messageInfo_ReserveIdsResponse.Size(m) +} +func (m *ReserveIdsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReserveIdsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ReserveIdsResponse proto.InternalMessageInfo + +// A mutation to apply to an entity. +type Mutation struct { + // The mutation operation. + // + // For `insert`, `update`, and `upsert`: + // - The entity's key must not be reserved/read-only. + // - No property in the entity may have a reserved name, + // not even a property in an entity in a value. + // - No value in the entity may have meaning 18, + // not even a value in an entity in another value. + // + // Types that are valid to be assigned to Operation: + // *Mutation_Insert + // *Mutation_Update + // *Mutation_Upsert + // *Mutation_Delete + Operation isMutation_Operation `protobuf_oneof:"operation"` + // When set, the server will detect whether or not this mutation conflicts + // with the current version of the entity on the server. Conflicting mutations + // are not applied, and are marked as such in MutationResult. + // + // Types that are valid to be assigned to ConflictDetectionStrategy: + // *Mutation_BaseVersion + ConflictDetectionStrategy isMutation_ConflictDetectionStrategy `protobuf_oneof:"conflict_detection_strategy"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Mutation) Reset() { *m = Mutation{} } +func (m *Mutation) String() string { return proto.CompactTextString(m) } +func (*Mutation) ProtoMessage() {} +func (*Mutation) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{14} +} +func (m *Mutation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Mutation.Unmarshal(m, b) +} +func (m *Mutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Mutation.Marshal(b, m, deterministic) +} +func (dst *Mutation) XXX_Merge(src proto.Message) { + xxx_messageInfo_Mutation.Merge(dst, src) +} +func (m *Mutation) XXX_Size() int { + return xxx_messageInfo_Mutation.Size(m) +} +func (m *Mutation) XXX_DiscardUnknown() { + xxx_messageInfo_Mutation.DiscardUnknown(m) +} + +var xxx_messageInfo_Mutation proto.InternalMessageInfo + +type isMutation_Operation interface { + isMutation_Operation() +} + +type Mutation_Insert struct { + Insert *Entity `protobuf:"bytes,4,opt,name=insert,proto3,oneof"` +} + +type Mutation_Update struct { + Update *Entity `protobuf:"bytes,5,opt,name=update,proto3,oneof"` +} + +type Mutation_Upsert struct { + Upsert *Entity `protobuf:"bytes,6,opt,name=upsert,proto3,oneof"` +} + +type Mutation_Delete struct { + Delete *Key `protobuf:"bytes,7,opt,name=delete,proto3,oneof"` +} + +func (*Mutation_Insert) isMutation_Operation() {} + +func (*Mutation_Update) isMutation_Operation() {} + +func (*Mutation_Upsert) isMutation_Operation() {} + +func (*Mutation_Delete) isMutation_Operation() {} + +func (m *Mutation) GetOperation() isMutation_Operation { + if m != nil { + return m.Operation + } + return nil +} + +func (m *Mutation) GetInsert() *Entity { + if x, ok := m.GetOperation().(*Mutation_Insert); ok { + return x.Insert + } + return nil +} + +func (m *Mutation) GetUpdate() *Entity { + if x, ok := m.GetOperation().(*Mutation_Update); ok { + return x.Update + } + return nil +} + +func (m *Mutation) GetUpsert() *Entity { + if x, ok := m.GetOperation().(*Mutation_Upsert); ok { + return x.Upsert + } + return nil +} + +func (m *Mutation) GetDelete() *Key { + if x, ok := m.GetOperation().(*Mutation_Delete); ok { + return x.Delete + } + return nil +} + +type isMutation_ConflictDetectionStrategy interface { + isMutation_ConflictDetectionStrategy() +} + +type Mutation_BaseVersion struct { + BaseVersion int64 `protobuf:"varint,8,opt,name=base_version,json=baseVersion,proto3,oneof"` +} + +func (*Mutation_BaseVersion) isMutation_ConflictDetectionStrategy() {} + +func (m *Mutation) GetConflictDetectionStrategy() isMutation_ConflictDetectionStrategy { + if m != nil { + return m.ConflictDetectionStrategy + } + return nil +} + +func (m *Mutation) GetBaseVersion() int64 { + if x, ok := m.GetConflictDetectionStrategy().(*Mutation_BaseVersion); ok { + return x.BaseVersion + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Mutation) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Mutation_OneofMarshaler, _Mutation_OneofUnmarshaler, _Mutation_OneofSizer, []interface{}{ + (*Mutation_Insert)(nil), + (*Mutation_Update)(nil), + (*Mutation_Upsert)(nil), + (*Mutation_Delete)(nil), + (*Mutation_BaseVersion)(nil), + } +} + +func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Mutation) + // operation + switch x := m.Operation.(type) { + case *Mutation_Insert: + b.EncodeVarint(4<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Insert); err != nil { + return err + } + case *Mutation_Update: + b.EncodeVarint(5<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Update); err != nil { + return err + } + case *Mutation_Upsert: + b.EncodeVarint(6<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Upsert); err != nil { + return err + } + case *Mutation_Delete: + b.EncodeVarint(7<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Delete); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Mutation.Operation has unexpected type %T", x) + } + // conflict_detection_strategy + switch x := m.ConflictDetectionStrategy.(type) { + case *Mutation_BaseVersion: + b.EncodeVarint(8<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.BaseVersion)) + case nil: + default: + return fmt.Errorf("Mutation.ConflictDetectionStrategy has unexpected type %T", x) + } + return nil +} + +func _Mutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Mutation) + switch tag { + case 4: // operation.insert + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Entity) + err := b.DecodeMessage(msg) + m.Operation = &Mutation_Insert{msg} + return true, err + case 5: // operation.update + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Entity) + err := b.DecodeMessage(msg) + m.Operation = &Mutation_Update{msg} + return true, err + case 6: // operation.upsert + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Entity) + err := b.DecodeMessage(msg) + m.Operation = &Mutation_Upsert{msg} + return true, err + case 7: // operation.delete + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Key) + err := b.DecodeMessage(msg) + m.Operation = &Mutation_Delete{msg} + return true, err + case 8: // conflict_detection_strategy.base_version + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.ConflictDetectionStrategy = &Mutation_BaseVersion{int64(x)} + return true, err + default: + return false, nil + } +} + +func _Mutation_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Mutation) + // operation + switch x := m.Operation.(type) { + case *Mutation_Insert: + s := proto.Size(x.Insert) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Mutation_Update: + s := proto.Size(x.Update) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Mutation_Upsert: + s := proto.Size(x.Upsert) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Mutation_Delete: + s := proto.Size(x.Delete) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + // conflict_detection_strategy + switch x := m.ConflictDetectionStrategy.(type) { + case *Mutation_BaseVersion: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(x.BaseVersion)) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// The result of applying a mutation. +type MutationResult struct { + // The automatically allocated key. + // Set only when the mutation allocated a key. + Key *Key `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + // The version of the entity on the server after processing the mutation. If + // the mutation doesn't change anything on the server, then the version will + // be the version of the current entity or, if no entity is present, a version + // that is strictly greater than the version of any previous entity and less + // than the version of any possible future entity. + Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` + // Whether a conflict was detected for this mutation. Always false when a + // conflict detection strategy field is not set in the mutation. + ConflictDetected bool `protobuf:"varint,5,opt,name=conflict_detected,json=conflictDetected,proto3" json:"conflict_detected,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MutationResult) Reset() { *m = MutationResult{} } +func (m *MutationResult) String() string { return proto.CompactTextString(m) } +func (*MutationResult) ProtoMessage() {} +func (*MutationResult) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{15} +} +func (m *MutationResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MutationResult.Unmarshal(m, b) +} +func (m *MutationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MutationResult.Marshal(b, m, deterministic) +} +func (dst *MutationResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MutationResult.Merge(dst, src) +} +func (m *MutationResult) XXX_Size() int { + return xxx_messageInfo_MutationResult.Size(m) +} +func (m *MutationResult) XXX_DiscardUnknown() { + xxx_messageInfo_MutationResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MutationResult proto.InternalMessageInfo + +func (m *MutationResult) GetKey() *Key { + if m != nil { + return m.Key + } + return nil +} + +func (m *MutationResult) GetVersion() int64 { + if m != nil { + return m.Version + } + return 0 +} + +func (m *MutationResult) GetConflictDetected() bool { + if m != nil { + return m.ConflictDetected + } + return false +} + +// The options shared by read requests. +type ReadOptions struct { + // If not specified, lookups and ancestor queries default to + // `read_consistency`=`STRONG`, global queries default to + // `read_consistency`=`EVENTUAL`. + // + // Types that are valid to be assigned to ConsistencyType: + // *ReadOptions_ReadConsistency_ + // *ReadOptions_Transaction + ConsistencyType isReadOptions_ConsistencyType `protobuf_oneof:"consistency_type"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReadOptions) Reset() { *m = ReadOptions{} } +func (m *ReadOptions) String() string { return proto.CompactTextString(m) } +func (*ReadOptions) ProtoMessage() {} +func (*ReadOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{16} +} +func (m *ReadOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReadOptions.Unmarshal(m, b) +} +func (m *ReadOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReadOptions.Marshal(b, m, deterministic) +} +func (dst *ReadOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReadOptions.Merge(dst, src) +} +func (m *ReadOptions) XXX_Size() int { + return xxx_messageInfo_ReadOptions.Size(m) +} +func (m *ReadOptions) XXX_DiscardUnknown() { + xxx_messageInfo_ReadOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_ReadOptions proto.InternalMessageInfo + +type isReadOptions_ConsistencyType interface { + isReadOptions_ConsistencyType() +} + +type ReadOptions_ReadConsistency_ struct { + ReadConsistency ReadOptions_ReadConsistency `protobuf:"varint,1,opt,name=read_consistency,json=readConsistency,proto3,enum=google.datastore.v1.ReadOptions_ReadConsistency,oneof"` +} + +type ReadOptions_Transaction struct { + Transaction []byte `protobuf:"bytes,2,opt,name=transaction,proto3,oneof"` +} + +func (*ReadOptions_ReadConsistency_) isReadOptions_ConsistencyType() {} + +func (*ReadOptions_Transaction) isReadOptions_ConsistencyType() {} + +func (m *ReadOptions) GetConsistencyType() isReadOptions_ConsistencyType { + if m != nil { + return m.ConsistencyType + } + return nil +} + +func (m *ReadOptions) GetReadConsistency() ReadOptions_ReadConsistency { + if x, ok := m.GetConsistencyType().(*ReadOptions_ReadConsistency_); ok { + return x.ReadConsistency + } + return ReadOptions_READ_CONSISTENCY_UNSPECIFIED +} + +func (m *ReadOptions) GetTransaction() []byte { + if x, ok := m.GetConsistencyType().(*ReadOptions_Transaction); ok { + return x.Transaction + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*ReadOptions) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _ReadOptions_OneofMarshaler, _ReadOptions_OneofUnmarshaler, _ReadOptions_OneofSizer, []interface{}{ + (*ReadOptions_ReadConsistency_)(nil), + (*ReadOptions_Transaction)(nil), + } +} + +func _ReadOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*ReadOptions) + // consistency_type + switch x := m.ConsistencyType.(type) { + case *ReadOptions_ReadConsistency_: + b.EncodeVarint(1<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.ReadConsistency)) + case *ReadOptions_Transaction: + b.EncodeVarint(2<<3 | proto.WireBytes) + b.EncodeRawBytes(x.Transaction) + case nil: + default: + return fmt.Errorf("ReadOptions.ConsistencyType has unexpected type %T", x) + } + return nil +} + +func _ReadOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*ReadOptions) + switch tag { + case 1: // consistency_type.read_consistency + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.ConsistencyType = &ReadOptions_ReadConsistency_{ReadOptions_ReadConsistency(x)} + return true, err + case 2: // consistency_type.transaction + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.ConsistencyType = &ReadOptions_Transaction{x} + return true, err + default: + return false, nil + } +} + +func _ReadOptions_OneofSizer(msg proto.Message) (n int) { + m := msg.(*ReadOptions) + // consistency_type + switch x := m.ConsistencyType.(type) { + case *ReadOptions_ReadConsistency_: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(x.ReadConsistency)) + case *ReadOptions_Transaction: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(len(x.Transaction))) + n += len(x.Transaction) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Options for beginning a new transaction. +// +// Transactions can be created explicitly with calls to +// [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction] +// or implicitly by setting +// [ReadOptions.new_transaction][google.datastore.v1.ReadOptions.new_transaction] +// in read requests. +type TransactionOptions struct { + // The `mode` of the transaction, indicating whether write operations are + // supported. + // + // Types that are valid to be assigned to Mode: + // *TransactionOptions_ReadWrite_ + // *TransactionOptions_ReadOnly_ + Mode isTransactionOptions_Mode `protobuf_oneof:"mode"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TransactionOptions) Reset() { *m = TransactionOptions{} } +func (m *TransactionOptions) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions) ProtoMessage() {} +func (*TransactionOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{17} +} +func (m *TransactionOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TransactionOptions.Unmarshal(m, b) +} +func (m *TransactionOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TransactionOptions.Marshal(b, m, deterministic) +} +func (dst *TransactionOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionOptions.Merge(dst, src) +} +func (m *TransactionOptions) XXX_Size() int { + return xxx_messageInfo_TransactionOptions.Size(m) +} +func (m *TransactionOptions) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionOptions proto.InternalMessageInfo + +type isTransactionOptions_Mode interface { + isTransactionOptions_Mode() +} + +type TransactionOptions_ReadWrite_ struct { + ReadWrite *TransactionOptions_ReadWrite `protobuf:"bytes,1,opt,name=read_write,json=readWrite,proto3,oneof"` +} + +type TransactionOptions_ReadOnly_ struct { + ReadOnly *TransactionOptions_ReadOnly `protobuf:"bytes,2,opt,name=read_only,json=readOnly,proto3,oneof"` +} + +func (*TransactionOptions_ReadWrite_) isTransactionOptions_Mode() {} + +func (*TransactionOptions_ReadOnly_) isTransactionOptions_Mode() {} + +func (m *TransactionOptions) GetMode() isTransactionOptions_Mode { + if m != nil { + return m.Mode + } + return nil +} + +func (m *TransactionOptions) GetReadWrite() *TransactionOptions_ReadWrite { + if x, ok := m.GetMode().(*TransactionOptions_ReadWrite_); ok { + return x.ReadWrite + } + return nil +} + +func (m *TransactionOptions) GetReadOnly() *TransactionOptions_ReadOnly { + if x, ok := m.GetMode().(*TransactionOptions_ReadOnly_); ok { + return x.ReadOnly + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TransactionOptions) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _TransactionOptions_OneofMarshaler, _TransactionOptions_OneofUnmarshaler, _TransactionOptions_OneofSizer, []interface{}{ + (*TransactionOptions_ReadWrite_)(nil), + (*TransactionOptions_ReadOnly_)(nil), + } +} + +func _TransactionOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadWrite); err != nil { + return err + } + case *TransactionOptions_ReadOnly_: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadOnly); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TransactionOptions.Mode has unexpected type %T", x) + } + return nil +} + +func _TransactionOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TransactionOptions) + switch tag { + case 1: // mode.read_write + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadWrite) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadWrite_{msg} + return true, err + case 2: // mode.read_only + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadOnly) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadOnly_{msg} + return true, err + default: + return false, nil + } +} + +func _TransactionOptions_OneofSizer(msg proto.Message) (n int) { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + s := proto.Size(x.ReadWrite) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *TransactionOptions_ReadOnly_: + s := proto.Size(x.ReadOnly) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Options specific to read / write transactions. +type TransactionOptions_ReadWrite struct { + // The transaction identifier of the transaction being retried. + PreviousTransaction []byte `protobuf:"bytes,1,opt,name=previous_transaction,json=previousTransaction,proto3" json:"previous_transaction,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TransactionOptions_ReadWrite) Reset() { *m = TransactionOptions_ReadWrite{} } +func (m *TransactionOptions_ReadWrite) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadWrite) ProtoMessage() {} +func (*TransactionOptions_ReadWrite) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{17, 0} +} +func (m *TransactionOptions_ReadWrite) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TransactionOptions_ReadWrite.Unmarshal(m, b) +} +func (m *TransactionOptions_ReadWrite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TransactionOptions_ReadWrite.Marshal(b, m, deterministic) +} +func (dst *TransactionOptions_ReadWrite) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionOptions_ReadWrite.Merge(dst, src) +} +func (m *TransactionOptions_ReadWrite) XXX_Size() int { + return xxx_messageInfo_TransactionOptions_ReadWrite.Size(m) +} +func (m *TransactionOptions_ReadWrite) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionOptions_ReadWrite.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionOptions_ReadWrite proto.InternalMessageInfo + +func (m *TransactionOptions_ReadWrite) GetPreviousTransaction() []byte { + if m != nil { + return m.PreviousTransaction + } + return nil +} + +// Options specific to read-only transactions. +type TransactionOptions_ReadOnly struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TransactionOptions_ReadOnly) Reset() { *m = TransactionOptions_ReadOnly{} } +func (m *TransactionOptions_ReadOnly) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadOnly) ProtoMessage() {} +func (*TransactionOptions_ReadOnly) Descriptor() ([]byte, []int) { + return fileDescriptor_datastore_8b950cadd2f2dedc, []int{17, 1} +} +func (m *TransactionOptions_ReadOnly) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TransactionOptions_ReadOnly.Unmarshal(m, b) +} +func (m *TransactionOptions_ReadOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TransactionOptions_ReadOnly.Marshal(b, m, deterministic) +} +func (dst *TransactionOptions_ReadOnly) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionOptions_ReadOnly.Merge(dst, src) +} +func (m *TransactionOptions_ReadOnly) XXX_Size() int { + return xxx_messageInfo_TransactionOptions_ReadOnly.Size(m) +} +func (m *TransactionOptions_ReadOnly) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionOptions_ReadOnly.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionOptions_ReadOnly proto.InternalMessageInfo + +func init() { + proto.RegisterType((*LookupRequest)(nil), "google.datastore.v1.LookupRequest") + proto.RegisterType((*LookupResponse)(nil), "google.datastore.v1.LookupResponse") + proto.RegisterType((*RunQueryRequest)(nil), "google.datastore.v1.RunQueryRequest") + proto.RegisterType((*RunQueryResponse)(nil), "google.datastore.v1.RunQueryResponse") + proto.RegisterType((*BeginTransactionRequest)(nil), "google.datastore.v1.BeginTransactionRequest") + proto.RegisterType((*BeginTransactionResponse)(nil), "google.datastore.v1.BeginTransactionResponse") + proto.RegisterType((*RollbackRequest)(nil), "google.datastore.v1.RollbackRequest") + proto.RegisterType((*RollbackResponse)(nil), "google.datastore.v1.RollbackResponse") + proto.RegisterType((*CommitRequest)(nil), "google.datastore.v1.CommitRequest") + proto.RegisterType((*CommitResponse)(nil), "google.datastore.v1.CommitResponse") + proto.RegisterType((*AllocateIdsRequest)(nil), "google.datastore.v1.AllocateIdsRequest") + proto.RegisterType((*AllocateIdsResponse)(nil), "google.datastore.v1.AllocateIdsResponse") + proto.RegisterType((*ReserveIdsRequest)(nil), "google.datastore.v1.ReserveIdsRequest") + proto.RegisterType((*ReserveIdsResponse)(nil), "google.datastore.v1.ReserveIdsResponse") + proto.RegisterType((*Mutation)(nil), "google.datastore.v1.Mutation") + proto.RegisterType((*MutationResult)(nil), "google.datastore.v1.MutationResult") + proto.RegisterType((*ReadOptions)(nil), "google.datastore.v1.ReadOptions") + proto.RegisterType((*TransactionOptions)(nil), "google.datastore.v1.TransactionOptions") + proto.RegisterType((*TransactionOptions_ReadWrite)(nil), "google.datastore.v1.TransactionOptions.ReadWrite") + proto.RegisterType((*TransactionOptions_ReadOnly)(nil), "google.datastore.v1.TransactionOptions.ReadOnly") + proto.RegisterEnum("google.datastore.v1.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value) + proto.RegisterEnum("google.datastore.v1.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value) +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// DatastoreClient is the client API for Datastore service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type DatastoreClient interface { + // Looks up entities by key. + Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error) + // Queries for entities. + RunQuery(ctx context.Context, in *RunQueryRequest, opts ...grpc.CallOption) (*RunQueryResponse, error) + // Begins a new transaction. + BeginTransaction(ctx context.Context, in *BeginTransactionRequest, opts ...grpc.CallOption) (*BeginTransactionResponse, error) + // Commits a transaction, optionally creating, deleting or modifying some + // entities. + Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) + // Rolls back a transaction. + Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error) + // Allocates IDs for the given keys, which is useful for referencing an entity + // before it is inserted. + AllocateIds(ctx context.Context, in *AllocateIdsRequest, opts ...grpc.CallOption) (*AllocateIdsResponse, error) + // Prevents the supplied keys' IDs from being auto-allocated by Cloud + // Datastore. + ReserveIds(ctx context.Context, in *ReserveIdsRequest, opts ...grpc.CallOption) (*ReserveIdsResponse, error) +} + +type datastoreClient struct { + cc *grpc.ClientConn +} + +func NewDatastoreClient(cc *grpc.ClientConn) DatastoreClient { + return &datastoreClient{cc} +} + +func (c *datastoreClient) Lookup(ctx context.Context, in *LookupRequest, opts ...grpc.CallOption) (*LookupResponse, error) { + out := new(LookupResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/Lookup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) RunQuery(ctx context.Context, in *RunQueryRequest, opts ...grpc.CallOption) (*RunQueryResponse, error) { + out := new(RunQueryResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/RunQuery", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) BeginTransaction(ctx context.Context, in *BeginTransactionRequest, opts ...grpc.CallOption) (*BeginTransactionResponse, error) { + out := new(BeginTransactionResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/BeginTransaction", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) { + out := new(CommitResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/Commit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error) { + out := new(RollbackResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/Rollback", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) AllocateIds(ctx context.Context, in *AllocateIdsRequest, opts ...grpc.CallOption) (*AllocateIdsResponse, error) { + out := new(AllocateIdsResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/AllocateIds", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreClient) ReserveIds(ctx context.Context, in *ReserveIdsRequest, opts ...grpc.CallOption) (*ReserveIdsResponse, error) { + out := new(ReserveIdsResponse) + err := c.cc.Invoke(ctx, "/google.datastore.v1.Datastore/ReserveIds", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DatastoreServer is the server API for Datastore service. +type DatastoreServer interface { + // Looks up entities by key. + Lookup(context.Context, *LookupRequest) (*LookupResponse, error) + // Queries for entities. + RunQuery(context.Context, *RunQueryRequest) (*RunQueryResponse, error) + // Begins a new transaction. + BeginTransaction(context.Context, *BeginTransactionRequest) (*BeginTransactionResponse, error) + // Commits a transaction, optionally creating, deleting or modifying some + // entities. + Commit(context.Context, *CommitRequest) (*CommitResponse, error) + // Rolls back a transaction. + Rollback(context.Context, *RollbackRequest) (*RollbackResponse, error) + // Allocates IDs for the given keys, which is useful for referencing an entity + // before it is inserted. + AllocateIds(context.Context, *AllocateIdsRequest) (*AllocateIdsResponse, error) + // Prevents the supplied keys' IDs from being auto-allocated by Cloud + // Datastore. + ReserveIds(context.Context, *ReserveIdsRequest) (*ReserveIdsResponse, error) +} + +func RegisterDatastoreServer(s *grpc.Server, srv DatastoreServer) { + s.RegisterService(&_Datastore_serviceDesc, srv) +} + +func _Datastore_Lookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LookupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).Lookup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/Lookup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).Lookup(ctx, req.(*LookupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_RunQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RunQueryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).RunQuery(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/RunQuery", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).RunQuery(ctx, req.(*RunQueryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_BeginTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BeginTransactionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).BeginTransaction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/BeginTransaction", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).BeginTransaction(ctx, req.(*BeginTransactionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CommitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).Commit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/Commit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).Commit(ctx, req.(*CommitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_Rollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RollbackRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).Rollback(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/Rollback", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).Rollback(ctx, req.(*RollbackRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_AllocateIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AllocateIdsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).AllocateIds(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/AllocateIds", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).AllocateIds(ctx, req.(*AllocateIdsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Datastore_ReserveIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReserveIdsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreServer).ReserveIds(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.v1.Datastore/ReserveIds", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreServer).ReserveIds(ctx, req.(*ReserveIdsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Datastore_serviceDesc = grpc.ServiceDesc{ + ServiceName: "google.datastore.v1.Datastore", + HandlerType: (*DatastoreServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Lookup", + Handler: _Datastore_Lookup_Handler, + }, + { + MethodName: "RunQuery", + Handler: _Datastore_RunQuery_Handler, + }, + { + MethodName: "BeginTransaction", + Handler: _Datastore_BeginTransaction_Handler, + }, + { + MethodName: "Commit", + Handler: _Datastore_Commit_Handler, + }, + { + MethodName: "Rollback", + Handler: _Datastore_Rollback_Handler, + }, + { + MethodName: "AllocateIds", + Handler: _Datastore_AllocateIds_Handler, + }, + { + MethodName: "ReserveIds", + Handler: _Datastore_ReserveIds_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "google/datastore/v1/datastore.proto", +} + +func init() { + proto.RegisterFile("google/datastore/v1/datastore.proto", fileDescriptor_datastore_8b950cadd2f2dedc) +} + +var fileDescriptor_datastore_8b950cadd2f2dedc = []byte{ + // 1390 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdf, 0x6f, 0x1b, 0xc5, + 0x13, 0xcf, 0x3a, 0x89, 0x63, 0x8f, 0xf3, 0xc3, 0xd9, 0xe4, 0xfb, 0xad, 0x71, 0x5b, 0xd5, 0x5c, + 0x1a, 0x1a, 0xd2, 0xd6, 0x4e, 0x0c, 0x15, 0x52, 0x53, 0x21, 0xc5, 0x8e, 0xdb, 0x58, 0x34, 0x76, + 0xd8, 0xa4, 0xe1, 0x87, 0x8a, 0xac, 0x8b, 0x6f, 0x6b, 0x8e, 0x9c, 0x6f, 0x2f, 0x77, 0xeb, 0x80, + 0x85, 0xa8, 0x54, 0x10, 0xbc, 0xc1, 0x43, 0xf9, 0x0b, 0xfa, 0xc2, 0x03, 0xe2, 0x91, 0x27, 0xc4, + 0x5f, 0xc0, 0x2b, 0xff, 0x02, 0x8f, 0xbc, 0xf1, 0x0f, 0xa0, 0xdb, 0xdb, 0xb3, 0x7d, 0xce, 0x5d, + 0xec, 0x48, 0xbc, 0x79, 0x67, 0xe7, 0x33, 0xf3, 0x99, 0x99, 0xbd, 0x99, 0x31, 0xac, 0xb4, 0x18, + 0x6b, 0x19, 0xb4, 0xa0, 0xa9, 0x5c, 0x75, 0x38, 0xb3, 0x69, 0xe1, 0x6c, 0xb3, 0x7f, 0xc8, 0x5b, + 0x36, 0xe3, 0x0c, 0x2f, 0x79, 0x4a, 0xf9, 0xbe, 0xfc, 0x6c, 0x33, 0x7b, 0x4d, 0x22, 0x55, 0x4b, + 0x2f, 0xa8, 0xa6, 0xc9, 0xb8, 0xca, 0x75, 0x66, 0x3a, 0x1e, 0x24, 0x9b, 0x0b, 0xb3, 0x4b, 0x4d, + 0xae, 0xf3, 0xae, 0xd4, 0xb8, 0x11, 0xa6, 0x71, 0xda, 0xa1, 0xb6, 0x54, 0x50, 0x5e, 0x21, 0x98, + 0x7b, 0xcc, 0xd8, 0x49, 0xc7, 0x22, 0xf4, 0xb4, 0x43, 0x1d, 0x8e, 0xaf, 0x03, 0x58, 0x36, 0xfb, + 0x8c, 0x36, 0x79, 0x43, 0xd7, 0x32, 0x89, 0x1c, 0x5a, 0x4b, 0x92, 0xa4, 0x94, 0x54, 0x35, 0x5c, + 0x86, 0x59, 0x9b, 0xaa, 0x5a, 0x83, 0x59, 0x82, 0x49, 0x06, 0xe5, 0xd0, 0x5a, 0xaa, 0x98, 0xcb, + 0x87, 0xb0, 0xcf, 0x13, 0xaa, 0x6a, 0x75, 0x4f, 0x8f, 0xa4, 0xec, 0xfe, 0x01, 0xdf, 0x81, 0xa9, + 0x13, 0xda, 0x75, 0x32, 0x93, 0xb9, 0xc9, 0xb5, 0x54, 0x31, 0x13, 0x0a, 0x7e, 0x8f, 0x76, 0x89, + 0xd0, 0x52, 0x7e, 0x47, 0x30, 0xef, 0x73, 0x74, 0x2c, 0x66, 0x3a, 0x14, 0xbf, 0x03, 0xd3, 0xcf, + 0x58, 0xc7, 0xd4, 0x32, 0x48, 0x58, 0x78, 0x3d, 0xd4, 0x42, 0x45, 0x64, 0x82, 0x50, 0xa7, 0x63, + 0x70, 0xe2, 0xe9, 0xe3, 0x2d, 0x98, 0x69, 0xeb, 0x8e, 0xa3, 0x9b, 0xad, 0x4c, 0x6c, 0x5c, 0xa8, + 0x8f, 0xc0, 0x6f, 0x43, 0x42, 0xa3, 0xcf, 0xa8, 0x6d, 0x53, 0x6d, 0x24, 0xf5, 0x9e, 0xa6, 0xf2, + 0x5b, 0x0c, 0x16, 0x48, 0xc7, 0x7c, 0xdf, 0xcd, 0xfa, 0xf8, 0x49, 0xb6, 0x54, 0x9b, 0xeb, 0x6e, + 0xb6, 0x5c, 0x85, 0xd8, 0x05, 0x49, 0xde, 0xf7, 0x15, 0xab, 0x1a, 0x49, 0x59, 0xfd, 0xc3, 0x7f, + 0x53, 0xa9, 0x22, 0x4c, 0x8b, 0xe7, 0x92, 0x99, 0x14, 0xe8, 0x6c, 0x28, 0x5a, 0x84, 0xb6, 0x3b, + 0x41, 0x3c, 0x55, 0xfc, 0x00, 0x92, 0xad, 0x53, 0xa3, 0xe1, 0xe1, 0x66, 0x04, 0xee, 0x7a, 0x28, + 0xee, 0xd1, 0xa9, 0xe1, 0x43, 0x13, 0x2d, 0xf9, 0xbb, 0x34, 0x0b, 0x20, 0x90, 0x0d, 0xde, 0xb5, + 0xa8, 0xf2, 0x02, 0x41, 0xba, 0x9f, 0x3c, 0x59, 0xfd, 0x2d, 0x98, 0x3e, 0x56, 0x79, 0xf3, 0x53, + 0x19, 0xd2, 0x6a, 0x34, 0x29, 0xaf, 0x82, 0x25, 0x57, 0x99, 0x78, 0x18, 0xbc, 0xe1, 0x47, 0x14, + 0x1b, 0x15, 0x91, 0x8c, 0x47, 0x79, 0x89, 0xe0, 0x4a, 0x89, 0xb6, 0x74, 0xf3, 0xd0, 0x56, 0x4d, + 0x47, 0x6d, 0xba, 0x99, 0x19, 0xb3, 0x90, 0x1f, 0xc2, 0x12, 0xef, 0x83, 0x7a, 0xa5, 0x00, 0xe1, + 0xfa, 0x56, 0xa8, 0xeb, 0x01, 0x27, 0x7e, 0x45, 0x30, 0x3f, 0x27, 0x53, 0x1e, 0x40, 0xe6, 0x3c, + 0x27, 0x99, 0x9f, 0x1c, 0xa4, 0x06, 0x10, 0x22, 0x4b, 0xb3, 0x64, 0x50, 0xa4, 0x10, 0x58, 0x20, + 0xcc, 0x30, 0x8e, 0xd5, 0xe6, 0xc9, 0x98, 0x91, 0x8c, 0xb6, 0x89, 0x21, 0xdd, 0xb7, 0xe9, 0x31, + 0x51, 0x7e, 0x89, 0xc1, 0x5c, 0x99, 0xb5, 0xdb, 0x3a, 0x1f, 0xd3, 0xcd, 0x16, 0x4c, 0xb5, 0x99, + 0x46, 0x33, 0xd3, 0x39, 0xb4, 0x36, 0x1f, 0x91, 0xa1, 0x80, 0xc1, 0xfc, 0x1e, 0xd3, 0x28, 0x11, + 0x20, 0xac, 0x84, 0x70, 0xdc, 0x9d, 0x08, 0xb0, 0xc4, 0x5b, 0x90, 0x6c, 0x77, 0x64, 0x1b, 0xcd, + 0xc4, 0xc5, 0x47, 0x1c, 0xfe, 0x38, 0xf7, 0xa4, 0x16, 0xe9, 0xeb, 0x2b, 0x0f, 0x61, 0xca, 0x75, + 0x87, 0x97, 0x21, 0xbd, 0x57, 0xdf, 0xa9, 0x34, 0x9e, 0xd4, 0x0e, 0xf6, 0x2b, 0xe5, 0xea, 0xc3, + 0x6a, 0x65, 0x27, 0x3d, 0x81, 0x17, 0x61, 0xee, 0x90, 0x6c, 0xd7, 0x0e, 0xb6, 0xcb, 0x87, 0xd5, + 0x7a, 0x6d, 0xfb, 0x71, 0x1a, 0xe1, 0xff, 0xc1, 0x62, 0xad, 0x5e, 0x6b, 0x04, 0xc5, 0xb1, 0xd2, + 0xff, 0x61, 0x79, 0xf0, 0x59, 0x38, 0xd4, 0xa0, 0x4d, 0xce, 0x6c, 0xe5, 0x5b, 0x04, 0xf3, 0x7e, + 0x74, 0xb2, 0x96, 0x35, 0x48, 0xfb, 0xfe, 0x1b, 0xb6, 0x78, 0xcd, 0x7e, 0xdb, 0x5c, 0xb9, 0x98, + 0xb6, 0xd7, 0xbb, 0x16, 0xda, 0x81, 0xb3, 0x83, 0x57, 0x60, 0x4e, 0x37, 0x35, 0xfa, 0x45, 0xa3, + 0x63, 0x69, 0x2a, 0xa7, 0x4e, 0x66, 0x2a, 0x87, 0xd6, 0xa6, 0xc9, 0xac, 0x10, 0x3e, 0xf1, 0x64, + 0x8a, 0x0a, 0x78, 0xdb, 0x30, 0x58, 0x53, 0xe5, 0xb4, 0xaa, 0x39, 0x63, 0x96, 0xce, 0x6f, 0xea, + 0x68, 0xac, 0xa6, 0x5e, 0x86, 0xa5, 0x80, 0x0b, 0x19, 0xee, 0xe5, 0x8c, 0xbc, 0x40, 0xb0, 0x48, + 0xa8, 0x43, 0xed, 0xb3, 0x4b, 0xf0, 0xbc, 0x01, 0x29, 0xd7, 0xdc, 0xb1, 0xea, 0x50, 0xf7, 0x3e, + 0x29, 0xee, 0xc1, 0x17, 0x5d, 0x3a, 0x90, 0x65, 0xc0, 0x83, 0x14, 0xe4, 0xc3, 0xff, 0x35, 0x06, + 0x09, 0xbf, 0x14, 0xf8, 0x1e, 0xc4, 0x75, 0xd3, 0xa1, 0x36, 0x17, 0xc9, 0x4e, 0x15, 0xaf, 0x5e, + 0x30, 0x73, 0x76, 0x27, 0x88, 0x54, 0x76, 0x61, 0x5e, 0x91, 0xc4, 0xd7, 0x30, 0x1a, 0xe6, 0x29, + 0x7b, 0x30, 0xe1, 0x2d, 0x3e, 0x26, 0x4c, 0x78, 0x2b, 0x42, 0x5c, 0xa3, 0x06, 0xe5, 0x54, 0xb6, + 0xec, 0xc8, 0xb8, 0x5d, 0x8c, 0xa7, 0x89, 0x57, 0x60, 0x56, 0xa4, 0xf1, 0x8c, 0xda, 0x8e, 0xfb, + 0xc5, 0xb9, 0xb9, 0x9e, 0xdc, 0x45, 0x24, 0xe5, 0x4a, 0x8f, 0x3c, 0x61, 0x29, 0x05, 0x49, 0x66, + 0x51, 0x5b, 0xa4, 0xa2, 0x74, 0x1d, 0xae, 0x36, 0x99, 0xf9, 0xcc, 0xd0, 0x9b, 0xbc, 0xa1, 0x51, + 0x4e, 0xe5, 0x07, 0xc0, 0x6d, 0x95, 0xd3, 0x56, 0x57, 0xf9, 0x06, 0xc1, 0x7c, 0xf0, 0x05, 0xe3, + 0x75, 0x98, 0x3c, 0xa1, 0xfe, 0xfc, 0x89, 0x2e, 0x86, 0xab, 0x84, 0x33, 0x30, 0xe3, 0x53, 0x71, + 0x33, 0x3d, 0x49, 0xfc, 0x23, 0xbe, 0x0d, 0x8b, 0x43, 0x7e, 0xa9, 0x26, 0xd2, 0x9a, 0x20, 0x69, + 0xff, 0x62, 0x47, 0xca, 0x95, 0x7f, 0x10, 0xa4, 0x06, 0x26, 0x22, 0xfe, 0x04, 0xd2, 0x62, 0x92, + 0x36, 0x99, 0xe9, 0xe8, 0x0e, 0xa7, 0x66, 0xb3, 0x2b, 0x9a, 0xcb, 0x7c, 0x71, 0x63, 0xd4, 0x34, + 0x15, 0xbf, 0xcb, 0x7d, 0xdc, 0xee, 0x04, 0x59, 0xb0, 0x83, 0xa2, 0xe1, 0xb6, 0x15, 0x0b, 0x69, + 0x5b, 0xca, 0x1e, 0x2c, 0x0c, 0x59, 0xc2, 0x39, 0xb8, 0x46, 0x2a, 0xdb, 0x3b, 0x8d, 0x72, 0xbd, + 0x76, 0x50, 0x3d, 0x38, 0xac, 0xd4, 0xca, 0x1f, 0x0d, 0x35, 0x24, 0x80, 0xf8, 0xc1, 0x21, 0xa9, + 0xd7, 0x1e, 0xa5, 0x11, 0x9e, 0x85, 0x44, 0xe5, 0xa8, 0x52, 0x3b, 0x7c, 0x22, 0x1a, 0x10, 0x86, + 0xf4, 0x40, 0x30, 0xde, 0xa8, 0xfd, 0x3e, 0x06, 0xf8, 0xfc, 0xf0, 0xc1, 0x04, 0x40, 0x04, 0xff, + 0xb9, 0xad, 0x73, 0x2a, 0x27, 0xee, 0xe6, 0x98, 0x93, 0x4b, 0x44, 0xff, 0x81, 0x0b, 0xdc, 0x9d, + 0x20, 0x49, 0xdb, 0x3f, 0xe0, 0x3a, 0x24, 0xbd, 0xd5, 0xc4, 0x34, 0xfc, 0x39, 0xbc, 0x71, 0x19, + 0x93, 0x75, 0xd3, 0x10, 0x4b, 0x83, 0x2d, 0x7f, 0x67, 0xdf, 0x85, 0x64, 0xcf, 0x15, 0xde, 0x84, + 0x65, 0xcb, 0xa6, 0x67, 0x3a, 0xeb, 0x38, 0x8d, 0xf3, 0x33, 0x6b, 0xc9, 0xbf, 0x1b, 0xb0, 0x9d, + 0x05, 0x48, 0xf8, 0x76, 0x4b, 0x71, 0x6f, 0x04, 0x15, 0xff, 0x9e, 0x81, 0xe4, 0x8e, 0x4f, 0x06, + 0x3f, 0x87, 0xb8, 0xb7, 0x83, 0x62, 0x25, 0x94, 0x69, 0x60, 0x89, 0xce, 0xae, 0x5c, 0xa8, 0x23, + 0x7b, 0xc4, 0xed, 0xaf, 0xff, 0xfc, 0xeb, 0xc7, 0xd8, 0xaa, 0x92, 0x73, 0x97, 0x72, 0xd9, 0x9f, + 0x9c, 0xc2, 0x97, 0xfd, 0xde, 0xf5, 0xd5, 0x7d, 0x43, 0x20, 0xee, 0xa3, 0x75, 0xfc, 0x1d, 0x82, + 0x84, 0xbf, 0x08, 0xe1, 0x9b, 0xe1, 0xcf, 0x2e, 0xb8, 0x64, 0x66, 0x57, 0x47, 0x68, 0x49, 0x1a, + 0x77, 0x05, 0x8d, 0x5b, 0x8a, 0x12, 0x4d, 0xc3, 0x96, 0x18, 0x97, 0xc8, 0x4f, 0x08, 0xd2, 0xc3, + 0x9b, 0x07, 0xbe, 0x13, 0xea, 0x2a, 0x62, 0x69, 0xca, 0xde, 0x1d, 0x53, 0x5b, 0x12, 0xbc, 0x27, + 0x08, 0x16, 0x94, 0xf5, 0x68, 0x82, 0xc7, 0x43, 0x58, 0x97, 0xe8, 0x73, 0x88, 0x7b, 0xb3, 0x34, + 0xa2, 0x62, 0x81, 0x35, 0x22, 0xa2, 0x62, 0xc1, 0x61, 0x3c, 0x4e, 0xc5, 0x9a, 0x02, 0xd1, 0xab, + 0x98, 0x5c, 0x88, 0xa2, 0x2a, 0x16, 0xdc, 0xc1, 0xa2, 0x2a, 0x36, 0xbc, 0x55, 0x8d, 0x53, 0x31, + 0x89, 0x71, 0x89, 0xbc, 0x44, 0x90, 0x1a, 0x98, 0xb5, 0x38, 0x7c, 0xab, 0x3a, 0x3f, 0xf0, 0xb3, + 0x6b, 0xa3, 0x15, 0x25, 0xa3, 0x0d, 0xc1, 0x68, 0x5d, 0x59, 0x8d, 0x66, 0xa4, 0xf6, 0x61, 0x2e, + 0xa9, 0x1f, 0x10, 0x40, 0x7f, 0x6e, 0xe2, 0x37, 0x22, 0x1a, 0xe9, 0xd0, 0x6c, 0xcf, 0xde, 0x1a, + 0xa9, 0x27, 0x19, 0x15, 0x04, 0xa3, 0x37, 0x95, 0x9b, 0x17, 0xe4, 0xa8, 0x87, 0xba, 0x8f, 0xd6, + 0x4b, 0xaf, 0x10, 0x5c, 0x69, 0xb2, 0x76, 0x98, 0xfd, 0xd2, 0x7c, 0xaf, 0x0f, 0xec, 0xbb, 0xff, + 0x9a, 0xf7, 0xd1, 0xc7, 0x0f, 0xa4, 0x5a, 0x8b, 0x19, 0xaa, 0xd9, 0xca, 0x33, 0xbb, 0x55, 0x68, + 0x51, 0x53, 0xfc, 0xa7, 0x2e, 0x78, 0x57, 0xaa, 0xa5, 0x3b, 0x81, 0xff, 0xdd, 0x5b, 0xbd, 0xc3, + 0xcf, 0xb1, 0xd7, 0x1e, 0x79, 0xf0, 0xb2, 0xc1, 0x3a, 0x5a, 0xbe, 0x67, 0x3d, 0x7f, 0xb4, 0xf9, + 0x87, 0x7f, 0xf7, 0x54, 0xdc, 0x3d, 0xed, 0xdd, 0x3d, 0x3d, 0xda, 0x3c, 0x8e, 0x0b, 0x07, 0x6f, + 0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x25, 0x27, 0xe9, 0x95, 0x51, 0x10, 0x00, 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1/entity.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1/entity.pb.go new file mode 100644 index 0000000..fc7c1ed --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1/entity.pb.go @@ -0,0 +1,927 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/datastore/v1/entity.proto + +package datastore // import "google.golang.org/genproto/googleapis/datastore/v1" + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _struct "github.com/golang/protobuf/ptypes/struct" +import timestamp "github.com/golang/protobuf/ptypes/timestamp" +import _ "google.golang.org/genproto/googleapis/api/annotations" +import latlng "google.golang.org/genproto/googleapis/type/latlng" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// A partition ID identifies a grouping of entities. The grouping is always +// by project and namespace, however the namespace ID may be empty. +// +// A partition ID contains several dimensions: +// project ID and namespace ID. +// +// Partition dimensions: +// +// - May be `""`. +// - Must be valid UTF-8 bytes. +// - Must have values that match regex `[A-Za-z\d\.\-_]{1,100}` +// If the value of any dimension matches regex `__.*__`, the partition is +// reserved/read-only. +// A reserved/read-only partition ID is forbidden in certain documented +// contexts. +// +// Foreign partition IDs (in which the project ID does +// not match the context project ID ) are discouraged. +// Reads and writes of foreign partition IDs may fail if the project is not in +// an active state. +type PartitionId struct { + // The ID of the project to which the entities belong. + ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` + // If not empty, the ID of the namespace to which the entities belong. + NamespaceId string `protobuf:"bytes,4,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PartitionId) Reset() { *m = PartitionId{} } +func (m *PartitionId) String() string { return proto.CompactTextString(m) } +func (*PartitionId) ProtoMessage() {} +func (*PartitionId) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{0} +} +func (m *PartitionId) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PartitionId.Unmarshal(m, b) +} +func (m *PartitionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PartitionId.Marshal(b, m, deterministic) +} +func (dst *PartitionId) XXX_Merge(src proto.Message) { + xxx_messageInfo_PartitionId.Merge(dst, src) +} +func (m *PartitionId) XXX_Size() int { + return xxx_messageInfo_PartitionId.Size(m) +} +func (m *PartitionId) XXX_DiscardUnknown() { + xxx_messageInfo_PartitionId.DiscardUnknown(m) +} + +var xxx_messageInfo_PartitionId proto.InternalMessageInfo + +func (m *PartitionId) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *PartitionId) GetNamespaceId() string { + if m != nil { + return m.NamespaceId + } + return "" +} + +// A unique identifier for an entity. +// If a key's partition ID or any of its path kinds or names are +// reserved/read-only, the key is reserved/read-only. +// A reserved/read-only key is forbidden in certain documented contexts. +type Key struct { + // Entities are partitioned into subsets, currently identified by a project + // ID and namespace ID. + // Queries are scoped to a single partition. + PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"` + // The entity path. + // An entity path consists of one or more elements composed of a kind and a + // string or numerical identifier, which identify entities. The first + // element identifies a _root entity_, the second element identifies + // a _child_ of the root entity, the third element identifies a child of the + // second entity, and so forth. The entities identified by all prefixes of + // the path are called the element's _ancestors_. + // + // An entity path is always fully complete: *all* of the entity's ancestors + // are required to be in the path along with the entity identifier itself. + // The only exception is that in some documented cases, the identifier in the + // last path element (for the entity) itself may be omitted. For example, + // the last path element of the key of `Mutation.insert` may have no + // identifier. + // + // A path can never be empty, and a path can have at most 100 elements. + Path []*Key_PathElement `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Key) Reset() { *m = Key{} } +func (m *Key) String() string { return proto.CompactTextString(m) } +func (*Key) ProtoMessage() {} +func (*Key) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{1} +} +func (m *Key) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Key.Unmarshal(m, b) +} +func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Key.Marshal(b, m, deterministic) +} +func (dst *Key) XXX_Merge(src proto.Message) { + xxx_messageInfo_Key.Merge(dst, src) +} +func (m *Key) XXX_Size() int { + return xxx_messageInfo_Key.Size(m) +} +func (m *Key) XXX_DiscardUnknown() { + xxx_messageInfo_Key.DiscardUnknown(m) +} + +var xxx_messageInfo_Key proto.InternalMessageInfo + +func (m *Key) GetPartitionId() *PartitionId { + if m != nil { + return m.PartitionId + } + return nil +} + +func (m *Key) GetPath() []*Key_PathElement { + if m != nil { + return m.Path + } + return nil +} + +// A (kind, ID/name) pair used to construct a key path. +// +// If either name or ID is set, the element is complete. +// If neither is set, the element is incomplete. +type Key_PathElement struct { + // The kind of the entity. + // A kind matching regex `__.*__` is reserved/read-only. + // A kind must not contain more than 1500 bytes when UTF-8 encoded. + // Cannot be `""`. + Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"` + // The type of ID. + // + // Types that are valid to be assigned to IdType: + // *Key_PathElement_Id + // *Key_PathElement_Name + IdType isKey_PathElement_IdType `protobuf_oneof:"id_type"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Key_PathElement) Reset() { *m = Key_PathElement{} } +func (m *Key_PathElement) String() string { return proto.CompactTextString(m) } +func (*Key_PathElement) ProtoMessage() {} +func (*Key_PathElement) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{1, 0} +} +func (m *Key_PathElement) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Key_PathElement.Unmarshal(m, b) +} +func (m *Key_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Key_PathElement.Marshal(b, m, deterministic) +} +func (dst *Key_PathElement) XXX_Merge(src proto.Message) { + xxx_messageInfo_Key_PathElement.Merge(dst, src) +} +func (m *Key_PathElement) XXX_Size() int { + return xxx_messageInfo_Key_PathElement.Size(m) +} +func (m *Key_PathElement) XXX_DiscardUnknown() { + xxx_messageInfo_Key_PathElement.DiscardUnknown(m) +} + +var xxx_messageInfo_Key_PathElement proto.InternalMessageInfo + +func (m *Key_PathElement) GetKind() string { + if m != nil { + return m.Kind + } + return "" +} + +type isKey_PathElement_IdType interface { + isKey_PathElement_IdType() +} + +type Key_PathElement_Id struct { + Id int64 `protobuf:"varint,2,opt,name=id,proto3,oneof"` +} + +type Key_PathElement_Name struct { + Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof"` +} + +func (*Key_PathElement_Id) isKey_PathElement_IdType() {} + +func (*Key_PathElement_Name) isKey_PathElement_IdType() {} + +func (m *Key_PathElement) GetIdType() isKey_PathElement_IdType { + if m != nil { + return m.IdType + } + return nil +} + +func (m *Key_PathElement) GetId() int64 { + if x, ok := m.GetIdType().(*Key_PathElement_Id); ok { + return x.Id + } + return 0 +} + +func (m *Key_PathElement) GetName() string { + if x, ok := m.GetIdType().(*Key_PathElement_Name); ok { + return x.Name + } + return "" +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Key_PathElement) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Key_PathElement_OneofMarshaler, _Key_PathElement_OneofUnmarshaler, _Key_PathElement_OneofSizer, []interface{}{ + (*Key_PathElement_Id)(nil), + (*Key_PathElement_Name)(nil), + } +} + +func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Key_PathElement) + // id_type + switch x := m.IdType.(type) { + case *Key_PathElement_Id: + b.EncodeVarint(2<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.Id)) + case *Key_PathElement_Name: + b.EncodeVarint(3<<3 | proto.WireBytes) + b.EncodeStringBytes(x.Name) + case nil: + default: + return fmt.Errorf("Key_PathElement.IdType has unexpected type %T", x) + } + return nil +} + +func _Key_PathElement_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Key_PathElement) + switch tag { + case 2: // id_type.id + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.IdType = &Key_PathElement_Id{int64(x)} + return true, err + case 3: // id_type.name + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.IdType = &Key_PathElement_Name{x} + return true, err + default: + return false, nil + } +} + +func _Key_PathElement_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Key_PathElement) + // id_type + switch x := m.IdType.(type) { + case *Key_PathElement_Id: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(x.Id)) + case *Key_PathElement_Name: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(len(x.Name))) + n += len(x.Name) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// An array value. +type ArrayValue struct { + // Values in the array. + // The order of this array may not be preserved if it contains a mix of + // indexed and unindexed values. + Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ArrayValue) Reset() { *m = ArrayValue{} } +func (m *ArrayValue) String() string { return proto.CompactTextString(m) } +func (*ArrayValue) ProtoMessage() {} +func (*ArrayValue) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{2} +} +func (m *ArrayValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ArrayValue.Unmarshal(m, b) +} +func (m *ArrayValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ArrayValue.Marshal(b, m, deterministic) +} +func (dst *ArrayValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArrayValue.Merge(dst, src) +} +func (m *ArrayValue) XXX_Size() int { + return xxx_messageInfo_ArrayValue.Size(m) +} +func (m *ArrayValue) XXX_DiscardUnknown() { + xxx_messageInfo_ArrayValue.DiscardUnknown(m) +} + +var xxx_messageInfo_ArrayValue proto.InternalMessageInfo + +func (m *ArrayValue) GetValues() []*Value { + if m != nil { + return m.Values + } + return nil +} + +// A message that can hold any of the supported value types and associated +// metadata. +type Value struct { + // Must have a value set. + // + // Types that are valid to be assigned to ValueType: + // *Value_NullValue + // *Value_BooleanValue + // *Value_IntegerValue + // *Value_DoubleValue + // *Value_TimestampValue + // *Value_KeyValue + // *Value_StringValue + // *Value_BlobValue + // *Value_GeoPointValue + // *Value_EntityValue + // *Value_ArrayValue + ValueType isValue_ValueType `protobuf_oneof:"value_type"` + // The `meaning` field should only be populated for backwards compatibility. + Meaning int32 `protobuf:"varint,14,opt,name=meaning,proto3" json:"meaning,omitempty"` + // If the value should be excluded from all indexes including those defined + // explicitly. + ExcludeFromIndexes bool `protobuf:"varint,19,opt,name=exclude_from_indexes,json=excludeFromIndexes,proto3" json:"exclude_from_indexes,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Value) Reset() { *m = Value{} } +func (m *Value) String() string { return proto.CompactTextString(m) } +func (*Value) ProtoMessage() {} +func (*Value) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{3} +} +func (m *Value) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Value.Unmarshal(m, b) +} +func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Value.Marshal(b, m, deterministic) +} +func (dst *Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_Value.Merge(dst, src) +} +func (m *Value) XXX_Size() int { + return xxx_messageInfo_Value.Size(m) +} +func (m *Value) XXX_DiscardUnknown() { + xxx_messageInfo_Value.DiscardUnknown(m) +} + +var xxx_messageInfo_Value proto.InternalMessageInfo + +type isValue_ValueType interface { + isValue_ValueType() +} + +type Value_NullValue struct { + NullValue _struct.NullValue `protobuf:"varint,11,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"` +} + +type Value_BooleanValue struct { + BooleanValue bool `protobuf:"varint,1,opt,name=boolean_value,json=booleanValue,proto3,oneof"` +} + +type Value_IntegerValue struct { + IntegerValue int64 `protobuf:"varint,2,opt,name=integer_value,json=integerValue,proto3,oneof"` +} + +type Value_DoubleValue struct { + DoubleValue float64 `protobuf:"fixed64,3,opt,name=double_value,json=doubleValue,proto3,oneof"` +} + +type Value_TimestampValue struct { + TimestampValue *timestamp.Timestamp `protobuf:"bytes,10,opt,name=timestamp_value,json=timestampValue,proto3,oneof"` +} + +type Value_KeyValue struct { + KeyValue *Key `protobuf:"bytes,5,opt,name=key_value,json=keyValue,proto3,oneof"` +} + +type Value_StringValue struct { + StringValue string `protobuf:"bytes,17,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type Value_BlobValue struct { + BlobValue []byte `protobuf:"bytes,18,opt,name=blob_value,json=blobValue,proto3,oneof"` +} + +type Value_GeoPointValue struct { + GeoPointValue *latlng.LatLng `protobuf:"bytes,8,opt,name=geo_point_value,json=geoPointValue,proto3,oneof"` +} + +type Value_EntityValue struct { + EntityValue *Entity `protobuf:"bytes,6,opt,name=entity_value,json=entityValue,proto3,oneof"` +} + +type Value_ArrayValue struct { + ArrayValue *ArrayValue `protobuf:"bytes,9,opt,name=array_value,json=arrayValue,proto3,oneof"` +} + +func (*Value_NullValue) isValue_ValueType() {} + +func (*Value_BooleanValue) isValue_ValueType() {} + +func (*Value_IntegerValue) isValue_ValueType() {} + +func (*Value_DoubleValue) isValue_ValueType() {} + +func (*Value_TimestampValue) isValue_ValueType() {} + +func (*Value_KeyValue) isValue_ValueType() {} + +func (*Value_StringValue) isValue_ValueType() {} + +func (*Value_BlobValue) isValue_ValueType() {} + +func (*Value_GeoPointValue) isValue_ValueType() {} + +func (*Value_EntityValue) isValue_ValueType() {} + +func (*Value_ArrayValue) isValue_ValueType() {} + +func (m *Value) GetValueType() isValue_ValueType { + if m != nil { + return m.ValueType + } + return nil +} + +func (m *Value) GetNullValue() _struct.NullValue { + if x, ok := m.GetValueType().(*Value_NullValue); ok { + return x.NullValue + } + return _struct.NullValue_NULL_VALUE +} + +func (m *Value) GetBooleanValue() bool { + if x, ok := m.GetValueType().(*Value_BooleanValue); ok { + return x.BooleanValue + } + return false +} + +func (m *Value) GetIntegerValue() int64 { + if x, ok := m.GetValueType().(*Value_IntegerValue); ok { + return x.IntegerValue + } + return 0 +} + +func (m *Value) GetDoubleValue() float64 { + if x, ok := m.GetValueType().(*Value_DoubleValue); ok { + return x.DoubleValue + } + return 0 +} + +func (m *Value) GetTimestampValue() *timestamp.Timestamp { + if x, ok := m.GetValueType().(*Value_TimestampValue); ok { + return x.TimestampValue + } + return nil +} + +func (m *Value) GetKeyValue() *Key { + if x, ok := m.GetValueType().(*Value_KeyValue); ok { + return x.KeyValue + } + return nil +} + +func (m *Value) GetStringValue() string { + if x, ok := m.GetValueType().(*Value_StringValue); ok { + return x.StringValue + } + return "" +} + +func (m *Value) GetBlobValue() []byte { + if x, ok := m.GetValueType().(*Value_BlobValue); ok { + return x.BlobValue + } + return nil +} + +func (m *Value) GetGeoPointValue() *latlng.LatLng { + if x, ok := m.GetValueType().(*Value_GeoPointValue); ok { + return x.GeoPointValue + } + return nil +} + +func (m *Value) GetEntityValue() *Entity { + if x, ok := m.GetValueType().(*Value_EntityValue); ok { + return x.EntityValue + } + return nil +} + +func (m *Value) GetArrayValue() *ArrayValue { + if x, ok := m.GetValueType().(*Value_ArrayValue); ok { + return x.ArrayValue + } + return nil +} + +func (m *Value) GetMeaning() int32 { + if m != nil { + return m.Meaning + } + return 0 +} + +func (m *Value) GetExcludeFromIndexes() bool { + if m != nil { + return m.ExcludeFromIndexes + } + return false +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{ + (*Value_NullValue)(nil), + (*Value_BooleanValue)(nil), + (*Value_IntegerValue)(nil), + (*Value_DoubleValue)(nil), + (*Value_TimestampValue)(nil), + (*Value_KeyValue)(nil), + (*Value_StringValue)(nil), + (*Value_BlobValue)(nil), + (*Value_GeoPointValue)(nil), + (*Value_EntityValue)(nil), + (*Value_ArrayValue)(nil), + } +} + +func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Value) + // value_type + switch x := m.ValueType.(type) { + case *Value_NullValue: + b.EncodeVarint(11<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.NullValue)) + case *Value_BooleanValue: + t := uint64(0) + if x.BooleanValue { + t = 1 + } + b.EncodeVarint(1<<3 | proto.WireVarint) + b.EncodeVarint(t) + case *Value_IntegerValue: + b.EncodeVarint(2<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.IntegerValue)) + case *Value_DoubleValue: + b.EncodeVarint(3<<3 | proto.WireFixed64) + b.EncodeFixed64(math.Float64bits(x.DoubleValue)) + case *Value_TimestampValue: + b.EncodeVarint(10<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.TimestampValue); err != nil { + return err + } + case *Value_KeyValue: + b.EncodeVarint(5<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.KeyValue); err != nil { + return err + } + case *Value_StringValue: + b.EncodeVarint(17<<3 | proto.WireBytes) + b.EncodeStringBytes(x.StringValue) + case *Value_BlobValue: + b.EncodeVarint(18<<3 | proto.WireBytes) + b.EncodeRawBytes(x.BlobValue) + case *Value_GeoPointValue: + b.EncodeVarint(8<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.GeoPointValue); err != nil { + return err + } + case *Value_EntityValue: + b.EncodeVarint(6<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.EntityValue); err != nil { + return err + } + case *Value_ArrayValue: + b.EncodeVarint(9<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ArrayValue); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Value.ValueType has unexpected type %T", x) + } + return nil +} + +func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Value) + switch tag { + case 11: // value_type.null_value + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.ValueType = &Value_NullValue{_struct.NullValue(x)} + return true, err + case 1: // value_type.boolean_value + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.ValueType = &Value_BooleanValue{x != 0} + return true, err + case 2: // value_type.integer_value + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.ValueType = &Value_IntegerValue{int64(x)} + return true, err + case 3: // value_type.double_value + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.ValueType = &Value_DoubleValue{math.Float64frombits(x)} + return true, err + case 10: // value_type.timestamp_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(timestamp.Timestamp) + err := b.DecodeMessage(msg) + m.ValueType = &Value_TimestampValue{msg} + return true, err + case 5: // value_type.key_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Key) + err := b.DecodeMessage(msg) + m.ValueType = &Value_KeyValue{msg} + return true, err + case 17: // value_type.string_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.ValueType = &Value_StringValue{x} + return true, err + case 18: // value_type.blob_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.ValueType = &Value_BlobValue{x} + return true, err + case 8: // value_type.geo_point_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(latlng.LatLng) + err := b.DecodeMessage(msg) + m.ValueType = &Value_GeoPointValue{msg} + return true, err + case 6: // value_type.entity_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Entity) + err := b.DecodeMessage(msg) + m.ValueType = &Value_EntityValue{msg} + return true, err + case 9: // value_type.array_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ArrayValue) + err := b.DecodeMessage(msg) + m.ValueType = &Value_ArrayValue{msg} + return true, err + default: + return false, nil + } +} + +func _Value_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Value) + // value_type + switch x := m.ValueType.(type) { + case *Value_NullValue: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(x.NullValue)) + case *Value_BooleanValue: + n += 1 // tag and wire + n += 1 + case *Value_IntegerValue: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(x.IntegerValue)) + case *Value_DoubleValue: + n += 1 // tag and wire + n += 8 + case *Value_TimestampValue: + s := proto.Size(x.TimestampValue) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_KeyValue: + s := proto.Size(x.KeyValue) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_StringValue: + n += 2 // tag and wire + n += proto.SizeVarint(uint64(len(x.StringValue))) + n += len(x.StringValue) + case *Value_BlobValue: + n += 2 // tag and wire + n += proto.SizeVarint(uint64(len(x.BlobValue))) + n += len(x.BlobValue) + case *Value_GeoPointValue: + s := proto.Size(x.GeoPointValue) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_EntityValue: + s := proto.Size(x.EntityValue) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_ArrayValue: + s := proto.Size(x.ArrayValue) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// A Datastore data object. +// +// An entity is limited to 1 megabyte when stored. That _roughly_ +// corresponds to a limit of 1 megabyte for the serialized form of this +// message. +type Entity struct { + // The entity's key. + // + // An entity must have a key, unless otherwise documented (for example, + // an entity in `Value.entity_value` may have no key). + // An entity's kind is its key path's last element's kind, + // or null if it has no key. + Key *Key `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // The entity's properties. + // The map's keys are property names. + // A property name matching regex `__.*__` is reserved. + // A reserved property name is forbidden in certain documented contexts. + // The name must not contain more than 500 characters. + // The name cannot be `""`. + Properties map[string]*Value `protobuf:"bytes,3,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Entity) Reset() { *m = Entity{} } +func (m *Entity) String() string { return proto.CompactTextString(m) } +func (*Entity) ProtoMessage() {} +func (*Entity) Descriptor() ([]byte, []int) { + return fileDescriptor_entity_096a297364b049a5, []int{4} +} +func (m *Entity) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Entity.Unmarshal(m, b) +} +func (m *Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Entity.Marshal(b, m, deterministic) +} +func (dst *Entity) XXX_Merge(src proto.Message) { + xxx_messageInfo_Entity.Merge(dst, src) +} +func (m *Entity) XXX_Size() int { + return xxx_messageInfo_Entity.Size(m) +} +func (m *Entity) XXX_DiscardUnknown() { + xxx_messageInfo_Entity.DiscardUnknown(m) +} + +var xxx_messageInfo_Entity proto.InternalMessageInfo + +func (m *Entity) GetKey() *Key { + if m != nil { + return m.Key + } + return nil +} + +func (m *Entity) GetProperties() map[string]*Value { + if m != nil { + return m.Properties + } + return nil +} + +func init() { + proto.RegisterType((*PartitionId)(nil), "google.datastore.v1.PartitionId") + proto.RegisterType((*Key)(nil), "google.datastore.v1.Key") + proto.RegisterType((*Key_PathElement)(nil), "google.datastore.v1.Key.PathElement") + proto.RegisterType((*ArrayValue)(nil), "google.datastore.v1.ArrayValue") + proto.RegisterType((*Value)(nil), "google.datastore.v1.Value") + proto.RegisterType((*Entity)(nil), "google.datastore.v1.Entity") + proto.RegisterMapType((map[string]*Value)(nil), "google.datastore.v1.Entity.PropertiesEntry") +} + +func init() { + proto.RegisterFile("google/datastore/v1/entity.proto", fileDescriptor_entity_096a297364b049a5) +} + +var fileDescriptor_entity_096a297364b049a5 = []byte{ + // 780 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x94, 0xff, 0x6e, 0xdc, 0x44, + 0x10, 0xc7, 0xed, 0xbb, 0x5c, 0x1a, 0x8f, 0xdd, 0xa4, 0x6c, 0x2a, 0x61, 0x02, 0x28, 0x26, 0x80, + 0x74, 0x02, 0xc9, 0x6e, 0xc2, 0x1f, 0x54, 0x14, 0xa4, 0x72, 0x25, 0xe0, 0x28, 0x15, 0x9c, 0x56, + 0x55, 0x24, 0x50, 0xa4, 0xd3, 0xde, 0x79, 0xeb, 0x2e, 0x67, 0xef, 0x5a, 0xf6, 0x3a, 0xaa, 0xdf, + 0x05, 0xf1, 0x00, 0x3c, 0x0a, 0x8f, 0x80, 0x78, 0x18, 0xb4, 0x3f, 0xec, 0x0b, 0xed, 0x35, 0xff, + 0x79, 0x67, 0x3e, 0xdf, 0xd9, 0xef, 0xec, 0xce, 0x1a, 0xa2, 0x5c, 0x88, 0xbc, 0xa0, 0x49, 0x46, + 0x24, 0x69, 0xa4, 0xa8, 0x69, 0x72, 0x73, 0x9a, 0x50, 0x2e, 0x99, 0xec, 0xe2, 0xaa, 0x16, 0x52, + 0xa0, 0x43, 0x43, 0xc4, 0x03, 0x11, 0xdf, 0x9c, 0x1e, 0x7d, 0x64, 0x65, 0xa4, 0x62, 0x09, 0xe1, + 0x5c, 0x48, 0x22, 0x99, 0xe0, 0x8d, 0x91, 0x0c, 0x59, 0xbd, 0x5a, 0xb6, 0x2f, 0x93, 0x46, 0xd6, + 0xed, 0x4a, 0xda, 0xec, 0xf1, 0x9b, 0x59, 0xc9, 0x4a, 0xda, 0x48, 0x52, 0x56, 0x16, 0x08, 0x2d, + 0x20, 0xbb, 0x8a, 0x26, 0x05, 0x91, 0x05, 0xcf, 0x4d, 0xe6, 0xe4, 0x17, 0xf0, 0xe7, 0xa4, 0x96, + 0x4c, 0x6d, 0x76, 0x91, 0xa1, 0x8f, 0x01, 0xaa, 0x5a, 0xfc, 0x4e, 0x57, 0x72, 0xc1, 0xb2, 0x70, + 0x14, 0xb9, 0x53, 0x0f, 0x7b, 0x36, 0x72, 0x91, 0xa1, 0x4f, 0x20, 0xe0, 0xa4, 0xa4, 0x4d, 0x45, + 0x56, 0x54, 0x01, 0x3b, 0x1a, 0xf0, 0x87, 0xd8, 0x45, 0x76, 0xf2, 0x8f, 0x0b, 0xe3, 0x4b, 0xda, + 0xa1, 0x67, 0x10, 0x54, 0x7d, 0x61, 0x85, 0xba, 0x91, 0x3b, 0xf5, 0xcf, 0xa2, 0x78, 0x4b, 0xef, + 0xf1, 0x2d, 0x07, 0xd8, 0xaf, 0x6e, 0xd9, 0x79, 0x0c, 0x3b, 0x15, 0x91, 0xaf, 0xc2, 0x51, 0x34, + 0x9e, 0xfa, 0x67, 0x9f, 0x6d, 0x15, 0x5f, 0xd2, 0x2e, 0x9e, 0x13, 0xf9, 0xea, 0xbc, 0xa0, 0x25, + 0xe5, 0x12, 0x6b, 0xc5, 0xd1, 0x0b, 0xd5, 0xd7, 0x10, 0x44, 0x08, 0x76, 0xd6, 0x8c, 0x1b, 0x17, + 0x1e, 0xd6, 0xdf, 0xe8, 0x01, 0x8c, 0x6c, 0x8f, 0xe3, 0xd4, 0xc1, 0x23, 0x96, 0xa1, 0x87, 0xb0, + 0xa3, 0x5a, 0x09, 0xc7, 0x8a, 0x4a, 0x1d, 0xac, 0x57, 0x33, 0x0f, 0xee, 0xb1, 0x6c, 0xa1, 0x8e, + 0xee, 0xe4, 0x29, 0xc0, 0xf7, 0x75, 0x4d, 0xba, 0x2b, 0x52, 0xb4, 0x14, 0x9d, 0xc1, 0xee, 0x8d, + 0xfa, 0x68, 0x42, 0x57, 0xfb, 0x3b, 0xda, 0xea, 0x4f, 0xb3, 0xd8, 0x92, 0x27, 0x7f, 0x4c, 0x60, + 0x62, 0xd4, 0x4f, 0x00, 0x78, 0x5b, 0x14, 0x0b, 0x9d, 0x08, 0xfd, 0xc8, 0x9d, 0xee, 0x6f, 0x2a, + 0xf4, 0x37, 0x19, 0xff, 0xdc, 0x16, 0x85, 0xe6, 0x53, 0x07, 0x7b, 0xbc, 0x5f, 0xa0, 0xcf, 0xe1, + 0xfe, 0x52, 0x88, 0x82, 0x12, 0x6e, 0xf5, 0xaa, 0xb1, 0xbd, 0xd4, 0xc1, 0x81, 0x0d, 0x0f, 0x18, + 0xe3, 0x92, 0xe6, 0xb4, 0xb6, 0x58, 0xdf, 0x6d, 0x60, 0xc3, 0x06, 0xfb, 0x14, 0x82, 0x4c, 0xb4, + 0xcb, 0x82, 0x5a, 0x4a, 0xf5, 0xef, 0xa6, 0x0e, 0xf6, 0x4d, 0xd4, 0x40, 0xe7, 0x70, 0x30, 0x8c, + 0x95, 0xe5, 0x40, 0xdf, 0xe9, 0xdb, 0xa6, 0x5f, 0xf4, 0x5c, 0xea, 0xe0, 0xfd, 0x41, 0x64, 0xca, + 0x7c, 0x0d, 0xde, 0x9a, 0x76, 0xb6, 0xc0, 0x44, 0x17, 0x08, 0xdf, 0x75, 0xaf, 0xa9, 0x83, 0xf7, + 0xd6, 0xb4, 0x1b, 0x4c, 0x36, 0xb2, 0x66, 0x3c, 0xb7, 0xda, 0xf7, 0xec, 0x25, 0xf9, 0x26, 0x6a, + 0xa0, 0x63, 0x80, 0x65, 0x21, 0x96, 0x16, 0x41, 0x91, 0x3b, 0x0d, 0xd4, 0xc1, 0xa9, 0x98, 0x01, + 0xbe, 0x83, 0x83, 0x9c, 0x8a, 0x45, 0x25, 0x18, 0x97, 0x96, 0xda, 0xd3, 0x26, 0x0e, 0x7b, 0x13, + 0xea, 0xa2, 0xe3, 0xe7, 0x44, 0x3e, 0xe7, 0x79, 0xea, 0xe0, 0xfb, 0x39, 0x15, 0x73, 0x05, 0x1b, + 0xf9, 0x53, 0x08, 0xcc, 0x53, 0xb6, 0xda, 0x5d, 0xad, 0xfd, 0x70, 0x6b, 0x03, 0xe7, 0x1a, 0x54, + 0x0e, 0x8d, 0xc4, 0x54, 0x98, 0x81, 0x4f, 0xd4, 0x08, 0xd9, 0x02, 0x9e, 0x2e, 0x70, 0xbc, 0xb5, + 0xc0, 0x66, 0xd4, 0x52, 0x07, 0x03, 0xd9, 0x0c, 0x5e, 0x08, 0xf7, 0x4a, 0x4a, 0x38, 0xe3, 0x79, + 0xb8, 0x1f, 0xb9, 0xd3, 0x09, 0xee, 0x97, 0xe8, 0x11, 0x3c, 0xa4, 0xaf, 0x57, 0x45, 0x9b, 0xd1, + 0xc5, 0xcb, 0x5a, 0x94, 0x0b, 0xc6, 0x33, 0xfa, 0x9a, 0x36, 0xe1, 0xa1, 0x1a, 0x0f, 0x8c, 0x6c, + 0xee, 0xc7, 0x5a, 0x94, 0x17, 0x26, 0x33, 0x0b, 0x00, 0xb4, 0x13, 0x33, 0xe0, 0xff, 0xba, 0xb0, + 0x6b, 0x7c, 0xa3, 0x2f, 0x60, 0xbc, 0xa6, 0x9d, 0x7d, 0xb7, 0xef, 0xbc, 0x22, 0xac, 0x20, 0x74, + 0xa9, 0x7f, 0x1b, 0x15, 0xad, 0x25, 0xa3, 0x4d, 0x38, 0xd6, 0xaf, 0xe1, 0xcb, 0x3b, 0x0e, 0x25, + 0x9e, 0x0f, 0xf4, 0x39, 0x97, 0x75, 0x87, 0x6f, 0xc9, 0x8f, 0x7e, 0x85, 0x83, 0x37, 0xd2, 0xe8, + 0xc1, 0xc6, 0x8b, 0x67, 0x76, 0x7c, 0x04, 0x93, 0xcd, 0x44, 0xdf, 0xfd, 0xf4, 0x0c, 0xf8, 0xcd, + 0xe8, 0xb1, 0x3b, 0xfb, 0xd3, 0x85, 0xf7, 0x57, 0xa2, 0xdc, 0x06, 0xcf, 0x7c, 0x63, 0x6d, 0xae, + 0x86, 0x78, 0xee, 0xfe, 0xf6, 0xad, 0x65, 0x72, 0x51, 0x10, 0x9e, 0xc7, 0xa2, 0xce, 0x93, 0x9c, + 0x72, 0x3d, 0xe2, 0x89, 0x49, 0x91, 0x8a, 0x35, 0xff, 0xfb, 0xcb, 0x3f, 0x19, 0x16, 0x7f, 0x8d, + 0x3e, 0xf8, 0xc9, 0xc8, 0x9f, 0x15, 0xa2, 0xcd, 0xe2, 0x1f, 0x86, 0x8d, 0xae, 0x4e, 0xff, 0xee, + 0x73, 0xd7, 0x3a, 0x77, 0x3d, 0xe4, 0xae, 0xaf, 0x4e, 0x97, 0xbb, 0x7a, 0x83, 0xaf, 0xfe, 0x0b, + 0x00, 0x00, 0xff, 0xff, 0xf3, 0xdd, 0x11, 0x96, 0x45, 0x06, 0x00, 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go new file mode 100644 index 0000000..1e39042 --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go @@ -0,0 +1,1258 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/datastore/v1/query.proto + +package datastore // import "google.golang.org/genproto/googleapis/datastore/v1" + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import wrappers "github.com/golang/protobuf/ptypes/wrappers" +import _ "google.golang.org/genproto/googleapis/api/annotations" +import _ "google.golang.org/genproto/googleapis/type/latlng" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// Specifies what data the 'entity' field contains. +// A `ResultType` is either implied (for example, in `LookupResponse.missing` +// from `datastore.proto`, it is always `KEY_ONLY`) or specified by context +// (for example, in message `QueryResultBatch`, field `entity_result_type` +// specifies a `ResultType` for all the values in field `entity_results`). +type EntityResult_ResultType int32 + +const ( + // Unspecified. This value is never used. + EntityResult_RESULT_TYPE_UNSPECIFIED EntityResult_ResultType = 0 + // The key and properties. + EntityResult_FULL EntityResult_ResultType = 1 + // A projected subset of properties. The entity may have no key. + EntityResult_PROJECTION EntityResult_ResultType = 2 + // Only the key. + EntityResult_KEY_ONLY EntityResult_ResultType = 3 +) + +var EntityResult_ResultType_name = map[int32]string{ + 0: "RESULT_TYPE_UNSPECIFIED", + 1: "FULL", + 2: "PROJECTION", + 3: "KEY_ONLY", +} +var EntityResult_ResultType_value = map[string]int32{ + "RESULT_TYPE_UNSPECIFIED": 0, + "FULL": 1, + "PROJECTION": 2, + "KEY_ONLY": 3, +} + +func (x EntityResult_ResultType) String() string { + return proto.EnumName(EntityResult_ResultType_name, int32(x)) +} +func (EntityResult_ResultType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{0, 0} +} + +// The sort direction. +type PropertyOrder_Direction int32 + +const ( + // Unspecified. This value must not be used. + PropertyOrder_DIRECTION_UNSPECIFIED PropertyOrder_Direction = 0 + // Ascending. + PropertyOrder_ASCENDING PropertyOrder_Direction = 1 + // Descending. + PropertyOrder_DESCENDING PropertyOrder_Direction = 2 +) + +var PropertyOrder_Direction_name = map[int32]string{ + 0: "DIRECTION_UNSPECIFIED", + 1: "ASCENDING", + 2: "DESCENDING", +} +var PropertyOrder_Direction_value = map[string]int32{ + "DIRECTION_UNSPECIFIED": 0, + "ASCENDING": 1, + "DESCENDING": 2, +} + +func (x PropertyOrder_Direction) String() string { + return proto.EnumName(PropertyOrder_Direction_name, int32(x)) +} +func (PropertyOrder_Direction) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{5, 0} +} + +// A composite filter operator. +type CompositeFilter_Operator int32 + +const ( + // Unspecified. This value must not be used. + CompositeFilter_OPERATOR_UNSPECIFIED CompositeFilter_Operator = 0 + // The results are required to satisfy each of the combined filters. + CompositeFilter_AND CompositeFilter_Operator = 1 +) + +var CompositeFilter_Operator_name = map[int32]string{ + 0: "OPERATOR_UNSPECIFIED", + 1: "AND", +} +var CompositeFilter_Operator_value = map[string]int32{ + "OPERATOR_UNSPECIFIED": 0, + "AND": 1, +} + +func (x CompositeFilter_Operator) String() string { + return proto.EnumName(CompositeFilter_Operator_name, int32(x)) +} +func (CompositeFilter_Operator) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{7, 0} +} + +// A property filter operator. +type PropertyFilter_Operator int32 + +const ( + // Unspecified. This value must not be used. + PropertyFilter_OPERATOR_UNSPECIFIED PropertyFilter_Operator = 0 + // Less than. + PropertyFilter_LESS_THAN PropertyFilter_Operator = 1 + // Less than or equal. + PropertyFilter_LESS_THAN_OR_EQUAL PropertyFilter_Operator = 2 + // Greater than. + PropertyFilter_GREATER_THAN PropertyFilter_Operator = 3 + // Greater than or equal. + PropertyFilter_GREATER_THAN_OR_EQUAL PropertyFilter_Operator = 4 + // Equal. + PropertyFilter_EQUAL PropertyFilter_Operator = 5 + // Has ancestor. + PropertyFilter_HAS_ANCESTOR PropertyFilter_Operator = 11 +) + +var PropertyFilter_Operator_name = map[int32]string{ + 0: "OPERATOR_UNSPECIFIED", + 1: "LESS_THAN", + 2: "LESS_THAN_OR_EQUAL", + 3: "GREATER_THAN", + 4: "GREATER_THAN_OR_EQUAL", + 5: "EQUAL", + 11: "HAS_ANCESTOR", +} +var PropertyFilter_Operator_value = map[string]int32{ + "OPERATOR_UNSPECIFIED": 0, + "LESS_THAN": 1, + "LESS_THAN_OR_EQUAL": 2, + "GREATER_THAN": 3, + "GREATER_THAN_OR_EQUAL": 4, + "EQUAL": 5, + "HAS_ANCESTOR": 11, +} + +func (x PropertyFilter_Operator) String() string { + return proto.EnumName(PropertyFilter_Operator_name, int32(x)) +} +func (PropertyFilter_Operator) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{8, 0} +} + +// The possible values for the `more_results` field. +type QueryResultBatch_MoreResultsType int32 + +const ( + // Unspecified. This value is never used. + QueryResultBatch_MORE_RESULTS_TYPE_UNSPECIFIED QueryResultBatch_MoreResultsType = 0 + // There may be additional batches to fetch from this query. + QueryResultBatch_NOT_FINISHED QueryResultBatch_MoreResultsType = 1 + // The query is finished, but there may be more results after the limit. + QueryResultBatch_MORE_RESULTS_AFTER_LIMIT QueryResultBatch_MoreResultsType = 2 + // The query is finished, but there may be more results after the end + // cursor. + QueryResultBatch_MORE_RESULTS_AFTER_CURSOR QueryResultBatch_MoreResultsType = 4 + // The query is finished, and there are no more results. + QueryResultBatch_NO_MORE_RESULTS QueryResultBatch_MoreResultsType = 3 +) + +var QueryResultBatch_MoreResultsType_name = map[int32]string{ + 0: "MORE_RESULTS_TYPE_UNSPECIFIED", + 1: "NOT_FINISHED", + 2: "MORE_RESULTS_AFTER_LIMIT", + 4: "MORE_RESULTS_AFTER_CURSOR", + 3: "NO_MORE_RESULTS", +} +var QueryResultBatch_MoreResultsType_value = map[string]int32{ + "MORE_RESULTS_TYPE_UNSPECIFIED": 0, + "NOT_FINISHED": 1, + "MORE_RESULTS_AFTER_LIMIT": 2, + "MORE_RESULTS_AFTER_CURSOR": 4, + "NO_MORE_RESULTS": 3, +} + +func (x QueryResultBatch_MoreResultsType) String() string { + return proto.EnumName(QueryResultBatch_MoreResultsType_name, int32(x)) +} +func (QueryResultBatch_MoreResultsType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{11, 0} +} + +// The result of fetching an entity from Datastore. +type EntityResult struct { + // The resulting entity. + Entity *Entity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + // The version of the entity, a strictly positive number that monotonically + // increases with changes to the entity. + // + // This field is set for + // [`FULL`][google.datastore.v1.EntityResult.ResultType.FULL] entity results. + // + // For [missing][google.datastore.v1.LookupResponse.missing] entities in + // `LookupResponse`, this is the version of the snapshot that was used to look + // up the entity, and it is always set except for eventually consistent reads. + Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` + // A cursor that points to the position after the result entity. + // Set only when the `EntityResult` is part of a `QueryResultBatch` message. + Cursor []byte `protobuf:"bytes,3,opt,name=cursor,proto3" json:"cursor,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EntityResult) Reset() { *m = EntityResult{} } +func (m *EntityResult) String() string { return proto.CompactTextString(m) } +func (*EntityResult) ProtoMessage() {} +func (*EntityResult) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{0} +} +func (m *EntityResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EntityResult.Unmarshal(m, b) +} +func (m *EntityResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EntityResult.Marshal(b, m, deterministic) +} +func (dst *EntityResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_EntityResult.Merge(dst, src) +} +func (m *EntityResult) XXX_Size() int { + return xxx_messageInfo_EntityResult.Size(m) +} +func (m *EntityResult) XXX_DiscardUnknown() { + xxx_messageInfo_EntityResult.DiscardUnknown(m) +} + +var xxx_messageInfo_EntityResult proto.InternalMessageInfo + +func (m *EntityResult) GetEntity() *Entity { + if m != nil { + return m.Entity + } + return nil +} + +func (m *EntityResult) GetVersion() int64 { + if m != nil { + return m.Version + } + return 0 +} + +func (m *EntityResult) GetCursor() []byte { + if m != nil { + return m.Cursor + } + return nil +} + +// A query for entities. +type Query struct { + // The projection to return. Defaults to returning all properties. + Projection []*Projection `protobuf:"bytes,2,rep,name=projection,proto3" json:"projection,omitempty"` + // The kinds to query (if empty, returns entities of all kinds). + // Currently at most 1 kind may be specified. + Kind []*KindExpression `protobuf:"bytes,3,rep,name=kind,proto3" json:"kind,omitempty"` + // The filter to apply. + Filter *Filter `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"` + // The order to apply to the query results (if empty, order is unspecified). + Order []*PropertyOrder `protobuf:"bytes,5,rep,name=order,proto3" json:"order,omitempty"` + // The properties to make distinct. The query results will contain the first + // result for each distinct combination of values for the given properties + // (if empty, all results are returned). + DistinctOn []*PropertyReference `protobuf:"bytes,6,rep,name=distinct_on,json=distinctOn,proto3" json:"distinct_on,omitempty"` + // A starting point for the query results. Query cursors are + // returned in query result batches and + // [can only be used to continue the same + // query](https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets). + StartCursor []byte `protobuf:"bytes,7,opt,name=start_cursor,json=startCursor,proto3" json:"start_cursor,omitempty"` + // An ending point for the query results. Query cursors are + // returned in query result batches and + // [can only be used to limit the same + // query](https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets). + EndCursor []byte `protobuf:"bytes,8,opt,name=end_cursor,json=endCursor,proto3" json:"end_cursor,omitempty"` + // The number of results to skip. Applies before limit, but after all other + // constraints. Optional. Must be >= 0 if specified. + Offset int32 `protobuf:"varint,10,opt,name=offset,proto3" json:"offset,omitempty"` + // The maximum number of results to return. Applies after all other + // constraints. Optional. + // Unspecified is interpreted as no limit. + // Must be >= 0 if specified. + Limit *wrappers.Int32Value `protobuf:"bytes,12,opt,name=limit,proto3" json:"limit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Query) Reset() { *m = Query{} } +func (m *Query) String() string { return proto.CompactTextString(m) } +func (*Query) ProtoMessage() {} +func (*Query) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{1} +} +func (m *Query) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Query.Unmarshal(m, b) +} +func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Query.Marshal(b, m, deterministic) +} +func (dst *Query) XXX_Merge(src proto.Message) { + xxx_messageInfo_Query.Merge(dst, src) +} +func (m *Query) XXX_Size() int { + return xxx_messageInfo_Query.Size(m) +} +func (m *Query) XXX_DiscardUnknown() { + xxx_messageInfo_Query.DiscardUnknown(m) +} + +var xxx_messageInfo_Query proto.InternalMessageInfo + +func (m *Query) GetProjection() []*Projection { + if m != nil { + return m.Projection + } + return nil +} + +func (m *Query) GetKind() []*KindExpression { + if m != nil { + return m.Kind + } + return nil +} + +func (m *Query) GetFilter() *Filter { + if m != nil { + return m.Filter + } + return nil +} + +func (m *Query) GetOrder() []*PropertyOrder { + if m != nil { + return m.Order + } + return nil +} + +func (m *Query) GetDistinctOn() []*PropertyReference { + if m != nil { + return m.DistinctOn + } + return nil +} + +func (m *Query) GetStartCursor() []byte { + if m != nil { + return m.StartCursor + } + return nil +} + +func (m *Query) GetEndCursor() []byte { + if m != nil { + return m.EndCursor + } + return nil +} + +func (m *Query) GetOffset() int32 { + if m != nil { + return m.Offset + } + return 0 +} + +func (m *Query) GetLimit() *wrappers.Int32Value { + if m != nil { + return m.Limit + } + return nil +} + +// A representation of a kind. +type KindExpression struct { + // The name of the kind. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KindExpression) Reset() { *m = KindExpression{} } +func (m *KindExpression) String() string { return proto.CompactTextString(m) } +func (*KindExpression) ProtoMessage() {} +func (*KindExpression) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{2} +} +func (m *KindExpression) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_KindExpression.Unmarshal(m, b) +} +func (m *KindExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_KindExpression.Marshal(b, m, deterministic) +} +func (dst *KindExpression) XXX_Merge(src proto.Message) { + xxx_messageInfo_KindExpression.Merge(dst, src) +} +func (m *KindExpression) XXX_Size() int { + return xxx_messageInfo_KindExpression.Size(m) +} +func (m *KindExpression) XXX_DiscardUnknown() { + xxx_messageInfo_KindExpression.DiscardUnknown(m) +} + +var xxx_messageInfo_KindExpression proto.InternalMessageInfo + +func (m *KindExpression) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +// A reference to a property relative to the kind expressions. +type PropertyReference struct { + // The name of the property. + // If name includes "."s, it may be interpreted as a property name path. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PropertyReference) Reset() { *m = PropertyReference{} } +func (m *PropertyReference) String() string { return proto.CompactTextString(m) } +func (*PropertyReference) ProtoMessage() {} +func (*PropertyReference) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{3} +} +func (m *PropertyReference) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PropertyReference.Unmarshal(m, b) +} +func (m *PropertyReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PropertyReference.Marshal(b, m, deterministic) +} +func (dst *PropertyReference) XXX_Merge(src proto.Message) { + xxx_messageInfo_PropertyReference.Merge(dst, src) +} +func (m *PropertyReference) XXX_Size() int { + return xxx_messageInfo_PropertyReference.Size(m) +} +func (m *PropertyReference) XXX_DiscardUnknown() { + xxx_messageInfo_PropertyReference.DiscardUnknown(m) +} + +var xxx_messageInfo_PropertyReference proto.InternalMessageInfo + +func (m *PropertyReference) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +// A representation of a property in a projection. +type Projection struct { + // The property to project. + Property *PropertyReference `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Projection) Reset() { *m = Projection{} } +func (m *Projection) String() string { return proto.CompactTextString(m) } +func (*Projection) ProtoMessage() {} +func (*Projection) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{4} +} +func (m *Projection) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Projection.Unmarshal(m, b) +} +func (m *Projection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Projection.Marshal(b, m, deterministic) +} +func (dst *Projection) XXX_Merge(src proto.Message) { + xxx_messageInfo_Projection.Merge(dst, src) +} +func (m *Projection) XXX_Size() int { + return xxx_messageInfo_Projection.Size(m) +} +func (m *Projection) XXX_DiscardUnknown() { + xxx_messageInfo_Projection.DiscardUnknown(m) +} + +var xxx_messageInfo_Projection proto.InternalMessageInfo + +func (m *Projection) GetProperty() *PropertyReference { + if m != nil { + return m.Property + } + return nil +} + +// The desired order for a specific property. +type PropertyOrder struct { + // The property to order by. + Property *PropertyReference `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"` + // The direction to order by. Defaults to `ASCENDING`. + Direction PropertyOrder_Direction `protobuf:"varint,2,opt,name=direction,proto3,enum=google.datastore.v1.PropertyOrder_Direction" json:"direction,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PropertyOrder) Reset() { *m = PropertyOrder{} } +func (m *PropertyOrder) String() string { return proto.CompactTextString(m) } +func (*PropertyOrder) ProtoMessage() {} +func (*PropertyOrder) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{5} +} +func (m *PropertyOrder) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PropertyOrder.Unmarshal(m, b) +} +func (m *PropertyOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PropertyOrder.Marshal(b, m, deterministic) +} +func (dst *PropertyOrder) XXX_Merge(src proto.Message) { + xxx_messageInfo_PropertyOrder.Merge(dst, src) +} +func (m *PropertyOrder) XXX_Size() int { + return xxx_messageInfo_PropertyOrder.Size(m) +} +func (m *PropertyOrder) XXX_DiscardUnknown() { + xxx_messageInfo_PropertyOrder.DiscardUnknown(m) +} + +var xxx_messageInfo_PropertyOrder proto.InternalMessageInfo + +func (m *PropertyOrder) GetProperty() *PropertyReference { + if m != nil { + return m.Property + } + return nil +} + +func (m *PropertyOrder) GetDirection() PropertyOrder_Direction { + if m != nil { + return m.Direction + } + return PropertyOrder_DIRECTION_UNSPECIFIED +} + +// A holder for any type of filter. +type Filter struct { + // The type of filter. + // + // Types that are valid to be assigned to FilterType: + // *Filter_CompositeFilter + // *Filter_PropertyFilter + FilterType isFilter_FilterType `protobuf_oneof:"filter_type"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Filter) Reset() { *m = Filter{} } +func (m *Filter) String() string { return proto.CompactTextString(m) } +func (*Filter) ProtoMessage() {} +func (*Filter) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{6} +} +func (m *Filter) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Filter.Unmarshal(m, b) +} +func (m *Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Filter.Marshal(b, m, deterministic) +} +func (dst *Filter) XXX_Merge(src proto.Message) { + xxx_messageInfo_Filter.Merge(dst, src) +} +func (m *Filter) XXX_Size() int { + return xxx_messageInfo_Filter.Size(m) +} +func (m *Filter) XXX_DiscardUnknown() { + xxx_messageInfo_Filter.DiscardUnknown(m) +} + +var xxx_messageInfo_Filter proto.InternalMessageInfo + +type isFilter_FilterType interface { + isFilter_FilterType() +} + +type Filter_CompositeFilter struct { + CompositeFilter *CompositeFilter `protobuf:"bytes,1,opt,name=composite_filter,json=compositeFilter,proto3,oneof"` +} + +type Filter_PropertyFilter struct { + PropertyFilter *PropertyFilter `protobuf:"bytes,2,opt,name=property_filter,json=propertyFilter,proto3,oneof"` +} + +func (*Filter_CompositeFilter) isFilter_FilterType() {} + +func (*Filter_PropertyFilter) isFilter_FilterType() {} + +func (m *Filter) GetFilterType() isFilter_FilterType { + if m != nil { + return m.FilterType + } + return nil +} + +func (m *Filter) GetCompositeFilter() *CompositeFilter { + if x, ok := m.GetFilterType().(*Filter_CompositeFilter); ok { + return x.CompositeFilter + } + return nil +} + +func (m *Filter) GetPropertyFilter() *PropertyFilter { + if x, ok := m.GetFilterType().(*Filter_PropertyFilter); ok { + return x.PropertyFilter + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Filter) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Filter_OneofMarshaler, _Filter_OneofUnmarshaler, _Filter_OneofSizer, []interface{}{ + (*Filter_CompositeFilter)(nil), + (*Filter_PropertyFilter)(nil), + } +} + +func _Filter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Filter) + // filter_type + switch x := m.FilterType.(type) { + case *Filter_CompositeFilter: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.CompositeFilter); err != nil { + return err + } + case *Filter_PropertyFilter: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.PropertyFilter); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Filter.FilterType has unexpected type %T", x) + } + return nil +} + +func _Filter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Filter) + switch tag { + case 1: // filter_type.composite_filter + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(CompositeFilter) + err := b.DecodeMessage(msg) + m.FilterType = &Filter_CompositeFilter{msg} + return true, err + case 2: // filter_type.property_filter + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(PropertyFilter) + err := b.DecodeMessage(msg) + m.FilterType = &Filter_PropertyFilter{msg} + return true, err + default: + return false, nil + } +} + +func _Filter_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Filter) + // filter_type + switch x := m.FilterType.(type) { + case *Filter_CompositeFilter: + s := proto.Size(x.CompositeFilter) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *Filter_PropertyFilter: + s := proto.Size(x.PropertyFilter) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// A filter that merges multiple other filters using the given operator. +type CompositeFilter struct { + // The operator for combining multiple filters. + Op CompositeFilter_Operator `protobuf:"varint,1,opt,name=op,proto3,enum=google.datastore.v1.CompositeFilter_Operator" json:"op,omitempty"` + // The list of filters to combine. + // Must contain at least one filter. + Filters []*Filter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CompositeFilter) Reset() { *m = CompositeFilter{} } +func (m *CompositeFilter) String() string { return proto.CompactTextString(m) } +func (*CompositeFilter) ProtoMessage() {} +func (*CompositeFilter) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{7} +} +func (m *CompositeFilter) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CompositeFilter.Unmarshal(m, b) +} +func (m *CompositeFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CompositeFilter.Marshal(b, m, deterministic) +} +func (dst *CompositeFilter) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompositeFilter.Merge(dst, src) +} +func (m *CompositeFilter) XXX_Size() int { + return xxx_messageInfo_CompositeFilter.Size(m) +} +func (m *CompositeFilter) XXX_DiscardUnknown() { + xxx_messageInfo_CompositeFilter.DiscardUnknown(m) +} + +var xxx_messageInfo_CompositeFilter proto.InternalMessageInfo + +func (m *CompositeFilter) GetOp() CompositeFilter_Operator { + if m != nil { + return m.Op + } + return CompositeFilter_OPERATOR_UNSPECIFIED +} + +func (m *CompositeFilter) GetFilters() []*Filter { + if m != nil { + return m.Filters + } + return nil +} + +// A filter on a specific property. +type PropertyFilter struct { + // The property to filter by. + Property *PropertyReference `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"` + // The operator to filter by. + Op PropertyFilter_Operator `protobuf:"varint,2,opt,name=op,proto3,enum=google.datastore.v1.PropertyFilter_Operator" json:"op,omitempty"` + // The value to compare the property to. + Value *Value `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PropertyFilter) Reset() { *m = PropertyFilter{} } +func (m *PropertyFilter) String() string { return proto.CompactTextString(m) } +func (*PropertyFilter) ProtoMessage() {} +func (*PropertyFilter) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{8} +} +func (m *PropertyFilter) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PropertyFilter.Unmarshal(m, b) +} +func (m *PropertyFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PropertyFilter.Marshal(b, m, deterministic) +} +func (dst *PropertyFilter) XXX_Merge(src proto.Message) { + xxx_messageInfo_PropertyFilter.Merge(dst, src) +} +func (m *PropertyFilter) XXX_Size() int { + return xxx_messageInfo_PropertyFilter.Size(m) +} +func (m *PropertyFilter) XXX_DiscardUnknown() { + xxx_messageInfo_PropertyFilter.DiscardUnknown(m) +} + +var xxx_messageInfo_PropertyFilter proto.InternalMessageInfo + +func (m *PropertyFilter) GetProperty() *PropertyReference { + if m != nil { + return m.Property + } + return nil +} + +func (m *PropertyFilter) GetOp() PropertyFilter_Operator { + if m != nil { + return m.Op + } + return PropertyFilter_OPERATOR_UNSPECIFIED +} + +func (m *PropertyFilter) GetValue() *Value { + if m != nil { + return m.Value + } + return nil +} + +// A [GQL +// query](https://cloud.google.com/datastore/docs/apis/gql/gql_reference). +type GqlQuery struct { + // A string of the format described + // [here](https://cloud.google.com/datastore/docs/apis/gql/gql_reference). + QueryString string `protobuf:"bytes,1,opt,name=query_string,json=queryString,proto3" json:"query_string,omitempty"` + // When false, the query string must not contain any literals and instead must + // bind all values. For example, + // `SELECT * FROM Kind WHERE a = 'string literal'` is not allowed, while + // `SELECT * FROM Kind WHERE a = @value` is. + AllowLiterals bool `protobuf:"varint,2,opt,name=allow_literals,json=allowLiterals,proto3" json:"allow_literals,omitempty"` + // For each non-reserved named binding site in the query string, there must be + // a named parameter with that name, but not necessarily the inverse. + // + // Key must match regex `[A-Za-z_$][A-Za-z_$0-9]*`, must not match regex + // `__.*__`, and must not be `""`. + NamedBindings map[string]*GqlQueryParameter `protobuf:"bytes,5,rep,name=named_bindings,json=namedBindings,proto3" json:"named_bindings,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Numbered binding site @1 references the first numbered parameter, + // effectively using 1-based indexing, rather than the usual 0. + // + // For each binding site numbered i in `query_string`, there must be an i-th + // numbered parameter. The inverse must also be true. + PositionalBindings []*GqlQueryParameter `protobuf:"bytes,4,rep,name=positional_bindings,json=positionalBindings,proto3" json:"positional_bindings,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GqlQuery) Reset() { *m = GqlQuery{} } +func (m *GqlQuery) String() string { return proto.CompactTextString(m) } +func (*GqlQuery) ProtoMessage() {} +func (*GqlQuery) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{9} +} +func (m *GqlQuery) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GqlQuery.Unmarshal(m, b) +} +func (m *GqlQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GqlQuery.Marshal(b, m, deterministic) +} +func (dst *GqlQuery) XXX_Merge(src proto.Message) { + xxx_messageInfo_GqlQuery.Merge(dst, src) +} +func (m *GqlQuery) XXX_Size() int { + return xxx_messageInfo_GqlQuery.Size(m) +} +func (m *GqlQuery) XXX_DiscardUnknown() { + xxx_messageInfo_GqlQuery.DiscardUnknown(m) +} + +var xxx_messageInfo_GqlQuery proto.InternalMessageInfo + +func (m *GqlQuery) GetQueryString() string { + if m != nil { + return m.QueryString + } + return "" +} + +func (m *GqlQuery) GetAllowLiterals() bool { + if m != nil { + return m.AllowLiterals + } + return false +} + +func (m *GqlQuery) GetNamedBindings() map[string]*GqlQueryParameter { + if m != nil { + return m.NamedBindings + } + return nil +} + +func (m *GqlQuery) GetPositionalBindings() []*GqlQueryParameter { + if m != nil { + return m.PositionalBindings + } + return nil +} + +// A binding parameter for a GQL query. +type GqlQueryParameter struct { + // The type of parameter. + // + // Types that are valid to be assigned to ParameterType: + // *GqlQueryParameter_Value + // *GqlQueryParameter_Cursor + ParameterType isGqlQueryParameter_ParameterType `protobuf_oneof:"parameter_type"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GqlQueryParameter) Reset() { *m = GqlQueryParameter{} } +func (m *GqlQueryParameter) String() string { return proto.CompactTextString(m) } +func (*GqlQueryParameter) ProtoMessage() {} +func (*GqlQueryParameter) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{10} +} +func (m *GqlQueryParameter) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GqlQueryParameter.Unmarshal(m, b) +} +func (m *GqlQueryParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GqlQueryParameter.Marshal(b, m, deterministic) +} +func (dst *GqlQueryParameter) XXX_Merge(src proto.Message) { + xxx_messageInfo_GqlQueryParameter.Merge(dst, src) +} +func (m *GqlQueryParameter) XXX_Size() int { + return xxx_messageInfo_GqlQueryParameter.Size(m) +} +func (m *GqlQueryParameter) XXX_DiscardUnknown() { + xxx_messageInfo_GqlQueryParameter.DiscardUnknown(m) +} + +var xxx_messageInfo_GqlQueryParameter proto.InternalMessageInfo + +type isGqlQueryParameter_ParameterType interface { + isGqlQueryParameter_ParameterType() +} + +type GqlQueryParameter_Value struct { + Value *Value `protobuf:"bytes,2,opt,name=value,proto3,oneof"` +} + +type GqlQueryParameter_Cursor struct { + Cursor []byte `protobuf:"bytes,3,opt,name=cursor,proto3,oneof"` +} + +func (*GqlQueryParameter_Value) isGqlQueryParameter_ParameterType() {} + +func (*GqlQueryParameter_Cursor) isGqlQueryParameter_ParameterType() {} + +func (m *GqlQueryParameter) GetParameterType() isGqlQueryParameter_ParameterType { + if m != nil { + return m.ParameterType + } + return nil +} + +func (m *GqlQueryParameter) GetValue() *Value { + if x, ok := m.GetParameterType().(*GqlQueryParameter_Value); ok { + return x.Value + } + return nil +} + +func (m *GqlQueryParameter) GetCursor() []byte { + if x, ok := m.GetParameterType().(*GqlQueryParameter_Cursor); ok { + return x.Cursor + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*GqlQueryParameter) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _GqlQueryParameter_OneofMarshaler, _GqlQueryParameter_OneofUnmarshaler, _GqlQueryParameter_OneofSizer, []interface{}{ + (*GqlQueryParameter_Value)(nil), + (*GqlQueryParameter_Cursor)(nil), + } +} + +func _GqlQueryParameter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*GqlQueryParameter) + // parameter_type + switch x := m.ParameterType.(type) { + case *GqlQueryParameter_Value: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Value); err != nil { + return err + } + case *GqlQueryParameter_Cursor: + b.EncodeVarint(3<<3 | proto.WireBytes) + b.EncodeRawBytes(x.Cursor) + case nil: + default: + return fmt.Errorf("GqlQueryParameter.ParameterType has unexpected type %T", x) + } + return nil +} + +func _GqlQueryParameter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*GqlQueryParameter) + switch tag { + case 2: // parameter_type.value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Value) + err := b.DecodeMessage(msg) + m.ParameterType = &GqlQueryParameter_Value{msg} + return true, err + case 3: // parameter_type.cursor + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.ParameterType = &GqlQueryParameter_Cursor{x} + return true, err + default: + return false, nil + } +} + +func _GqlQueryParameter_OneofSizer(msg proto.Message) (n int) { + m := msg.(*GqlQueryParameter) + // parameter_type + switch x := m.ParameterType.(type) { + case *GqlQueryParameter_Value: + s := proto.Size(x.Value) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *GqlQueryParameter_Cursor: + n += 1 // tag and wire + n += proto.SizeVarint(uint64(len(x.Cursor))) + n += len(x.Cursor) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// A batch of results produced by a query. +type QueryResultBatch struct { + // The number of results skipped, typically because of an offset. + SkippedResults int32 `protobuf:"varint,6,opt,name=skipped_results,json=skippedResults,proto3" json:"skipped_results,omitempty"` + // A cursor that points to the position after the last skipped result. + // Will be set when `skipped_results` != 0. + SkippedCursor []byte `protobuf:"bytes,3,opt,name=skipped_cursor,json=skippedCursor,proto3" json:"skipped_cursor,omitempty"` + // The result type for every entity in `entity_results`. + EntityResultType EntityResult_ResultType `protobuf:"varint,1,opt,name=entity_result_type,json=entityResultType,proto3,enum=google.datastore.v1.EntityResult_ResultType" json:"entity_result_type,omitempty"` + // The results for this batch. + EntityResults []*EntityResult `protobuf:"bytes,2,rep,name=entity_results,json=entityResults,proto3" json:"entity_results,omitempty"` + // A cursor that points to the position after the last result in the batch. + EndCursor []byte `protobuf:"bytes,4,opt,name=end_cursor,json=endCursor,proto3" json:"end_cursor,omitempty"` + // The state of the query after the current batch. + MoreResults QueryResultBatch_MoreResultsType `protobuf:"varint,5,opt,name=more_results,json=moreResults,proto3,enum=google.datastore.v1.QueryResultBatch_MoreResultsType" json:"more_results,omitempty"` + // The version number of the snapshot this batch was returned from. + // This applies to the range of results from the query's `start_cursor` (or + // the beginning of the query if no cursor was given) to this batch's + // `end_cursor` (not the query's `end_cursor`). + // + // In a single transaction, subsequent query result batches for the same query + // can have a greater snapshot version number. Each batch's snapshot version + // is valid for all preceding batches. + // The value will be zero for eventually consistent queries. + SnapshotVersion int64 `protobuf:"varint,7,opt,name=snapshot_version,json=snapshotVersion,proto3" json:"snapshot_version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryResultBatch) Reset() { *m = QueryResultBatch{} } +func (m *QueryResultBatch) String() string { return proto.CompactTextString(m) } +func (*QueryResultBatch) ProtoMessage() {} +func (*QueryResultBatch) Descriptor() ([]byte, []int) { + return fileDescriptor_query_469190755d01ba40, []int{11} +} +func (m *QueryResultBatch) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryResultBatch.Unmarshal(m, b) +} +func (m *QueryResultBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryResultBatch.Marshal(b, m, deterministic) +} +func (dst *QueryResultBatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryResultBatch.Merge(dst, src) +} +func (m *QueryResultBatch) XXX_Size() int { + return xxx_messageInfo_QueryResultBatch.Size(m) +} +func (m *QueryResultBatch) XXX_DiscardUnknown() { + xxx_messageInfo_QueryResultBatch.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryResultBatch proto.InternalMessageInfo + +func (m *QueryResultBatch) GetSkippedResults() int32 { + if m != nil { + return m.SkippedResults + } + return 0 +} + +func (m *QueryResultBatch) GetSkippedCursor() []byte { + if m != nil { + return m.SkippedCursor + } + return nil +} + +func (m *QueryResultBatch) GetEntityResultType() EntityResult_ResultType { + if m != nil { + return m.EntityResultType + } + return EntityResult_RESULT_TYPE_UNSPECIFIED +} + +func (m *QueryResultBatch) GetEntityResults() []*EntityResult { + if m != nil { + return m.EntityResults + } + return nil +} + +func (m *QueryResultBatch) GetEndCursor() []byte { + if m != nil { + return m.EndCursor + } + return nil +} + +func (m *QueryResultBatch) GetMoreResults() QueryResultBatch_MoreResultsType { + if m != nil { + return m.MoreResults + } + return QueryResultBatch_MORE_RESULTS_TYPE_UNSPECIFIED +} + +func (m *QueryResultBatch) GetSnapshotVersion() int64 { + if m != nil { + return m.SnapshotVersion + } + return 0 +} + +func init() { + proto.RegisterType((*EntityResult)(nil), "google.datastore.v1.EntityResult") + proto.RegisterType((*Query)(nil), "google.datastore.v1.Query") + proto.RegisterType((*KindExpression)(nil), "google.datastore.v1.KindExpression") + proto.RegisterType((*PropertyReference)(nil), "google.datastore.v1.PropertyReference") + proto.RegisterType((*Projection)(nil), "google.datastore.v1.Projection") + proto.RegisterType((*PropertyOrder)(nil), "google.datastore.v1.PropertyOrder") + proto.RegisterType((*Filter)(nil), "google.datastore.v1.Filter") + proto.RegisterType((*CompositeFilter)(nil), "google.datastore.v1.CompositeFilter") + proto.RegisterType((*PropertyFilter)(nil), "google.datastore.v1.PropertyFilter") + proto.RegisterType((*GqlQuery)(nil), "google.datastore.v1.GqlQuery") + proto.RegisterMapType((map[string]*GqlQueryParameter)(nil), "google.datastore.v1.GqlQuery.NamedBindingsEntry") + proto.RegisterType((*GqlQueryParameter)(nil), "google.datastore.v1.GqlQueryParameter") + proto.RegisterType((*QueryResultBatch)(nil), "google.datastore.v1.QueryResultBatch") + proto.RegisterEnum("google.datastore.v1.EntityResult_ResultType", EntityResult_ResultType_name, EntityResult_ResultType_value) + proto.RegisterEnum("google.datastore.v1.PropertyOrder_Direction", PropertyOrder_Direction_name, PropertyOrder_Direction_value) + proto.RegisterEnum("google.datastore.v1.CompositeFilter_Operator", CompositeFilter_Operator_name, CompositeFilter_Operator_value) + proto.RegisterEnum("google.datastore.v1.PropertyFilter_Operator", PropertyFilter_Operator_name, PropertyFilter_Operator_value) + proto.RegisterEnum("google.datastore.v1.QueryResultBatch_MoreResultsType", QueryResultBatch_MoreResultsType_name, QueryResultBatch_MoreResultsType_value) +} + +func init() { + proto.RegisterFile("google/datastore/v1/query.proto", fileDescriptor_query_469190755d01ba40) +} + +var fileDescriptor_query_469190755d01ba40 = []byte{ + // 1313 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x72, 0xd3, 0x46, + 0x14, 0x8e, 0x64, 0x3b, 0x89, 0x8f, 0xff, 0xc4, 0xd2, 0x82, 0x08, 0x50, 0x12, 0x41, 0x4b, 0x3a, + 0x03, 0x36, 0x31, 0xc3, 0x94, 0x69, 0xe9, 0x74, 0xfc, 0xa3, 0xc4, 0x06, 0x63, 0x39, 0x6b, 0x27, + 0x14, 0x86, 0x19, 0x8d, 0xb0, 0x37, 0x46, 0x45, 0x96, 0xc4, 0x4a, 0x09, 0xcd, 0x83, 0x74, 0xa6, + 0x37, 0x7d, 0x81, 0x3e, 0x40, 0x2f, 0xfa, 0x00, 0x6d, 0xa7, 0xcf, 0xd0, 0xeb, 0x5e, 0xf7, 0x11, + 0x3a, 0xda, 0x5d, 0xf9, 0x2f, 0xc6, 0xe4, 0x82, 0x3b, 0xed, 0xd9, 0xef, 0xfb, 0xce, 0x9e, 0xb3, + 0x67, 0x8f, 0x0e, 0xdc, 0x18, 0x7a, 0xde, 0xd0, 0x21, 0xa5, 0x81, 0x15, 0x5a, 0x41, 0xe8, 0x51, + 0x52, 0x3a, 0xd9, 0x29, 0xbd, 0x3d, 0x26, 0xf4, 0xb4, 0xe8, 0x53, 0x2f, 0xf4, 0xd0, 0x45, 0x0e, + 0x28, 0x8e, 0x01, 0xc5, 0x93, 0x9d, 0x8d, 0x6b, 0x82, 0x65, 0xf9, 0x76, 0xc9, 0x72, 0x5d, 0x2f, + 0xb4, 0x42, 0xdb, 0x73, 0x03, 0x4e, 0xd9, 0xd8, 0x5c, 0xa4, 0x49, 0xdc, 0xd0, 0x0e, 0x85, 0xe8, + 0xc6, 0x67, 0x02, 0xc1, 0x56, 0xaf, 0x8e, 0x8f, 0x4a, 0xef, 0xa8, 0xe5, 0xfb, 0x84, 0xc6, 0x0a, + 0xaa, 0xd8, 0x0f, 0x4f, 0x7d, 0x52, 0x72, 0xac, 0xd0, 0x71, 0x87, 0x7c, 0x47, 0xfb, 0x4b, 0x82, + 0xac, 0xce, 0xa4, 0x30, 0x09, 0x8e, 0x9d, 0x10, 0xdd, 0x87, 0x55, 0x2e, 0xad, 0x4a, 0x9b, 0xd2, + 0x76, 0xa6, 0x7c, 0xb5, 0xb8, 0xe0, 0xc0, 0x45, 0x41, 0x11, 0x50, 0xa4, 0xc2, 0xda, 0x09, 0xa1, + 0x81, 0xed, 0xb9, 0x6a, 0x72, 0x53, 0xda, 0x4e, 0xe0, 0x78, 0x89, 0x2e, 0xc1, 0x6a, 0xff, 0x98, + 0x06, 0x1e, 0x55, 0x13, 0x9b, 0xd2, 0x76, 0x16, 0x8b, 0x95, 0xb6, 0x0f, 0xc0, 0x1d, 0xf6, 0x4e, + 0x7d, 0x82, 0xae, 0xc2, 0x65, 0xac, 0x77, 0x0f, 0x5a, 0x3d, 0xb3, 0xf7, 0xbc, 0xa3, 0x9b, 0x07, + 0xed, 0x6e, 0x47, 0xaf, 0x35, 0x77, 0x9b, 0x7a, 0x5d, 0x59, 0x41, 0xeb, 0x90, 0xdc, 0x3d, 0x68, + 0xb5, 0x14, 0x09, 0xe5, 0x01, 0x3a, 0xd8, 0x78, 0xac, 0xd7, 0x7a, 0x4d, 0xa3, 0xad, 0xc8, 0x28, + 0x0b, 0xeb, 0x4f, 0xf4, 0xe7, 0xa6, 0xd1, 0x6e, 0x3d, 0x57, 0x12, 0xda, 0x1f, 0x09, 0x48, 0xed, + 0x47, 0x99, 0x46, 0xdf, 0x01, 0xf8, 0xd4, 0xfb, 0x81, 0xf4, 0xa3, 0x2c, 0xaa, 0xf2, 0x66, 0x62, + 0x3b, 0x53, 0xbe, 0xb1, 0x30, 0x8e, 0xce, 0x18, 0x86, 0xa7, 0x28, 0xe8, 0x2b, 0x48, 0xbe, 0xb1, + 0xdd, 0x81, 0x9a, 0x60, 0xd4, 0x9b, 0x0b, 0xa9, 0x4f, 0x6c, 0x77, 0xa0, 0xff, 0xe8, 0x53, 0x12, + 0x44, 0x81, 0x62, 0x46, 0x88, 0xb2, 0x77, 0x64, 0x3b, 0x21, 0xa1, 0x2c, 0x0f, 0xef, 0xcb, 0xde, + 0x2e, 0x83, 0x60, 0x01, 0x45, 0x0f, 0x21, 0xe5, 0xd1, 0x01, 0xa1, 0x6a, 0x8a, 0xb9, 0xd3, 0xde, + 0x77, 0x52, 0x9f, 0xd0, 0xf0, 0xd4, 0x88, 0x90, 0x98, 0x13, 0xd0, 0x1e, 0x64, 0x06, 0x76, 0x10, + 0xda, 0x6e, 0x3f, 0x34, 0x3d, 0x57, 0x5d, 0x65, 0xfc, 0x2f, 0x96, 0xf2, 0x31, 0x39, 0x22, 0x94, + 0xb8, 0x7d, 0x82, 0x21, 0xa6, 0x1a, 0x2e, 0xda, 0x82, 0x6c, 0x10, 0x5a, 0x34, 0x34, 0xc5, 0x65, + 0xad, 0xb1, 0xcb, 0xca, 0x30, 0x5b, 0x8d, 0x99, 0xd0, 0x75, 0x00, 0xe2, 0x0e, 0x62, 0xc0, 0x3a, + 0x03, 0xa4, 0x89, 0x3b, 0x10, 0xdb, 0x97, 0x60, 0xd5, 0x3b, 0x3a, 0x0a, 0x48, 0xa8, 0xc2, 0xa6, + 0xb4, 0x9d, 0xc2, 0x62, 0x85, 0x76, 0x20, 0xe5, 0xd8, 0x23, 0x3b, 0x54, 0xb3, 0xb3, 0x09, 0x89, + 0x4b, 0xb5, 0xd8, 0x74, 0xc3, 0xfb, 0xe5, 0x43, 0xcb, 0x39, 0x26, 0x98, 0x23, 0xb5, 0x5b, 0x90, + 0x9f, 0x4d, 0x2e, 0x42, 0x90, 0x74, 0xad, 0x11, 0x61, 0x25, 0x99, 0xc6, 0xec, 0x5b, 0xbb, 0x0d, + 0x17, 0xce, 0xc4, 0x34, 0x06, 0xca, 0x53, 0xc0, 0x0e, 0xc0, 0xe4, 0x9a, 0x51, 0x15, 0xd6, 0x7d, + 0x41, 0x13, 0x15, 0x7e, 0xde, 0x7c, 0x8d, 0x79, 0xda, 0xbf, 0x12, 0xe4, 0x66, 0xee, 0xe3, 0x63, + 0xa8, 0xa2, 0xc7, 0x90, 0x1e, 0xd8, 0x74, 0x5c, 0xb4, 0xd2, 0x76, 0xbe, 0x7c, 0xe7, 0xc3, 0xa5, + 0x50, 0xac, 0xc7, 0x1c, 0x3c, 0xa1, 0x6b, 0x3a, 0xa4, 0xc7, 0x76, 0x74, 0x05, 0x3e, 0xad, 0x37, + 0x31, 0x7f, 0x35, 0x73, 0x6f, 0x2b, 0x07, 0xe9, 0x4a, 0xb7, 0xa6, 0xb7, 0xeb, 0xcd, 0xf6, 0x1e, + 0x7f, 0x60, 0x75, 0x7d, 0xbc, 0x96, 0xb5, 0xdf, 0x25, 0x58, 0xe5, 0xc5, 0x8a, 0xf6, 0x41, 0xe9, + 0x7b, 0x23, 0xdf, 0x0b, 0xec, 0x90, 0x98, 0xa2, 0xc6, 0x79, 0xa4, 0xb7, 0x16, 0x1e, 0xb2, 0x16, + 0x83, 0x39, 0xbf, 0xb1, 0x82, 0x0b, 0xfd, 0x59, 0x13, 0x6a, 0x43, 0x21, 0x0e, 0x3e, 0x56, 0x94, + 0x99, 0xe2, 0xcd, 0xa5, 0x61, 0x8f, 0x05, 0xf3, 0xfe, 0x8c, 0xa5, 0x9a, 0x83, 0x0c, 0x97, 0x31, + 0xa3, 0x3e, 0xa7, 0xfd, 0x26, 0x41, 0x61, 0xee, 0x14, 0xe8, 0x5b, 0x90, 0x3d, 0x9f, 0x9d, 0x3b, + 0x5f, 0xbe, 0x7b, 0x9e, 0x73, 0x17, 0x0d, 0x9f, 0x50, 0x2b, 0xf4, 0x28, 0x96, 0x3d, 0x1f, 0x3d, + 0x80, 0x35, 0xee, 0x21, 0x10, 0x5d, 0x65, 0xe9, 0xfb, 0x8e, 0xb1, 0xda, 0x5d, 0x58, 0x8f, 0x65, + 0x90, 0x0a, 0x9f, 0x18, 0x1d, 0x1d, 0x57, 0x7a, 0x06, 0x9e, 0xbb, 0x8b, 0x35, 0x48, 0x54, 0xda, + 0x75, 0x45, 0xd2, 0xfe, 0x91, 0x21, 0x3f, 0x1b, 0xec, 0x47, 0xa9, 0xaf, 0x47, 0x2c, 0xf6, 0xf3, + 0x14, 0xd6, 0xa2, 0xd0, 0xef, 0x41, 0xea, 0x24, 0x7a, 0xa4, 0xac, 0x8f, 0x67, 0xca, 0x1b, 0x0b, + 0x05, 0xc4, 0x33, 0x66, 0x40, 0xed, 0x27, 0xe9, 0x5c, 0x61, 0xe7, 0x20, 0xdd, 0xd2, 0xbb, 0x5d, + 0xb3, 0xd7, 0xa8, 0xb4, 0x15, 0x09, 0x5d, 0x02, 0x34, 0x5e, 0x9a, 0x06, 0x36, 0xf5, 0xfd, 0x83, + 0x4a, 0x4b, 0x91, 0x91, 0x02, 0xd9, 0x3d, 0xac, 0x57, 0x7a, 0x3a, 0xe6, 0xc8, 0x44, 0x54, 0xd6, + 0xd3, 0x96, 0x09, 0x38, 0x89, 0xd2, 0x90, 0xe2, 0x9f, 0xa9, 0x88, 0xd7, 0xa8, 0x74, 0xcd, 0x4a, + 0xbb, 0xa6, 0x77, 0x7b, 0x06, 0x56, 0x32, 0xda, 0x7f, 0x32, 0xac, 0xef, 0xbd, 0x75, 0xf8, 0xaf, + 0x62, 0x0b, 0xb2, 0xec, 0xef, 0x6c, 0x06, 0x21, 0xb5, 0xdd, 0xa1, 0xe8, 0x30, 0x19, 0x66, 0xeb, + 0x32, 0x13, 0xfa, 0x1c, 0xf2, 0x96, 0xe3, 0x78, 0xef, 0x4c, 0xc7, 0x0e, 0x09, 0xb5, 0x9c, 0x80, + 0xe5, 0x70, 0x1d, 0xe7, 0x98, 0xb5, 0x25, 0x8c, 0xe8, 0x19, 0xe4, 0xa3, 0x76, 0x33, 0x30, 0x5f, + 0xd9, 0xee, 0xc0, 0x76, 0x87, 0x81, 0x68, 0xe7, 0xf7, 0x16, 0x66, 0x2a, 0x3e, 0x40, 0xb1, 0x1d, + 0x71, 0xaa, 0x82, 0xa2, 0xbb, 0x21, 0x3d, 0xc5, 0x39, 0x77, 0xda, 0x86, 0x9e, 0xc1, 0x45, 0x56, + 0x91, 0xb6, 0xe7, 0x5a, 0xce, 0x44, 0x3d, 0xb9, 0xa4, 0xd9, 0xc7, 0xea, 0x1d, 0x8b, 0x5a, 0x23, + 0x12, 0xd5, 0x22, 0x9a, 0x48, 0xc4, 0xc2, 0x1b, 0xaf, 0x01, 0x9d, 0xf5, 0x8e, 0x14, 0x48, 0xbc, + 0x21, 0xa7, 0x22, 0x11, 0xd1, 0x27, 0x7a, 0x14, 0x5f, 0xbd, 0xbc, 0xa4, 0xf2, 0xce, 0xba, 0xe4, + 0xa4, 0xaf, 0xe5, 0x87, 0x92, 0x16, 0xc0, 0x85, 0x33, 0xfb, 0xa8, 0x3c, 0x2b, 0xbb, 0xa4, 0xa2, + 0x1a, 0x2b, 0x42, 0x0c, 0xa9, 0xb3, 0xe3, 0x44, 0x63, 0x25, 0x1e, 0x28, 0xaa, 0x0a, 0xe4, 0xfd, + 0x58, 0x9a, 0xbf, 0xff, 0x3f, 0x93, 0xa0, 0x30, 0x97, 0x7c, 0xd0, 0xa8, 0x5a, 0x61, 0xff, 0x35, + 0xba, 0x0d, 0x85, 0xe0, 0x8d, 0xed, 0xfb, 0x64, 0x60, 0x52, 0x66, 0x0e, 0xd4, 0x55, 0xf6, 0xbf, + 0xca, 0x0b, 0x33, 0x07, 0x07, 0xd1, 0xad, 0xc7, 0xc0, 0x99, 0x01, 0x26, 0x27, 0xac, 0xe2, 0xb7, + 0xf7, 0x02, 0x10, 0x9f, 0x81, 0x84, 0x1c, 0x73, 0x2d, 0x1a, 0xcc, 0x9d, 0x65, 0xa3, 0x13, 0x43, + 0x17, 0x27, 0x33, 0x10, 0x56, 0xc8, 0xd4, 0x06, 0x9b, 0x8a, 0x1a, 0x90, 0x9f, 0xd1, 0x8e, 0x9b, + 0xce, 0xd6, 0x07, 0x75, 0x71, 0x6e, 0x5a, 0x2c, 0x98, 0xfb, 0x77, 0x27, 0xe7, 0xff, 0xdd, 0xdf, + 0x43, 0x76, 0xe4, 0x51, 0x32, 0x76, 0x93, 0x62, 0xc7, 0x7f, 0xb0, 0xd0, 0xcd, 0x7c, 0x46, 0x8b, + 0x4f, 0x3d, 0x4a, 0x84, 0x1f, 0x16, 0x47, 0x66, 0x34, 0x31, 0xa0, 0x2f, 0x41, 0x09, 0x5c, 0xcb, + 0x0f, 0x5e, 0x7b, 0xa1, 0x19, 0x4f, 0x88, 0x6b, 0x6c, 0x42, 0x2c, 0xc4, 0xf6, 0x43, 0x6e, 0xd6, + 0x7e, 0x96, 0xa0, 0x30, 0xa7, 0x85, 0xb6, 0xe0, 0xfa, 0x53, 0x03, 0xeb, 0x26, 0x1f, 0x0e, 0xbb, + 0x8b, 0xa6, 0x43, 0x05, 0xb2, 0x6d, 0xa3, 0x67, 0xee, 0x36, 0xdb, 0xcd, 0x6e, 0x43, 0xaf, 0x2b, + 0x12, 0xba, 0x06, 0xea, 0x0c, 0xa9, 0xb2, 0x1b, 0xb5, 0x88, 0x56, 0xf3, 0x69, 0xb3, 0xa7, 0xc8, + 0xe8, 0x3a, 0x5c, 0x59, 0xb0, 0x5b, 0x3b, 0xc0, 0x5d, 0x03, 0x2b, 0x49, 0x74, 0x11, 0x0a, 0x6d, + 0xc3, 0x9c, 0x46, 0x28, 0x89, 0xea, 0x2f, 0x12, 0x5c, 0xee, 0x7b, 0xa3, 0x45, 0xf9, 0xa8, 0x02, + 0xaf, 0xea, 0x68, 0x9a, 0xe9, 0x48, 0x2f, 0x1e, 0x09, 0xc8, 0xd0, 0x73, 0x2c, 0x77, 0x58, 0xf4, + 0xe8, 0xb0, 0x34, 0x24, 0x2e, 0x9b, 0x75, 0x4a, 0x7c, 0xcb, 0xf2, 0xed, 0x60, 0x66, 0x92, 0xff, + 0x66, 0xbc, 0xf8, 0x55, 0xbe, 0xb2, 0xc7, 0xe9, 0x35, 0xc7, 0x3b, 0x1e, 0x14, 0xeb, 0x63, 0x3f, + 0x87, 0x3b, 0x7f, 0xc7, 0x7b, 0x2f, 0xd9, 0xde, 0xcb, 0xf1, 0xde, 0xcb, 0xc3, 0x9d, 0x57, 0xab, + 0xcc, 0xc1, 0xfd, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x38, 0x05, 0xaa, 0x7d, 0x0c, 0x00, + 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/type/latlng/latlng.pb.go b/vendor/google.golang.org/genproto/googleapis/type/latlng/latlng.pb.go new file mode 100644 index 0000000..6566204 --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/type/latlng/latlng.pb.go @@ -0,0 +1,93 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/type/latlng.proto + +package latlng // import "google.golang.org/genproto/googleapis/type/latlng" + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// An object representing a latitude/longitude pair. This is expressed as a pair +// of doubles representing degrees latitude and degrees longitude. Unless +// specified otherwise, this must conform to the +// WGS84 +// standard. Values must be within normalized ranges. +type LatLng struct { + // The latitude in degrees. It must be in the range [-90.0, +90.0]. + Latitude float64 `protobuf:"fixed64,1,opt,name=latitude,proto3" json:"latitude,omitempty"` + // The longitude in degrees. It must be in the range [-180.0, +180.0]. + Longitude float64 `protobuf:"fixed64,2,opt,name=longitude,proto3" json:"longitude,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LatLng) Reset() { *m = LatLng{} } +func (m *LatLng) String() string { return proto.CompactTextString(m) } +func (*LatLng) ProtoMessage() {} +func (*LatLng) Descriptor() ([]byte, []int) { + return fileDescriptor_latlng_330cffcdb57a0ae8, []int{0} +} +func (m *LatLng) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LatLng.Unmarshal(m, b) +} +func (m *LatLng) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LatLng.Marshal(b, m, deterministic) +} +func (dst *LatLng) XXX_Merge(src proto.Message) { + xxx_messageInfo_LatLng.Merge(dst, src) +} +func (m *LatLng) XXX_Size() int { + return xxx_messageInfo_LatLng.Size(m) +} +func (m *LatLng) XXX_DiscardUnknown() { + xxx_messageInfo_LatLng.DiscardUnknown(m) +} + +var xxx_messageInfo_LatLng proto.InternalMessageInfo + +func (m *LatLng) GetLatitude() float64 { + if m != nil { + return m.Latitude + } + return 0 +} + +func (m *LatLng) GetLongitude() float64 { + if m != nil { + return m.Longitude + } + return 0 +} + +func init() { + proto.RegisterType((*LatLng)(nil), "google.type.LatLng") +} + +func init() { proto.RegisterFile("google/type/latlng.proto", fileDescriptor_latlng_330cffcdb57a0ae8) } + +var fileDescriptor_latlng_330cffcdb57a0ae8 = []byte{ + // 168 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x48, 0xcf, 0xcf, 0x4f, + 0xcf, 0x49, 0xd5, 0x2f, 0xa9, 0x2c, 0x48, 0xd5, 0xcf, 0x49, 0x2c, 0xc9, 0xc9, 0x4b, 0xd7, 0x2b, + 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x86, 0xc8, 0xe8, 0x81, 0x64, 0x94, 0x9c, 0xb8, 0xd8, 0x7c, + 0x12, 0x4b, 0x7c, 0xf2, 0xd2, 0x85, 0xa4, 0xb8, 0x38, 0x72, 0x12, 0x4b, 0x32, 0x4b, 0x4a, 0x53, + 0x52, 0x25, 0x18, 0x15, 0x18, 0x35, 0x18, 0x83, 0xe0, 0x7c, 0x21, 0x19, 0x2e, 0xce, 0x9c, 0xfc, + 0xbc, 0x74, 0x88, 0x24, 0x13, 0x58, 0x12, 0x21, 0xe0, 0x94, 0xcc, 0xc5, 0x9f, 0x9c, 0x9f, 0xab, + 0x87, 0x64, 0xac, 0x13, 0x37, 0xc4, 0xd0, 0x00, 0x90, 0x85, 0x01, 0x8c, 0x51, 0x16, 0x50, 0xb9, + 0xf4, 0xfc, 0x9c, 0xc4, 0xbc, 0x74, 0xbd, 0xfc, 0xa2, 0x74, 0xfd, 0xf4, 0xd4, 0x3c, 0xb0, 0x73, + 0xf4, 0x21, 0x52, 0x89, 0x05, 0x99, 0xc5, 0xc8, 0x6e, 0xb5, 0x86, 0x50, 0x3f, 0x18, 0x19, 0x17, + 0x31, 0x31, 0xbb, 0x87, 0x04, 0x24, 0xb1, 0x81, 0x55, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, + 0xc0, 0x7b, 0xd0, 0x8b, 0xd8, 0x00, 0x00, 0x00, +}