| // Copyright 2019 Google LLC. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Code generated file. DO NOT EDIT. |
| |
| // Package spanner provides access to the Cloud Spanner API. |
| // |
| // This package is DEPRECATED. Use package cloud.google.com/go/spanner instead. |
| // |
| // For product documentation, see: https://cloud.google.com/spanner/ |
| // |
| // Creating a client |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/spanner/v1" |
| // ... |
| // ctx := context.Background() |
| // spannerService, err := spanner.NewService(ctx) |
| // |
| // In this example, Google Application Default Credentials are used for authentication. |
| // |
| // For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. |
| // |
| // Other authentication options |
| // |
| // By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes: |
| // |
| // spannerService, err := spanner.NewService(ctx, option.WithScopes(spanner.SpannerDataScope)) |
| // |
| // To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: |
| // |
| // spannerService, err := spanner.NewService(ctx, option.WithAPIKey("AIza...")) |
| // |
| // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: |
| // |
| // config := &oauth2.Config{...} |
| // // ... |
| // token, err := config.Exchange(ctx, ...) |
| // spannerService, err := spanner.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) |
| // |
| // See https://godoc.org/google.golang.org/api/option/ for details on options. |
| package spanner // import "google.golang.org/api/spanner/v1" |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| |
| googleapi "google.golang.org/api/googleapi" |
| gensupport "google.golang.org/api/internal/gensupport" |
| option "google.golang.org/api/option" |
| htransport "google.golang.org/api/transport/http" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| |
| const apiId = "spanner:v1" |
| const apiName = "spanner" |
| const apiVersion = "v1" |
| const basePath = "https://spanner.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage your data across Google Cloud Platform services |
| CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" |
| |
| // Administer your Spanner databases |
| SpannerAdminScope = "https://www.googleapis.com/auth/spanner.admin" |
| |
| // View and manage the contents of your Spanner databases |
| SpannerDataScope = "https://www.googleapis.com/auth/spanner.data" |
| ) |
| |
| // NewService creates a new Service. |
| func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { |
| scopesOption := option.WithScopes( |
| "https://www.googleapis.com/auth/cloud-platform", |
| "https://www.googleapis.com/auth/spanner.admin", |
| "https://www.googleapis.com/auth/spanner.data", |
| ) |
| // NOTE: prepend, so we don't override user-specified scopes. |
| opts = append([]option.ClientOption{scopesOption}, opts...) |
| client, endpoint, err := htransport.NewClient(ctx, opts...) |
| if err != nil { |
| return nil, err |
| } |
| s, err := New(client) |
| if err != nil { |
| return nil, err |
| } |
| if endpoint != "" { |
| s.BasePath = endpoint |
| } |
| return s, nil |
| } |
| |
| // New creates a new Service. It uses the provided http.Client for requests. |
| // |
| // Deprecated: please use NewService instead. |
| // To provide a custom HTTP client, use option.WithHTTPClient. |
| // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Projects = NewProjectsService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Projects *ProjectsService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewProjectsService(s *Service) *ProjectsService { |
| rs := &ProjectsService{s: s} |
| rs.InstanceConfigs = NewProjectsInstanceConfigsService(s) |
| rs.Instances = NewProjectsInstancesService(s) |
| return rs |
| } |
| |
| type ProjectsService struct { |
| s *Service |
| |
| InstanceConfigs *ProjectsInstanceConfigsService |
| |
| Instances *ProjectsInstancesService |
| } |
| |
| func NewProjectsInstanceConfigsService(s *Service) *ProjectsInstanceConfigsService { |
| rs := &ProjectsInstanceConfigsService{s: s} |
| return rs |
| } |
| |
| type ProjectsInstanceConfigsService struct { |
| s *Service |
| } |
| |
| func NewProjectsInstancesService(s *Service) *ProjectsInstancesService { |
| rs := &ProjectsInstancesService{s: s} |
| rs.Backups = NewProjectsInstancesBackupsService(s) |
| rs.Databases = NewProjectsInstancesDatabasesService(s) |
| rs.Operations = NewProjectsInstancesOperationsService(s) |
| return rs |
| } |
| |
| type ProjectsInstancesService struct { |
| s *Service |
| |
| Backups *ProjectsInstancesBackupsService |
| |
| Databases *ProjectsInstancesDatabasesService |
| |
| Operations *ProjectsInstancesOperationsService |
| } |
| |
| func NewProjectsInstancesBackupsService(s *Service) *ProjectsInstancesBackupsService { |
| rs := &ProjectsInstancesBackupsService{s: s} |
| rs.Operations = NewProjectsInstancesBackupsOperationsService(s) |
| return rs |
| } |
| |
| type ProjectsInstancesBackupsService struct { |
| s *Service |
| |
| Operations *ProjectsInstancesBackupsOperationsService |
| } |
| |
| func NewProjectsInstancesBackupsOperationsService(s *Service) *ProjectsInstancesBackupsOperationsService { |
| rs := &ProjectsInstancesBackupsOperationsService{s: s} |
| return rs |
| } |
| |
| type ProjectsInstancesBackupsOperationsService struct { |
| s *Service |
| } |
| |
| func NewProjectsInstancesDatabasesService(s *Service) *ProjectsInstancesDatabasesService { |
| rs := &ProjectsInstancesDatabasesService{s: s} |
| rs.Operations = NewProjectsInstancesDatabasesOperationsService(s) |
| rs.Sessions = NewProjectsInstancesDatabasesSessionsService(s) |
| return rs |
| } |
| |
| type ProjectsInstancesDatabasesService struct { |
| s *Service |
| |
| Operations *ProjectsInstancesDatabasesOperationsService |
| |
| Sessions *ProjectsInstancesDatabasesSessionsService |
| } |
| |
| func NewProjectsInstancesDatabasesOperationsService(s *Service) *ProjectsInstancesDatabasesOperationsService { |
| rs := &ProjectsInstancesDatabasesOperationsService{s: s} |
| return rs |
| } |
| |
| type ProjectsInstancesDatabasesOperationsService struct { |
| s *Service |
| } |
| |
| func NewProjectsInstancesDatabasesSessionsService(s *Service) *ProjectsInstancesDatabasesSessionsService { |
| rs := &ProjectsInstancesDatabasesSessionsService{s: s} |
| return rs |
| } |
| |
| type ProjectsInstancesDatabasesSessionsService struct { |
| s *Service |
| } |
| |
| func NewProjectsInstancesOperationsService(s *Service) *ProjectsInstancesOperationsService { |
| rs := &ProjectsInstancesOperationsService{s: s} |
| return rs |
| } |
| |
| type ProjectsInstancesOperationsService struct { |
| s *Service |
| } |
| |
| // BatchCreateSessionsRequest: The request for BatchCreateSessions. |
| type BatchCreateSessionsRequest struct { |
| // SessionCount: Required. The number of sessions to be created in this |
| // batch call. |
| // The API may return fewer than the requested number of sessions. If |
| // a |
| // specific number of sessions are desired, the client can make |
| // additional |
| // calls to BatchCreateSessions (adjusting |
| // session_count as necessary). |
| SessionCount int64 `json:"sessionCount,omitempty"` |
| |
| // SessionTemplate: Parameters to be applied to each created session. |
| SessionTemplate *Session `json:"sessionTemplate,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "SessionCount") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "SessionCount") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BatchCreateSessionsRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod BatchCreateSessionsRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // BatchCreateSessionsResponse: The response for BatchCreateSessions. |
| type BatchCreateSessionsResponse struct { |
| // Session: The freshly created sessions. |
| Session []*Session `json:"session,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Session") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Session") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BatchCreateSessionsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod BatchCreateSessionsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // BeginTransactionRequest: The request for BeginTransaction. |
| type BeginTransactionRequest struct { |
| // Options: Required. Options for the new transaction. |
| Options *TransactionOptions `json:"options,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Options") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Options") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BeginTransactionRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod BeginTransactionRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Binding: Associates `members` with a `role`. |
| type Binding struct { |
| // Condition: The condition that is associated with this binding. |
| // NOTE: An unsatisfied condition will not allow user access via |
| // current |
| // binding. Different bindings, including their conditions, are |
| // examined |
| // independently. |
| Condition *Expr `json:"condition,omitempty"` |
| |
| // Members: Specifies the identities requesting access for a Cloud |
| // Platform resource. |
| // `members` can have the following values: |
| // |
| // * `allUsers`: A special identifier that represents anyone who is |
| // on the internet; with or without a Google account. |
| // |
| // * `allAuthenticatedUsers`: A special identifier that represents |
| // anyone |
| // who is authenticated with a Google account or a service |
| // account. |
| // |
| // * `user:{emailid}`: An email address that represents a specific |
| // Google |
| // account. For example, `alice@example.com` . |
| // |
| // |
| // * `serviceAccount:{emailid}`: An email address that represents a |
| // service |
| // account. For example, |
| // `my-other-app@appspot.gserviceaccount.com`. |
| // |
| // * `group:{emailid}`: An email address that represents a Google |
| // group. |
| // For example, `admins@example.com`. |
| // |
| // |
| // * `domain:{domain}`: The G Suite domain (primary) that represents all |
| // the |
| // users of that domain. For example, `google.com` or |
| // `example.com`. |
| // |
| // |
| Members []string `json:"members,omitempty"` |
| |
| // Role: Role that is assigned to `members`. |
| // For example, `roles/viewer`, `roles/editor`, or `roles/owner`. |
| Role string `json:"role,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Condition") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Condition") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Binding) MarshalJSON() ([]byte, error) { |
| type NoMethod Binding |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChildLink: Metadata associated with a parent-child relationship |
| // appearing in a |
| // PlanNode. |
| type ChildLink struct { |
| // ChildIndex: The node to which the link points. |
| ChildIndex int64 `json:"childIndex,omitempty"` |
| |
| // Type: The type of the link. For example, in Hash Joins this could be |
| // used to |
| // distinguish between the build child and the probe child, or in the |
| // case |
| // of the child being an output variable, to represent the tag |
| // associated |
| // with the output variable. |
| Type string `json:"type,omitempty"` |
| |
| // Variable: Only present if the child node is SCALAR and corresponds |
| // to an output variable of the parent node. The field carries the name |
| // of |
| // the output variable. |
| // For example, a `TableScan` operator that reads rows from a table |
| // will |
| // have child links to the `SCALAR` nodes representing the output |
| // variables |
| // created for each column that is read by the operator. The |
| // corresponding |
| // `variable` fields will be set to the variable names assigned to |
| // the |
| // columns. |
| Variable string `json:"variable,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ChildIndex") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ChildIndex") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChildLink) MarshalJSON() ([]byte, error) { |
| type NoMethod ChildLink |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CommitRequest: The request for Commit. |
| type CommitRequest struct { |
| // Mutations: The mutations to be executed when this transaction |
| // commits. All |
| // mutations are applied atomically, in the order they appear in |
| // this list. |
| Mutations []*Mutation `json:"mutations,omitempty"` |
| |
| // SingleUseTransaction: Execute mutations in a temporary transaction. |
| // Note that unlike |
| // commit of a previously-started transaction, commit with a |
| // temporary transaction is non-idempotent. That is, if |
| // the |
| // `CommitRequest` is sent to Cloud Spanner more than once |
| // (for |
| // instance, due to retries in the application, or in the |
| // transport library), it is possible that the mutations are |
| // executed more than once. If this is undesirable, use |
| // BeginTransaction and |
| // Commit instead. |
| SingleUseTransaction *TransactionOptions `json:"singleUseTransaction,omitempty"` |
| |
| // TransactionId: Commit a previously-started transaction. |
| TransactionId string `json:"transactionId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Mutations") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Mutations") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CommitRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod CommitRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CommitResponse: The response for Commit. |
| type CommitResponse struct { |
| // CommitTimestamp: The Cloud Spanner timestamp at which the transaction |
| // committed. |
| CommitTimestamp string `json:"commitTimestamp,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "CommitTimestamp") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CommitTimestamp") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CommitResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod CommitResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CreateDatabaseMetadata: Metadata type for the operation returned |
| // by |
| // CreateDatabase. |
| type CreateDatabaseMetadata struct { |
| // Database: The database being created. |
| Database string `json:"database,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Database") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Database") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CreateDatabaseMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod CreateDatabaseMetadata |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CreateDatabaseRequest: The request for CreateDatabase. |
| type CreateDatabaseRequest struct { |
| // CreateStatement: Required. A `CREATE DATABASE` statement, which |
| // specifies the ID of the |
| // new database. The database ID must conform to the regular |
| // expression |
| // `a-z*[a-z0-9]` and be between 2 and 30 characters in length. |
| // If the database ID is a reserved word or if it contains a hyphen, |
| // the |
| // database ID must be enclosed in backticks (`` ` ``). |
| CreateStatement string `json:"createStatement,omitempty"` |
| |
| // ExtraStatements: An optional list of DDL statements to run inside the |
| // newly created |
| // database. Statements can create tables, indexes, etc. |
| // These |
| // statements execute atomically with the creation of the database: |
| // if there is an error in any statement, the database is not created. |
| ExtraStatements []string `json:"extraStatements,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CreateStatement") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CreateStatement") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CreateDatabaseRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod CreateDatabaseRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CreateInstanceMetadata: Metadata type for the operation returned |
| // by |
| // CreateInstance. |
| type CreateInstanceMetadata struct { |
| // CancelTime: The time at which this operation was cancelled. If set, |
| // this operation is |
| // in the process of undoing itself (which is guaranteed to succeed) |
| // and |
| // cannot be cancelled again. |
| CancelTime string `json:"cancelTime,omitempty"` |
| |
| // EndTime: The time at which this operation failed or was completed |
| // successfully. |
| EndTime string `json:"endTime,omitempty"` |
| |
| // Instance: The instance being created. |
| Instance *Instance `json:"instance,omitempty"` |
| |
| // StartTime: The time at which the |
| // CreateInstance request was |
| // received. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CancelTime") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CancelTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CreateInstanceMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod CreateInstanceMetadata |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CreateInstanceRequest: The request for CreateInstance. |
| type CreateInstanceRequest struct { |
| // Instance: Required. The instance to create. The name may be omitted, |
| // but if |
| // specified must be `<parent>/instances/<instance_id>`. |
| Instance *Instance `json:"instance,omitempty"` |
| |
| // InstanceId: Required. The ID of the instance to create. Valid |
| // identifiers are of the |
| // form `a-z*[a-z0-9]` and must be between 2 and 64 characters |
| // in |
| // length. |
| InstanceId string `json:"instanceId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Instance") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Instance") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CreateInstanceRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod CreateInstanceRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CreateSessionRequest: The request for CreateSession. |
| type CreateSessionRequest struct { |
| // Session: The session to create. |
| Session *Session `json:"session,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Session") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Session") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CreateSessionRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod CreateSessionRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Database: A Cloud Spanner database. |
| type Database struct { |
| // Name: Required. The name of the database. Values are of the |
| // form |
| // `projects/<project>/instances/<instance>/databases/<database>`, |
| // w |
| // here `<database>` is as specified in the `CREATE DATABASE` |
| // statement. This name can be passed to other API methods to |
| // identify the database. |
| Name string `json:"name,omitempty"` |
| |
| // State: Output only. The current database state. |
| // |
| // Possible values: |
| // "STATE_UNSPECIFIED" - Not specified. |
| // "CREATING" - The database is still being created. Operations on the |
| // database may fail |
| // with `FAILED_PRECONDITION` in this state. |
| // "READY" - The database is fully created and ready for use. |
| State string `json:"state,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Database) MarshalJSON() ([]byte, error) { |
| type NoMethod Database |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Delete: Arguments to delete operations. |
| type Delete struct { |
| // KeySet: Required. The primary keys of the rows within table to |
| // delete. |
| // Delete is idempotent. The transaction will succeed even if some or |
| // all |
| // rows do not exist. |
| KeySet *KeySet `json:"keySet,omitempty"` |
| |
| // Table: Required. The table whose rows will be deleted. |
| Table string `json:"table,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "KeySet") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "KeySet") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Delete) MarshalJSON() ([]byte, error) { |
| type NoMethod Delete |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Empty: A generic empty message that you can re-use to avoid defining |
| // duplicated |
| // empty messages in your APIs. A typical example is to use it as the |
| // request |
| // or the response type of an API method. For instance: |
| // |
| // service Foo { |
| // rpc Bar(google.protobuf.Empty) returns |
| // (google.protobuf.Empty); |
| // } |
| // |
| // The JSON representation for `Empty` is empty JSON object `{}`. |
| type Empty struct { |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| } |
| |
| // ExecuteBatchDmlRequest: The request for ExecuteBatchDml. |
| type ExecuteBatchDmlRequest struct { |
| // Seqno: A per-transaction sequence number used to identify this |
| // request. This field |
| // makes each request idempotent such that if the request is received |
| // multiple |
| // times, at most one will succeed. |
| // |
| // The sequence number must be monotonically increasing within |
| // the |
| // transaction. If a request arrives for the first time with an |
| // out-of-order |
| // sequence number, the transaction may be aborted. Replays of |
| // previously |
| // handled requests will yield the same response as the first execution. |
| Seqno int64 `json:"seqno,omitempty,string"` |
| |
| // Statements: The list of statements to execute in this batch. |
| // Statements are executed |
| // serially, such that the effects of statement `i` are visible to |
| // statement |
| // `i+1`. Each statement must be a DML statement. Execution stops at |
| // the |
| // first failed statement; the remaining statements are not |
| // executed. |
| // |
| // Callers must provide at least one statement. |
| Statements []*Statement `json:"statements,omitempty"` |
| |
| // Transaction: The transaction to use. Must be a read-write |
| // transaction. |
| // |
| // To protect against replays, single-use transactions are not |
| // supported. The |
| // caller must either supply an existing transaction ID or begin a |
| // new |
| // transaction. |
| Transaction *TransactionSelector `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Seqno") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Seqno") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ExecuteBatchDmlRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod ExecuteBatchDmlRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ExecuteBatchDmlResponse: The response for ExecuteBatchDml. Contains a |
| // list |
| // of ResultSet messages, one for each DML statement that has |
| // successfully |
| // executed, in the same order as the statements in the request. If a |
| // statement |
| // fails, the status in the response body identifies the cause of the |
| // failure. |
| // |
| // To check for DML statements that failed, use the following |
| // approach: |
| // |
| // 1. Check the status in the response message. The google.rpc.Code |
| // enum |
| // value `OK` indicates that all statements were executed |
| // successfully. |
| // 2. If the status was not `OK`, check the number of result sets in |
| // the |
| // response. If the response contains `N` ResultSet messages, then |
| // statement `N+1` in the request failed. |
| // |
| // Example 1: |
| // |
| // * Request: 5 DML statements, all executed successfully. |
| // * Response: 5 ResultSet messages, with the status `OK`. |
| // |
| // Example 2: |
| // |
| // * Request: 5 DML statements. The third statement has a syntax |
| // error. |
| // * Response: 2 ResultSet messages, and a syntax error |
| // (`INVALID_ARGUMENT`) |
| // status. The number of ResultSet messages indicates that the third |
| // statement failed, and the fourth and fifth statements were not |
| // executed. |
| type ExecuteBatchDmlResponse struct { |
| // ResultSets: One ResultSet for each statement in the request that ran |
| // successfully, |
| // in the same order as the statements in the request. Each ResultSet |
| // does |
| // not contain any rows. The ResultSetStats in each ResultSet |
| // contain |
| // the number of rows modified by the statement. |
| // |
| // Only the first ResultSet in the response contains |
| // valid |
| // ResultSetMetadata. |
| ResultSets []*ResultSet `json:"resultSets,omitempty"` |
| |
| // Status: If all DML statements are executed successfully, the status |
| // is `OK`. |
| // Otherwise, the error status of the first failed statement. |
| Status *Status `json:"status,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ResultSets") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ResultSets") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ExecuteBatchDmlResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ExecuteBatchDmlResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ExecuteSqlRequest: The request for ExecuteSql |
| // and |
| // ExecuteStreamingSql. |
| type ExecuteSqlRequest struct { |
| // ParamTypes: It is not always possible for Cloud Spanner to infer the |
| // right SQL type |
| // from a JSON value. For example, values of type `BYTES` and values |
| // of type `STRING` both appear in params as JSON strings. |
| // |
| // In these cases, `param_types` can be used to specify the exact |
| // SQL type for some or all of the SQL statement parameters. See |
| // the |
| // definition of Type for more information |
| // about SQL types. |
| ParamTypes map[string]Type `json:"paramTypes,omitempty"` |
| |
| // Params: Parameter names and values that bind to placeholders in the |
| // SQL string. |
| // |
| // A parameter placeholder consists of the `@` character followed by |
| // the |
| // parameter name (for example, `@firstName`). Parameter names can |
| // contain |
| // letters, numbers, and underscores. |
| // |
| // Parameters can appear anywhere that a literal value is expected. The |
| // same |
| // parameter name can be used more than once, for example: |
| // |
| // "WHERE id > @msg_id AND id < @msg_id + 100" |
| // |
| // It is an error to execute a SQL statement with unbound parameters. |
| Params googleapi.RawMessage `json:"params,omitempty"` |
| |
| // PartitionToken: If present, results will be restricted to the |
| // specified partition |
| // previously created using PartitionQuery(). There must be an |
| // exact |
| // match for the values of fields common to this message and |
| // the |
| // PartitionQueryRequest message used to create this partition_token. |
| PartitionToken string `json:"partitionToken,omitempty"` |
| |
| // QueryMode: Used to control the amount of debugging information |
| // returned in |
| // ResultSetStats. If partition_token is set, query_mode can only |
| // be set to QueryMode.NORMAL. |
| // |
| // Possible values: |
| // "NORMAL" - The default mode. Only the statement results are |
| // returned. |
| // "PLAN" - This mode returns only the query plan, without any results |
| // or |
| // execution statistics information. |
| // "PROFILE" - This mode returns both the query plan and the execution |
| // statistics along |
| // with the results. |
| QueryMode string `json:"queryMode,omitempty"` |
| |
| // ResumeToken: If this request is resuming a previously interrupted SQL |
| // statement |
| // execution, `resume_token` should be copied from the |
| // last |
| // PartialResultSet yielded before the interruption. Doing this |
| // enables the new SQL statement execution to resume where the last one |
| // left |
| // off. The rest of the request parameters must exactly match |
| // the |
| // request that yielded this token. |
| ResumeToken string `json:"resumeToken,omitempty"` |
| |
| // Seqno: A per-transaction sequence number used to identify this |
| // request. This field |
| // makes each request idempotent such that if the request is received |
| // multiple |
| // times, at most one will succeed. |
| // |
| // The sequence number must be monotonically increasing within |
| // the |
| // transaction. If a request arrives for the first time with an |
| // out-of-order |
| // sequence number, the transaction may be aborted. Replays of |
| // previously |
| // handled requests will yield the same response as the first |
| // execution. |
| // |
| // Required for DML statements. Ignored for queries. |
| Seqno int64 `json:"seqno,omitempty,string"` |
| |
| // Sql: Required. The SQL string. |
| Sql string `json:"sql,omitempty"` |
| |
| // Transaction: The transaction to use. |
| // |
| // For queries, if none is provided, the default is a temporary |
| // read-only |
| // transaction with strong concurrency. |
| // |
| // Standard DML statements require a read-write transaction. To |
| // protect |
| // against replays, single-use transactions are not supported. The |
| // caller |
| // must either supply an existing transaction ID or begin a new |
| // transaction. |
| // |
| // Partitioned DML requires an existing Partitioned DML transaction ID. |
| Transaction *TransactionSelector `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ParamTypes") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ParamTypes") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ExecuteSqlRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod ExecuteSqlRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Expr: Represents an expression text. Example: |
| // |
| // title: "User account presence" |
| // description: "Determines whether the request has a user account" |
| // expression: "size(request.user) > 0" |
| type Expr struct { |
| // Description: An optional description of the expression. This is a |
| // longer text which |
| // describes the expression, e.g. when hovered over it in a UI. |
| Description string `json:"description,omitempty"` |
| |
| // Expression: Textual representation of an expression in |
| // Common Expression Language syntax. |
| // |
| // The application context of the containing message determines |
| // which |
| // well-known feature set of CEL is supported. |
| Expression string `json:"expression,omitempty"` |
| |
| // Location: An optional string indicating the location of the |
| // expression for error |
| // reporting, e.g. a file name and a position in the file. |
| Location string `json:"location,omitempty"` |
| |
| // Title: An optional title for the expression, i.e. a short string |
| // describing |
| // its purpose. This can be used e.g. in UIs which allow to enter |
| // the |
| // expression. |
| Title string `json:"title,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Expr) MarshalJSON() ([]byte, error) { |
| type NoMethod Expr |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Field: Message representing a single field of a struct. |
| type Field struct { |
| // Name: The name of the field. For reads, this is the column name. |
| // For |
| // SQL queries, it is the column alias (e.g., "Word" in the |
| // query "SELECT 'hello' AS Word"), or the column name |
| // (e.g., |
| // "ColName" in the query "SELECT ColName FROM Table"). Some |
| // columns might have an empty name (e.g., !"SELECT |
| // UPPER(ColName)"). Note that a query result can contain |
| // multiple fields with the same name. |
| Name string `json:"name,omitempty"` |
| |
| // Type: The type of the field. |
| Type *Type `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Field) MarshalJSON() ([]byte, error) { |
| type NoMethod Field |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GetDatabaseDdlResponse: The response for GetDatabaseDdl. |
| type GetDatabaseDdlResponse struct { |
| // Statements: A list of formatted DDL statements defining the schema of |
| // the database |
| // specified in the request. |
| Statements []string `json:"statements,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Statements") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Statements") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GetDatabaseDdlResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod GetDatabaseDdlResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GetIamPolicyRequest: Request message for `GetIamPolicy` method. |
| type GetIamPolicyRequest struct { |
| // Options: OPTIONAL: A `GetPolicyOptions` object for specifying options |
| // to |
| // `GetIamPolicy`. This field is only used by Cloud IAM. |
| Options *GetPolicyOptions `json:"options,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Options") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Options") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GetIamPolicyRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod GetIamPolicyRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GetPolicyOptions: Encapsulates settings provided to GetIamPolicy. |
| type GetPolicyOptions struct { |
| // RequestedPolicyVersion: Optional. The policy format version to be |
| // returned. |
| // |
| // Valid values are 0, 1, and 3. Requests specifying an invalid value |
| // will be |
| // rejected. |
| // |
| // Requests for policies with any conditional bindings must specify |
| // version 3. |
| // Policies without any conditional bindings may specify any valid value |
| // or |
| // leave the field unset. |
| RequestedPolicyVersion int64 `json:"requestedPolicyVersion,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "RequestedPolicyVersion") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "RequestedPolicyVersion") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GetPolicyOptions) MarshalJSON() ([]byte, error) { |
| type NoMethod GetPolicyOptions |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Instance: An isolated set of Cloud Spanner resources on which |
| // databases can be hosted. |
| type Instance struct { |
| // Config: Required. The name of the instance's configuration. Values |
| // are of the form |
| // `projects/<project>/instanceConfigs/<configuration>`. See |
| // also InstanceConfig and |
| // ListInstanceConfigs. |
| Config string `json:"config,omitempty"` |
| |
| // DisplayName: Required. The descriptive name for this instance as it |
| // appears in UIs. |
| // Must be unique per project and between 4 and 30 characters in length. |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: Cloud Labels are a flexible and lightweight mechanism for |
| // organizing cloud |
| // resources into groups that reflect a customer's organizational needs |
| // and |
| // deployment strategies. Cloud Labels can be used to filter collections |
| // of |
| // resources. They can be used to control how resource metrics are |
| // aggregated. |
| // And they can be used as arguments to policy management rules (e.g. |
| // route, |
| // firewall, load balancing, etc.). |
| // |
| // * Label keys must be between 1 and 63 characters long and must |
| // conform to |
| // the following regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`. |
| // * Label values must be between 0 and 63 characters long and must |
| // conform |
| // to the regular expression `([a-z]([-a-z0-9]*[a-z0-9])?)?`. |
| // * No more than 64 labels can be associated with a given |
| // resource. |
| // |
| // See https://goo.gl/xmQnxf for more information on and examples of |
| // labels. |
| // |
| // If you plan to use labels in your own code, please note that |
| // additional |
| // characters may be allowed in the future. And so you are advised to |
| // use an |
| // internal label representation, such as JSON, which doesn't rely |
| // upon |
| // specific characters being disallowed. For example, representing |
| // labels |
| // as the string: name + "_" + value would prove problematic if we |
| // were to |
| // allow "_" in a future release. |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // Name: Required. A unique identifier for the instance, which cannot be |
| // changed |
| // after the instance is created. Values are of the |
| // form |
| // `projects/<project>/instances/a-z*[a-z0-9]`. The final |
| // segment of the name must be between 2 and 64 characters in length. |
| Name string `json:"name,omitempty"` |
| |
| // NodeCount: Required. The number of nodes allocated to this instance. |
| // This may be zero |
| // in API responses for instances that are not yet in state |
| // `READY`. |
| // |
| // See |
| // [the |
| // documentation](https://cloud.google.com/spanner/docs/instances#no |
| // de_count) |
| // for more information about nodes. |
| NodeCount int64 `json:"nodeCount,omitempty"` |
| |
| // State: Output only. The current instance state. For |
| // CreateInstance, the state must be |
| // either omitted or set to `CREATING`. For |
| // UpdateInstance, the state must be |
| // either omitted or set to `READY`. |
| // |
| // Possible values: |
| // "STATE_UNSPECIFIED" - Not specified. |
| // "CREATING" - The instance is still being created. Resources may not |
| // be |
| // available yet, and operations such as database creation may not |
| // work. |
| // "READY" - The instance is fully created and ready to do work such |
| // as |
| // creating databases. |
| State string `json:"state,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Config") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Config") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Instance) MarshalJSON() ([]byte, error) { |
| type NoMethod Instance |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // InstanceConfig: A possible configuration for a Cloud Spanner |
| // instance. Configurations |
| // define the geographic placement of nodes and their replication. |
| type InstanceConfig struct { |
| // DisplayName: The name of this instance configuration as it appears in |
| // UIs. |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Name: A unique identifier for the instance configuration. Values |
| // are of the form |
| // `projects/<project>/instanceConfigs/a-z*` |
| Name string `json:"name,omitempty"` |
| |
| // Replicas: The geographic placement of nodes in this instance |
| // configuration and their |
| // replication properties. |
| Replicas []*ReplicaInfo `json:"replicas,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "DisplayName") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DisplayName") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *InstanceConfig) MarshalJSON() ([]byte, error) { |
| type NoMethod InstanceConfig |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // KeyRange: KeyRange represents a range of rows in a table or index. |
| // |
| // A range has a start key and an end key. These keys can be open |
| // or |
| // closed, indicating if the range includes rows with that key. |
| // |
| // Keys are represented by lists, where the ith value in the |
| // list |
| // corresponds to the ith component of the table or index primary |
| // key. |
| // Individual values are encoded as described |
| // here. |
| // |
| // For example, consider the following table definition: |
| // |
| // CREATE TABLE UserEvents ( |
| // UserName STRING(MAX), |
| // EventDate STRING(10) |
| // ) PRIMARY KEY(UserName, EventDate); |
| // |
| // The following keys name rows in this table: |
| // |
| // "Bob", "2014-09-23" |
| // |
| // Since the `UserEvents` table's `PRIMARY KEY` clause names |
| // two |
| // columns, each `UserEvents` key has two elements; the first is |
| // the |
| // `UserName`, and the second is the `EventDate`. |
| // |
| // Key ranges with multiple components are interpreted |
| // lexicographically by component using the table or index key's |
| // declared |
| // sort order. For example, the following range returns all events |
| // for |
| // user "Bob" that occurred in the year 2015: |
| // |
| // "start_closed": ["Bob", "2015-01-01"] |
| // "end_closed": ["Bob", "2015-12-31"] |
| // |
| // Start and end keys can omit trailing key components. This affects |
| // the |
| // inclusion and exclusion of rows that exactly match the provided |
| // key |
| // components: if the key is closed, then rows that exactly match |
| // the |
| // provided components are included; if the key is open, then rows |
| // that exactly match are not included. |
| // |
| // For example, the following range includes all events for "Bob" |
| // that |
| // occurred during and after the year 2000: |
| // |
| // "start_closed": ["Bob", "2000-01-01"] |
| // "end_closed": ["Bob"] |
| // |
| // The next example retrieves all events for "Bob": |
| // |
| // "start_closed": ["Bob"] |
| // "end_closed": ["Bob"] |
| // |
| // To retrieve events before the year 2000: |
| // |
| // "start_closed": ["Bob"] |
| // "end_open": ["Bob", "2000-01-01"] |
| // |
| // The following range includes all rows in the table: |
| // |
| // "start_closed": [] |
| // "end_closed": [] |
| // |
| // This range returns all users whose `UserName` begins with |
| // any |
| // character from A to C: |
| // |
| // "start_closed": ["A"] |
| // "end_open": ["D"] |
| // |
| // This range returns all users whose `UserName` begins with B: |
| // |
| // "start_closed": ["B"] |
| // "end_open": ["C"] |
| // |
| // Key ranges honor column sort order. For example, suppose a table |
| // is |
| // defined as follows: |
| // |
| // CREATE TABLE DescendingSortedTable { |
| // Key INT64, |
| // ... |
| // ) PRIMARY KEY(Key DESC); |
| // |
| // The following range retrieves all rows with key values between 1 |
| // and 100 inclusive: |
| // |
| // "start_closed": ["100"] |
| // "end_closed": ["1"] |
| // |
| // Note that 100 is passed as the start, and 1 is passed as the |
| // end, |
| // because `Key` is a descending column in the schema. |
| type KeyRange struct { |
| // EndClosed: If the end is closed, then the range includes all rows |
| // whose |
| // first `len(end_closed)` key columns exactly match `end_closed`. |
| EndClosed []interface{} `json:"endClosed,omitempty"` |
| |
| // EndOpen: If the end is open, then the range excludes rows whose |
| // first |
| // `len(end_open)` key columns exactly match `end_open`. |
| EndOpen []interface{} `json:"endOpen,omitempty"` |
| |
| // StartClosed: If the start is closed, then the range includes all rows |
| // whose |
| // first `len(start_closed)` key columns exactly match `start_closed`. |
| StartClosed []interface{} `json:"startClosed,omitempty"` |
| |
| // StartOpen: If the start is open, then the range excludes rows whose |
| // first |
| // `len(start_open)` key columns exactly match `start_open`. |
| StartOpen []interface{} `json:"startOpen,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndClosed") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndClosed") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *KeyRange) MarshalJSON() ([]byte, error) { |
| type NoMethod KeyRange |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // KeySet: `KeySet` defines a collection of Cloud Spanner keys and/or |
| // key ranges. All |
| // the keys are expected to be in the same table or index. The keys |
| // need |
| // not be sorted in any particular way. |
| // |
| // If the same key is specified multiple times in the set (for |
| // example |
| // if two ranges, two keys, or a key and a range overlap), Cloud |
| // Spanner |
| // behaves as if the key were only specified once. |
| type KeySet struct { |
| // All: For convenience `all` can be set to `true` to indicate that |
| // this |
| // `KeySet` matches all keys in the table or index. Note that any |
| // keys |
| // specified in `keys` or `ranges` are only yielded once. |
| All bool `json:"all,omitempty"` |
| |
| // Keys: A list of specific keys. Entries in `keys` should have exactly |
| // as |
| // many elements as there are columns in the primary or index key |
| // with which this `KeySet` is used. Individual key values are |
| // encoded as described here. |
| Keys [][]interface{} `json:"keys,omitempty"` |
| |
| // Ranges: A list of key ranges. See KeyRange for more information |
| // about |
| // key range specifications. |
| Ranges []*KeyRange `json:"ranges,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "All") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "All") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *KeySet) MarshalJSON() ([]byte, error) { |
| type NoMethod KeySet |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListDatabasesResponse: The response for ListDatabases. |
| type ListDatabasesResponse struct { |
| // Databases: Databases that matched the request. |
| Databases []*Database `json:"databases,omitempty"` |
| |
| // NextPageToken: `next_page_token` can be sent in a |
| // subsequent |
| // ListDatabases call to fetch more |
| // of the matching databases. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Databases") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Databases") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListDatabasesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListDatabasesResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListInstanceConfigsResponse: The response for ListInstanceConfigs. |
| type ListInstanceConfigsResponse struct { |
| // InstanceConfigs: The list of requested instance configurations. |
| InstanceConfigs []*InstanceConfig `json:"instanceConfigs,omitempty"` |
| |
| // NextPageToken: `next_page_token` can be sent in a |
| // subsequent |
| // ListInstanceConfigs call to |
| // fetch more of the matching instance configurations. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "InstanceConfigs") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "InstanceConfigs") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListInstanceConfigsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListInstanceConfigsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListInstancesResponse: The response for ListInstances. |
| type ListInstancesResponse struct { |
| // Instances: The list of requested instances. |
| Instances []*Instance `json:"instances,omitempty"` |
| |
| // NextPageToken: `next_page_token` can be sent in a |
| // subsequent |
| // ListInstances call to fetch more |
| // of the matching instances. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Instances") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Instances") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListInstancesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListInstancesResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListOperationsResponse: The response message for |
| // Operations.ListOperations. |
| type ListOperationsResponse struct { |
| // NextPageToken: The standard List next-page token. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Operations: A list of operations that matches the specified filter in |
| // the request. |
| Operations []*Operation `json:"operations,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListOperationsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListSessionsResponse: The response for ListSessions. |
| type ListSessionsResponse struct { |
| // NextPageToken: `next_page_token` can be sent in a |
| // subsequent |
| // ListSessions call to fetch more of the matching |
| // sessions. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Sessions: The list of requested sessions. |
| Sessions []*Session `json:"sessions,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListSessionsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListSessionsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Mutation: A modification to one or more Cloud Spanner rows. |
| // Mutations can be |
| // applied to a Cloud Spanner database by sending them in a |
| // Commit call. |
| type Mutation struct { |
| // Delete: Delete rows from a table. Succeeds whether or not the |
| // named |
| // rows were present. |
| Delete *Delete `json:"delete,omitempty"` |
| |
| // Insert: Insert new rows in a table. If any of the rows already |
| // exist, |
| // the write or transaction fails with error `ALREADY_EXISTS`. |
| Insert *Write `json:"insert,omitempty"` |
| |
| // InsertOrUpdate: Like insert, except that if the row already exists, |
| // then |
| // its column values are overwritten with the ones provided. Any |
| // column values not explicitly written are preserved. |
| InsertOrUpdate *Write `json:"insertOrUpdate,omitempty"` |
| |
| // Replace: Like insert, except that if the row already exists, it |
| // is |
| // deleted, and the column values provided are inserted |
| // instead. Unlike insert_or_update, this means any values |
| // not |
| // explicitly written become `NULL`. |
| // |
| // In an interleaved table, if you create the child table with the |
| // `ON DELETE CASCADE` annotation, then replacing a parent row |
| // also deletes the child rows. Otherwise, you must delete the |
| // child rows before you replace the parent row. |
| Replace *Write `json:"replace,omitempty"` |
| |
| // Update: Update existing rows in a table. If any of the rows does |
| // not |
| // already exist, the transaction fails with error `NOT_FOUND`. |
| Update *Write `json:"update,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Delete") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Delete") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Mutation) MarshalJSON() ([]byte, error) { |
| type NoMethod Mutation |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Operation: This resource represents a long-running operation that is |
| // the result of a |
| // network API call. |
| type Operation struct { |
| // Done: If the value is `false`, it means the operation is still in |
| // progress. |
| // If `true`, the operation is completed, and either `error` or |
| // `response` is |
| // available. |
| Done bool `json:"done,omitempty"` |
| |
| // Error: The error result of the operation in case of failure or |
| // cancellation. |
| Error *Status `json:"error,omitempty"` |
| |
| // Metadata: Service-specific metadata associated with the operation. |
| // It typically |
| // contains progress information and common metadata such as create |
| // time. |
| // Some services might not provide such metadata. Any method that |
| // returns a |
| // long-running operation should document the metadata type, if any. |
| Metadata googleapi.RawMessage `json:"metadata,omitempty"` |
| |
| // Name: The server-assigned name, which is only unique within the same |
| // service that |
| // originally returns it. If you use the default HTTP mapping, |
| // the |
| // `name` should be a resource name ending with |
| // `operations/{unique_id}`. |
| Name string `json:"name,omitempty"` |
| |
| // Response: The normal response of the operation in case of success. |
| // If the original |
| // method returns no data on success, such as `Delete`, the response |
| // is |
| // `google.protobuf.Empty`. If the original method is |
| // standard |
| // `Get`/`Create`/`Update`, the response should be the resource. For |
| // other |
| // methods, the response should have the type `XxxResponse`, where |
| // `Xxx` |
| // is the original method name. For example, if the original method |
| // name |
| // is `TakeSnapshot()`, the inferred response type |
| // is |
| // `TakeSnapshotResponse`. |
| Response googleapi.RawMessage `json:"response,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Done") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Done") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Operation) MarshalJSON() ([]byte, error) { |
| type NoMethod Operation |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartialResultSet: Partial results from a streaming read or SQL query. |
| // Streaming reads and |
| // SQL queries better tolerate large result sets, large rows, and |
| // large |
| // values, but are a little trickier to consume. |
| type PartialResultSet struct { |
| // ChunkedValue: If true, then the final value in values is chunked, and |
| // must |
| // be combined with more values from subsequent `PartialResultSet`s |
| // to obtain a complete field value. |
| ChunkedValue bool `json:"chunkedValue,omitempty"` |
| |
| // Metadata: Metadata about the result set, such as row type |
| // information. |
| // Only present in the first response. |
| Metadata *ResultSetMetadata `json:"metadata,omitempty"` |
| |
| // ResumeToken: Streaming calls might be interrupted for a variety of |
| // reasons, such |
| // as TCP connection loss. If this occurs, the stream of results can |
| // be resumed by re-sending the original request and |
| // including |
| // `resume_token`. Note that executing any other transaction in the |
| // same session invalidates the token. |
| ResumeToken string `json:"resumeToken,omitempty"` |
| |
| // Stats: Query plan and execution statistics for the statement that |
| // produced this |
| // streaming result set. These can be requested by |
| // setting |
| // ExecuteSqlRequest.query_mode and are sent |
| // only once with the last response in the stream. |
| // This field will also be present in the last response for |
| // DML |
| // statements. |
| Stats *ResultSetStats `json:"stats,omitempty"` |
| |
| // Values: A streamed result set consists of a stream of values, which |
| // might |
| // be split into many `PartialResultSet` messages to accommodate |
| // large rows and/or large values. Every N complete values defines |
| // a |
| // row, where N is equal to the number of entries |
| // in |
| // metadata.row_type.fields. |
| // |
| // Most values are encoded based on type as described |
| // here. |
| // |
| // It is possible that the last value in values is "chunked", |
| // meaning that the rest of the value is sent in |
| // subsequent |
| // `PartialResultSet`(s). This is denoted by the chunked_value |
| // field. Two or more chunked values can be merged to form a |
| // complete value as follows: |
| // |
| // * `bool/number/null`: cannot be chunked |
| // * `string`: concatenate the strings |
| // * `list`: concatenate the lists. If the last element in a list is |
| // a |
| // `string`, `list`, or `object`, merge it with the first element |
| // in |
| // the next list by applying these rules recursively. |
| // * `object`: concatenate the (field name, field value) pairs. If a |
| // field name is duplicated, then apply these rules recursively |
| // to merge the field values. |
| // |
| // Some examples of merging: |
| // |
| // # Strings are concatenated. |
| // "foo", "bar" => "foobar" |
| // |
| // # Lists of non-strings are concatenated. |
| // [2, 3], [4] => [2, 3, 4] |
| // |
| // # Lists are concatenated, but the last and first elements are |
| // merged |
| // # because they are strings. |
| // ["a", "b"], ["c", "d"] => ["a", "bc", "d"] |
| // |
| // # Lists are concatenated, but the last and first elements are |
| // merged |
| // # because they are lists. Recursively, the last and first |
| // elements |
| // # of the inner lists are merged because they are strings. |
| // ["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"] |
| // |
| // # Non-overlapping object fields are combined. |
| // {"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"} |
| // |
| // # Overlapping object fields are merged. |
| // {"a": "1"}, {"a": "2"} => {"a": "12"} |
| // |
| // # Examples of merging objects containing lists of strings. |
| // {"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]} |
| // |
| // For a more complete example, suppose a streaming SQL query |
| // is |
| // yielding a result set whose rows contain a single string |
| // field. The following `PartialResultSet`s might be yielded: |
| // |
| // { |
| // "metadata": { ... } |
| // "values": ["Hello", "W"] |
| // "chunked_value": true |
| // "resume_token": "Af65..." |
| // } |
| // { |
| // "values": ["orl"] |
| // "chunked_value": true |
| // "resume_token": "Bqp2..." |
| // } |
| // { |
| // "values": ["d"] |
| // "resume_token": "Zx1B..." |
| // } |
| // |
| // This sequence of `PartialResultSet`s encodes two rows, one |
| // containing the field value "Hello", and a second containing |
| // the |
| // field value "World" = "W" + "orl" + "d". |
| Values []interface{} `json:"values,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ChunkedValue") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ChunkedValue") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PartialResultSet) MarshalJSON() ([]byte, error) { |
| type NoMethod PartialResultSet |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Partition: Information returned for each partition returned in |
| // a |
| // PartitionResponse. |
| type Partition struct { |
| // PartitionToken: This token can be passed to Read, StreamingRead, |
| // ExecuteSql, or |
| // ExecuteStreamingSql requests to restrict the results to those |
| // identified by |
| // this partition token. |
| PartitionToken string `json:"partitionToken,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "PartitionToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "PartitionToken") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Partition) MarshalJSON() ([]byte, error) { |
| type NoMethod Partition |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartitionOptions: Options for a PartitionQueryRequest |
| // and |
| // PartitionReadRequest. |
| type PartitionOptions struct { |
| // MaxPartitions: **Note:** This hint is currently ignored by |
| // PartitionQuery and |
| // PartitionRead requests. |
| // |
| // The desired maximum number of partitions to return. For example, |
| // this may |
| // be set to the number of workers available. The default for this |
| // option |
| // is currently 10,000. The maximum value is currently 200,000. This is |
| // only |
| // a hint. The actual number of partitions returned may be smaller or |
| // larger |
| // than this maximum count request. |
| MaxPartitions int64 `json:"maxPartitions,omitempty,string"` |
| |
| // PartitionSizeBytes: **Note:** This hint is currently ignored by |
| // PartitionQuery and |
| // PartitionRead requests. |
| // |
| // The desired data size for each partition generated. The default for |
| // this |
| // option is currently 1 GiB. This is only a hint. The actual size of |
| // each |
| // partition may be smaller or larger than this size request. |
| PartitionSizeBytes int64 `json:"partitionSizeBytes,omitempty,string"` |
| |
| // ForceSendFields is a list of field names (e.g. "MaxPartitions") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "MaxPartitions") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PartitionOptions) MarshalJSON() ([]byte, error) { |
| type NoMethod PartitionOptions |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartitionQueryRequest: The request for PartitionQuery |
| type PartitionQueryRequest struct { |
| // ParamTypes: It is not always possible for Cloud Spanner to infer the |
| // right SQL type |
| // from a JSON value. For example, values of type `BYTES` and values |
| // of type `STRING` both appear in params as JSON strings. |
| // |
| // In these cases, `param_types` can be used to specify the exact |
| // SQL type for some or all of the SQL query parameters. See |
| // the |
| // definition of Type for more information |
| // about SQL types. |
| ParamTypes map[string]Type `json:"paramTypes,omitempty"` |
| |
| // Params: Parameter names and values that bind to placeholders in the |
| // SQL string. |
| // |
| // A parameter placeholder consists of the `@` character followed by |
| // the |
| // parameter name (for example, `@firstName`). Parameter names can |
| // contain |
| // letters, numbers, and underscores. |
| // |
| // Parameters can appear anywhere that a literal value is expected. The |
| // same |
| // parameter name can be used more than once, for example: |
| // |
| // "WHERE id > @msg_id AND id < @msg_id + 100" |
| // |
| // It is an error to execute a SQL statement with unbound parameters. |
| Params googleapi.RawMessage `json:"params,omitempty"` |
| |
| // PartitionOptions: Additional options that affect how many partitions |
| // are created. |
| PartitionOptions *PartitionOptions `json:"partitionOptions,omitempty"` |
| |
| // Sql: The query request to generate partitions for. The request will |
| // fail if |
| // the query is not root partitionable. The query plan of a |
| // root |
| // partitionable query has a single distributed union operator. A |
| // distributed |
| // union operator conceptually divides one or more tables into |
| // multiple |
| // splits, remotely evaluates a subquery independently on each split, |
| // and |
| // then unions all results. |
| // |
| // This must not contain DML commands, such as INSERT, UPDATE, |
| // or |
| // DELETE. Use ExecuteStreamingSql with a |
| // PartitionedDml transaction for large, partition-friendly DML |
| // operations. |
| Sql string `json:"sql,omitempty"` |
| |
| // Transaction: Read only snapshot transactions are supported, |
| // read/write and single use |
| // transactions are not. |
| Transaction *TransactionSelector `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ParamTypes") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ParamTypes") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PartitionQueryRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod PartitionQueryRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartitionReadRequest: The request for PartitionRead |
| type PartitionReadRequest struct { |
| // Columns: The columns of table to be returned for each row |
| // matching |
| // this request. |
| Columns []string `json:"columns,omitempty"` |
| |
| // Index: If non-empty, the name of an index on table. This index |
| // is |
| // used instead of the table primary key when interpreting key_set |
| // and sorting result rows. See key_set for further information. |
| Index string `json:"index,omitempty"` |
| |
| // KeySet: Required. `key_set` identifies the rows to be yielded. |
| // `key_set` names the |
| // primary keys of the rows in table to be yielded, unless index |
| // is present. If index is present, then key_set instead names |
| // index keys in index. |
| // |
| // It is not an error for the `key_set` to name rows that do not |
| // exist in the database. Read yields nothing for nonexistent rows. |
| KeySet *KeySet `json:"keySet,omitempty"` |
| |
| // PartitionOptions: Additional options that affect how many partitions |
| // are created. |
| PartitionOptions *PartitionOptions `json:"partitionOptions,omitempty"` |
| |
| // Table: Required. The name of the table in the database to be read. |
| Table string `json:"table,omitempty"` |
| |
| // Transaction: Read only snapshot transactions are supported, |
| // read/write and single use |
| // transactions are not. |
| Transaction *TransactionSelector `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Columns") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Columns") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PartitionReadRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod PartitionReadRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartitionResponse: The response for PartitionQuery |
| // or PartitionRead |
| type PartitionResponse struct { |
| // Partitions: Partitions created by this request. |
| Partitions []*Partition `json:"partitions,omitempty"` |
| |
| // Transaction: Transaction created by this request. |
| Transaction *Transaction `json:"transaction,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Partitions") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Partitions") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PartitionResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod PartitionResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // PartitionedDml: Message type to initiate a Partitioned DML |
| // transaction. |
| type PartitionedDml struct { |
| } |
| |
| // PlanNode: Node information for nodes appearing in a |
| // QueryPlan.plan_nodes. |
| type PlanNode struct { |
| // ChildLinks: List of child node `index`es and their relationship to |
| // this parent. |
| ChildLinks []*ChildLink `json:"childLinks,omitempty"` |
| |
| // DisplayName: The display name for the node. |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // ExecutionStats: The execution statistics associated with the node, |
| // contained in a group of |
| // key-value pairs. Only present if the plan was returned as a result of |
| // a |
| // profile query. For example, number of executions, number of rows/time |
| // per |
| // execution etc. |
| ExecutionStats googleapi.RawMessage `json:"executionStats,omitempty"` |
| |
| // Index: The `PlanNode`'s index in node list. |
| Index int64 `json:"index,omitempty"` |
| |
| // Kind: Used to determine the type of node. May be needed for |
| // visualizing |
| // different kinds of nodes differently. For example, If the node is |
| // a |
| // SCALAR node, it will have a condensed representation |
| // which can be used to directly embed a description of the node in |
| // its |
| // parent. |
| // |
| // Possible values: |
| // "KIND_UNSPECIFIED" - Not specified. |
| // "RELATIONAL" - Denotes a Relational operator node in the expression |
| // tree. Relational |
| // operators represent iterative processing of rows during query |
| // execution. |
| // For example, a `TableScan` operation that reads rows from a table. |
| // "SCALAR" - Denotes a Scalar node in the expression tree. Scalar |
| // nodes represent |
| // non-iterable entities in the query plan. For example, constants |
| // or |
| // arithmetic operators appearing inside predicate expressions or |
| // references |
| // to column names. |
| Kind string `json:"kind,omitempty"` |
| |
| // Metadata: Attributes relevant to the node contained in a group of |
| // key-value pairs. |
| // For example, a Parameter Reference node could have the |
| // following |
| // information in its metadata: |
| // |
| // { |
| // "parameter_reference": "param1", |
| // "parameter_type": "array" |
| // } |
| Metadata googleapi.RawMessage `json:"metadata,omitempty"` |
| |
| // ShortRepresentation: Condensed representation for SCALAR nodes. |
| ShortRepresentation *ShortRepresentation `json:"shortRepresentation,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ChildLinks") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ChildLinks") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PlanNode) MarshalJSON() ([]byte, error) { |
| type NoMethod PlanNode |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Policy: Defines an Identity and Access Management (IAM) policy. It is |
| // used to |
| // specify access control policies for Cloud Platform resources. |
| // |
| // |
| // A `Policy` is a collection of `bindings`. A `binding` binds one or |
| // more |
| // `members` to a single `role`. Members can be user accounts, service |
| // accounts, |
| // Google groups, and domains (such as G Suite). A `role` is a named |
| // list of |
| // permissions (defined by IAM or configured by users). A `binding` |
| // can |
| // optionally specify a `condition`, which is a logic expression that |
| // further |
| // constrains the role binding based on attributes about the request |
| // and/or |
| // target resource. |
| // |
| // **JSON Example** |
| // |
| // { |
| // "bindings": [ |
| // { |
| // "role": "roles/resourcemanager.organizationAdmin", |
| // "members": [ |
| // "user:mike@example.com", |
| // "group:admins@example.com", |
| // "domain:google.com", |
| // |
| // "serviceAccount:my-project-id@appspot.gserviceaccount.com" |
| // ] |
| // }, |
| // { |
| // "role": "roles/resourcemanager.organizationViewer", |
| // "members": ["user:eve@example.com"], |
| // "condition": { |
| // "title": "expirable access", |
| // "description": "Does not grant access after Sep 2020", |
| // "expression": "request.time < |
| // timestamp('2020-10-01T00:00:00.000Z')", |
| // } |
| // } |
| // ] |
| // } |
| // |
| // **YAML Example** |
| // |
| // bindings: |
| // - members: |
| // - user:mike@example.com |
| // - group:admins@example.com |
| // - domain:google.com |
| // - serviceAccount:my-project-id@appspot.gserviceaccount.com |
| // role: roles/resourcemanager.organizationAdmin |
| // - members: |
| // - user:eve@example.com |
| // role: roles/resourcemanager.organizationViewer |
| // condition: |
| // title: expirable access |
| // description: Does not grant access after Sep 2020 |
| // expression: request.time < |
| // timestamp('2020-10-01T00:00:00.000Z') |
| // |
| // For a description of IAM and its features, see the |
| // [IAM developer's guide](https://cloud.google.com/iam/docs). |
| type Policy struct { |
| // Bindings: Associates a list of `members` to a `role`. Optionally may |
| // specify a |
| // `condition` that determines when binding is in effect. |
| // `bindings` with no members will result in an error. |
| Bindings []*Binding `json:"bindings,omitempty"` |
| |
| // Etag: `etag` is used for optimistic concurrency control as a way to |
| // help |
| // prevent simultaneous updates of a policy from overwriting each |
| // other. |
| // It is strongly suggested that systems make use of the `etag` in |
| // the |
| // read-modify-write cycle to perform policy updates in order to avoid |
| // race |
| // conditions: An `etag` is returned in the response to `getIamPolicy`, |
| // and |
| // systems are expected to put that etag in the request to |
| // `setIamPolicy` to |
| // ensure that their change will be applied to the same version of the |
| // policy. |
| // |
| // If no `etag` is provided in the call to `setIamPolicy`, then the |
| // existing |
| // policy is overwritten. Due to blind-set semantics of an etag-less |
| // policy, |
| // 'setIamPolicy' will not fail even if either of incoming or stored |
| // policy |
| // does not meet the version requirements. |
| Etag string `json:"etag,omitempty"` |
| |
| // Version: Specifies the format of the policy. |
| // |
| // Valid values are 0, 1, and 3. Requests specifying an invalid value |
| // will be |
| // rejected. |
| // |
| // Operations affecting conditional bindings must specify version 3. |
| // This can |
| // be either setting a conditional policy, modifying a conditional |
| // binding, |
| // or removing a conditional binding from the stored conditional |
| // policy. |
| // Operations on non-conditional policies may specify any valid value |
| // or |
| // leave the field unset. |
| // |
| // If no etag is provided in the call to `setIamPolicy`, any |
| // version |
| // compliance checks on the incoming and/or stored policy is skipped. |
| Version int64 `json:"version,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Bindings") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Bindings") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Policy) MarshalJSON() ([]byte, error) { |
| type NoMethod Policy |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // QueryPlan: Contains an ordered list of nodes appearing in the query |
| // plan. |
| type QueryPlan struct { |
| // PlanNodes: The nodes in the query plan. Plan nodes are returned in |
| // pre-order starting |
| // with the plan root. Each PlanNode's `id` corresponds to its index |
| // in |
| // `plan_nodes`. |
| PlanNodes []*PlanNode `json:"planNodes,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "PlanNodes") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "PlanNodes") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *QueryPlan) MarshalJSON() ([]byte, error) { |
| type NoMethod QueryPlan |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ReadOnly: Message type to initiate a read-only transaction. |
| type ReadOnly struct { |
| // ExactStaleness: Executes all reads at a timestamp that is |
| // `exact_staleness` |
| // old. The timestamp is chosen soon after the read is |
| // started. |
| // |
| // Guarantees that all writes that have committed more than |
| // the |
| // specified number of seconds ago are visible. Because Cloud |
| // Spanner |
| // chooses the exact timestamp, this mode works even if the |
| // client's |
| // local clock is substantially skewed from Cloud Spanner |
| // commit |
| // timestamps. |
| // |
| // Useful for reading at nearby replicas without the |
| // distributed |
| // timestamp negotiation overhead of `max_staleness`. |
| ExactStaleness string `json:"exactStaleness,omitempty"` |
| |
| // MaxStaleness: Read data at a timestamp >= `NOW - |
| // max_staleness` |
| // seconds. Guarantees that all writes that have committed more |
| // than the specified number of seconds ago are visible. Because |
| // Cloud Spanner chooses the exact timestamp, this mode works even |
| // if |
| // the client's local clock is substantially skewed from Cloud |
| // Spanner |
| // commit timestamps. |
| // |
| // Useful for reading the freshest data available at a nearby |
| // replica, while bounding the possible staleness if the local |
| // replica has fallen behind. |
| // |
| // Note that this option can only be used in single-use |
| // transactions. |
| MaxStaleness string `json:"maxStaleness,omitempty"` |
| |
| // MinReadTimestamp: Executes all reads at a timestamp >= |
| // `min_read_timestamp`. |
| // |
| // This is useful for requesting fresher data than some previous |
| // read, or data that is fresh enough to observe the effects of |
| // some |
| // previously committed transaction whose timestamp is known. |
| // |
| // Note that this option can only be used in single-use transactions. |
| // |
| // A timestamp in RFC3339 UTC \"Zulu\" format, accurate to |
| // nanoseconds. |
| // Example: "2014-10-02T15:01:23.045123456Z". |
| MinReadTimestamp string `json:"minReadTimestamp,omitempty"` |
| |
| // ReadTimestamp: Executes all reads at the given timestamp. Unlike |
| // other modes, |
| // reads at a specific timestamp are repeatable; the same read at |
| // the same timestamp always returns the same data. If the |
| // timestamp is in the future, the read will block until the |
| // specified timestamp, modulo the read's deadline. |
| // |
| // Useful for large scale consistent reads such as mapreduces, or |
| // for coordinating many reads against a consistent snapshot of |
| // the |
| // data. |
| // |
| // A timestamp in RFC3339 UTC \"Zulu\" format, accurate to |
| // nanoseconds. |
| // Example: "2014-10-02T15:01:23.045123456Z". |
| ReadTimestamp string `json:"readTimestamp,omitempty"` |
| |
| // ReturnReadTimestamp: If true, the Cloud Spanner-selected read |
| // timestamp is included in |
| // the Transaction message that describes the transaction. |
| ReturnReadTimestamp bool `json:"returnReadTimestamp,omitempty"` |
| |
| // Strong: Read at a timestamp where all previously committed |
| // transactions |
| // are visible. |
| Strong bool `json:"strong,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ExactStaleness") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ExactStaleness") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ReadOnly) MarshalJSON() ([]byte, error) { |
| type NoMethod ReadOnly |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ReadRequest: The request for Read and |
| // StreamingRead. |
| type ReadRequest struct { |
| // Columns: The columns of table to be returned for each row |
| // matching |
| // this request. |
| Columns []string `json:"columns,omitempty"` |
| |
| // Index: If non-empty, the name of an index on table. This index |
| // is |
| // used instead of the table primary key when interpreting key_set |
| // and sorting result rows. See key_set for further information. |
| Index string `json:"index,omitempty"` |
| |
| // KeySet: Required. `key_set` identifies the rows to be yielded. |
| // `key_set` names the |
| // primary keys of the rows in table to be yielded, unless index |
| // is present. If index is present, then key_set instead names |
| // index keys in index. |
| // |
| // If the partition_token field is empty, rows are yielded |
| // in table primary key order (if index is empty) or index key order |
| // (if index is non-empty). If the partition_token field is not |
| // empty, rows will be yielded in an unspecified order. |
| // |
| // It is not an error for the `key_set` to name rows that do not |
| // exist in the database. Read yields nothing for nonexistent rows. |
| KeySet *KeySet `json:"keySet,omitempty"` |
| |
| // Limit: If greater than zero, only the first `limit` rows are yielded. |
| // If `limit` |
| // is zero, the default is no limit. A limit cannot be specified |
| // if |
| // `partition_token` is set. |
| Limit int64 `json:"limit,omitempty,string"` |
| |
| // PartitionToken: If present, results will be restricted to the |
| // specified partition |
| // previously created using PartitionRead(). There must be an |
| // exact |
| // match for the values of fields common to this message and |
| // the |
| // PartitionReadRequest message used to create this partition_token. |
| PartitionToken string `json:"partitionToken,omitempty"` |
| |
| // ResumeToken: If this request is resuming a previously interrupted |
| // read, |
| // `resume_token` should be copied from the last |
| // PartialResultSet yielded before the interruption. Doing this |
| // enables the new read to resume where the last read left off. The |
| // rest of the request parameters must exactly match the request |
| // that yielded this token. |
| ResumeToken string `json:"resumeToken,omitempty"` |
| |
| // Table: Required. The name of the table in the database to be read. |
| Table string `json:"table,omitempty"` |
| |
| // Transaction: The transaction to use. If none is provided, the default |
| // is a |
| // temporary read-only transaction with strong concurrency. |
| Transaction *TransactionSelector `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Columns") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Columns") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ReadRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod ReadRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ReadWrite: Message type to initiate a read-write transaction. |
| // Currently this |
| // transaction type has no options. |
| type ReadWrite struct { |
| } |
| |
| type ReplicaInfo struct { |
| // DefaultLeaderLocation: If true, this location is designated as the |
| // default leader location where |
| // leader replicas are placed. See the [region |
| // types |
| // documentation](https://cloud.google.com/spanner/docs/instances#r |
| // egion_types) |
| // for more details. |
| DefaultLeaderLocation bool `json:"defaultLeaderLocation,omitempty"` |
| |
| // Location: The location of the serving resources, e.g. "us-central1". |
| Location string `json:"location,omitempty"` |
| |
| // Type: The type of replica. |
| // |
| // Possible values: |
| // "TYPE_UNSPECIFIED" - Not specified. |
| // "READ_WRITE" - Read-write replicas support both reads and writes. |
| // These replicas: |
| // |
| // * Maintain a full copy of your data. |
| // * Serve reads. |
| // * Can vote whether to commit a write. |
| // * Participate in leadership election. |
| // * Are eligible to become a leader. |
| // "READ_ONLY" - Read-only replicas only support reads (not writes). |
| // Read-only replicas: |
| // |
| // * Maintain a full copy of your data. |
| // * Serve reads. |
| // * Do not participate in voting to commit writes. |
| // * Are not eligible to become a leader. |
| // "WITNESS" - Witness replicas don't support reads but do participate |
| // in voting to |
| // commit writes. Witness replicas: |
| // |
| // * Do not maintain a full copy of data. |
| // * Do not serve reads. |
| // * Vote whether to commit writes. |
| // * Participate in leader election but are not eligible to become |
| // leader. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "DefaultLeaderLocation") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DefaultLeaderLocation") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ReplicaInfo) MarshalJSON() ([]byte, error) { |
| type NoMethod ReplicaInfo |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ResultSet: Results from Read or |
| // ExecuteSql. |
| type ResultSet struct { |
| // Metadata: Metadata about the result set, such as row type |
| // information. |
| Metadata *ResultSetMetadata `json:"metadata,omitempty"` |
| |
| // Rows: Each element in `rows` is a row whose format is defined |
| // by |
| // metadata.row_type. The ith element |
| // in each row matches the ith field in |
| // metadata.row_type. Elements are |
| // encoded based on type as described |
| // here. |
| Rows [][]interface{} `json:"rows,omitempty"` |
| |
| // Stats: Query plan and execution statistics for the SQL statement |
| // that |
| // produced this result set. These can be requested by |
| // setting |
| // ExecuteSqlRequest.query_mode. |
| // DML statements always produce stats containing the number of |
| // rows |
| // modified, unless executed using the |
| // ExecuteSqlRequest.QueryMode.PLAN ExecuteSqlRequest.query_mode. |
| // Other fields may or may not be populated, based on |
| // the |
| // ExecuteSqlRequest.query_mode. |
| Stats *ResultSetStats `json:"stats,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Metadata") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Metadata") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ResultSet) MarshalJSON() ([]byte, error) { |
| type NoMethod ResultSet |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ResultSetMetadata: Metadata about a ResultSet or PartialResultSet. |
| type ResultSetMetadata struct { |
| // RowType: Indicates the field names and types for the rows in the |
| // result |
| // set. For example, a SQL query like "SELECT UserId, UserName |
| // FROM |
| // Users" could return a `row_type` value like: |
| // |
| // "fields": [ |
| // { "name": "UserId", "type": { "code": "INT64" } }, |
| // { "name": "UserName", "type": { "code": "STRING" } }, |
| // ] |
| RowType *StructType `json:"rowType,omitempty"` |
| |
| // Transaction: If the read or SQL query began a transaction as a |
| // side-effect, the |
| // information about the new transaction is yielded here. |
| Transaction *Transaction `json:"transaction,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "RowType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "RowType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ResultSetMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod ResultSetMetadata |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ResultSetStats: Additional statistics about a ResultSet or |
| // PartialResultSet. |
| type ResultSetStats struct { |
| // QueryPlan: QueryPlan for the query associated with this result. |
| QueryPlan *QueryPlan `json:"queryPlan,omitempty"` |
| |
| // QueryStats: Aggregated statistics from the execution of the query. |
| // Only present when |
| // the query is profiled. For example, a query could return the |
| // statistics as |
| // follows: |
| // |
| // { |
| // "rows_returned": "3", |
| // "elapsed_time": "1.22 secs", |
| // "cpu_time": "1.19 secs" |
| // } |
| QueryStats googleapi.RawMessage `json:"queryStats,omitempty"` |
| |
| // RowCountExact: Standard DML returns an exact count of rows that were |
| // modified. |
| RowCountExact int64 `json:"rowCountExact,omitempty,string"` |
| |
| // RowCountLowerBound: Partitioned DML does not offer exactly-once |
| // semantics, so it |
| // returns a lower bound of the rows modified. |
| RowCountLowerBound int64 `json:"rowCountLowerBound,omitempty,string"` |
| |
| // ForceSendFields is a list of field names (e.g. "QueryPlan") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "QueryPlan") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ResultSetStats) MarshalJSON() ([]byte, error) { |
| type NoMethod ResultSetStats |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // RollbackRequest: The request for Rollback. |
| type RollbackRequest struct { |
| // TransactionId: Required. The transaction to roll back. |
| TransactionId string `json:"transactionId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "TransactionId") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "TransactionId") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *RollbackRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod RollbackRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Session: A session in the Cloud Spanner API. |
| type Session struct { |
| // ApproximateLastUseTime: Output only. The approximate timestamp when |
| // the session is last used. It is |
| // typically earlier than the actual last use time. |
| ApproximateLastUseTime string `json:"approximateLastUseTime,omitempty"` |
| |
| // CreateTime: Output only. The timestamp when the session is created. |
| CreateTime string `json:"createTime,omitempty"` |
| |
| // Labels: The labels for the session. |
| // |
| // * Label keys must be between 1 and 63 characters long and must |
| // conform to |
| // the following regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`. |
| // * Label values must be between 0 and 63 characters long and must |
| // conform |
| // to the regular expression `([a-z]([-a-z0-9]*[a-z0-9])?)?`. |
| // * No more than 64 labels can be associated with a given |
| // session. |
| // |
| // See https://goo.gl/xmQnxf for more information on and examples of |
| // labels. |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // Name: The name of the session. This is always system-assigned; values |
| // provided |
| // when creating a session are ignored. |
| Name string `json:"name,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "ApproximateLastUseTime") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ApproximateLastUseTime") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Session) MarshalJSON() ([]byte, error) { |
| type NoMethod Session |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // SetIamPolicyRequest: Request message for `SetIamPolicy` method. |
| type SetIamPolicyRequest struct { |
| // Policy: REQUIRED: The complete policy to be applied to the |
| // `resource`. The size of |
| // the policy is limited to a few 10s of KB. An empty policy is a |
| // valid policy but certain Cloud Platform services (such as |
| // Projects) |
| // might reject them. |
| Policy *Policy `json:"policy,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Policy") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Policy") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SetIamPolicyRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod SetIamPolicyRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ShortRepresentation: Condensed representation of a node and its |
| // subtree. Only present for |
| // `SCALAR` PlanNode(s). |
| type ShortRepresentation struct { |
| // Description: A string representation of the expression subtree rooted |
| // at this node. |
| Description string `json:"description,omitempty"` |
| |
| // Subqueries: A mapping of (subquery variable name) -> (subquery node |
| // id) for cases |
| // where the `description` string of this node references a |
| // `SCALAR` |
| // subquery contained in the expression subtree rooted at this node. |
| // The |
| // referenced `SCALAR` subquery may not necessarily be a direct child |
| // of |
| // this node. |
| Subqueries map[string]int64 `json:"subqueries,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ShortRepresentation) MarshalJSON() ([]byte, error) { |
| type NoMethod ShortRepresentation |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Statement: A single DML statement. |
| type Statement struct { |
| // ParamTypes: It is not always possible for Cloud Spanner to infer the |
| // right SQL type |
| // from a JSON value. For example, values of type `BYTES` and values |
| // of type `STRING` both appear in params as JSON strings. |
| // |
| // In these cases, `param_types` can be used to specify the exact |
| // SQL type for some or all of the SQL statement parameters. See |
| // the |
| // definition of Type for more information |
| // about SQL types. |
| ParamTypes map[string]Type `json:"paramTypes,omitempty"` |
| |
| // Params: Parameter names and values that bind to placeholders in the |
| // DML string. |
| // |
| // A parameter placeholder consists of the `@` character followed by |
| // the |
| // parameter name (for example, `@firstName`). Parameter names can |
| // contain |
| // letters, numbers, and underscores. |
| // |
| // Parameters can appear anywhere that a literal value is expected. |
| // The |
| // same parameter name can be used more than once, for example: |
| // |
| // "WHERE id > @msg_id AND id < @msg_id + 100" |
| // |
| // It is an error to execute a SQL statement with unbound parameters. |
| Params googleapi.RawMessage `json:"params,omitempty"` |
| |
| // Sql: Required. The DML string. |
| Sql string `json:"sql,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ParamTypes") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ParamTypes") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Statement) MarshalJSON() ([]byte, error) { |
| type NoMethod Statement |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Status: The `Status` type defines a logical error model that is |
| // suitable for |
| // different programming environments, including REST APIs and RPC APIs. |
| // It is |
| // used by [gRPC](https://github.com/grpc). Each `Status` message |
| // contains |
| // three pieces of data: error code, error message, and error |
| // details. |
| // |
| // You can find out more about this error model and how to work with it |
| // in the |
| // [API Design Guide](https://cloud.google.com/apis/design/errors). |
| type Status struct { |
| // Code: The status code, which should be an enum value of |
| // google.rpc.Code. |
| Code int64 `json:"code,omitempty"` |
| |
| // Details: A list of messages that carry the error details. There is a |
| // common set of |
| // message types for APIs to use. |
| Details []googleapi.RawMessage `json:"details,omitempty"` |
| |
| // Message: A developer-facing error message, which should be in |
| // English. Any |
| // user-facing error message should be localized and sent in |
| // the |
| // google.rpc.Status.details field, or localized by the client. |
| Message string `json:"message,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Code") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Code") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Status) MarshalJSON() ([]byte, error) { |
| type NoMethod Status |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // StructType: `StructType` defines the fields of a STRUCT type. |
| type StructType struct { |
| // Fields: The list of fields that make up this struct. Order |
| // is |
| // significant, because values of this struct type are represented |
| // as |
| // lists, where the order of field values matches the order of |
| // fields in the StructType. In turn, the order of fields |
| // matches the order of columns in a read request, or the order |
| // of |
| // fields in the `SELECT` clause of a query. |
| Fields []*Field `json:"fields,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Fields") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Fields") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *StructType) MarshalJSON() ([]byte, error) { |
| type NoMethod StructType |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // TestIamPermissionsRequest: Request message for `TestIamPermissions` |
| // method. |
| type TestIamPermissionsRequest struct { |
| // Permissions: REQUIRED: The set of permissions to check for |
| // 'resource'. |
| // Permissions with wildcards (such as '*', 'spanner.*', |
| // 'spanner.instances.*') are not allowed. |
| Permissions []string `json:"permissions,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Permissions") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Permissions") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *TestIamPermissionsRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod TestIamPermissionsRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // TestIamPermissionsResponse: Response message for `TestIamPermissions` |
| // method. |
| type TestIamPermissionsResponse struct { |
| // Permissions: A subset of `TestPermissionsRequest.permissions` that |
| // the caller is |
| // allowed. |
| Permissions []string `json:"permissions,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Permissions") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Permissions") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod TestIamPermissionsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Transaction: A transaction. |
| type Transaction struct { |
| // Id: `id` may be used to identify the transaction in |
| // subsequent |
| // Read, |
| // ExecuteSql, |
| // Commit, or |
| // Rollback calls. |
| // |
| // Single-use read-only transactions do not have IDs, because |
| // single-use transactions do not support multiple requests. |
| Id string `json:"id,omitempty"` |
| |
| // ReadTimestamp: For snapshot read-only transactions, the read |
| // timestamp chosen |
| // for the transaction. Not returned by default: |
| // see |
| // TransactionOptions.ReadOnly.return_read_timestamp. |
| // |
| // A timestamp in RFC3339 UTC \"Zulu\" format, accurate to |
| // nanoseconds. |
| // Example: "2014-10-02T15:01:23.045123456Z". |
| ReadTimestamp string `json:"readTimestamp,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Id") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Id") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Transaction) MarshalJSON() ([]byte, error) { |
| type NoMethod Transaction |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // TransactionOptions: # Transactions |
| // |
| // |
| // Each session can have at most one active transaction at a time. After |
| // the |
| // active transaction is completed, the session can immediately |
| // be |
| // re-used for the next transaction. It is not necessary to create a |
| // new session for each transaction. |
| // |
| // # Transaction Modes |
| // |
| // Cloud Spanner supports three transaction modes: |
| // |
| // 1. Locking read-write. This type of transaction is the only way |
| // to write data into Cloud Spanner. These transactions rely on |
| // pessimistic locking and, if necessary, two-phase commit. |
| // Locking read-write transactions may abort, requiring the |
| // application to retry. |
| // |
| // 2. Snapshot read-only. This transaction type provides guaranteed |
| // consistency across several reads, but does not allow |
| // writes. Snapshot read-only transactions can be configured to |
| // read at timestamps in the past. Snapshot read-only |
| // transactions do not need to be committed. |
| // |
| // 3. Partitioned DML. This type of transaction is used to execute |
| // a single Partitioned DML statement. Partitioned DML partitions |
| // the key space and runs the DML statement over each partition |
| // in parallel using separate, internal transactions that commit |
| // independently. Partitioned DML transactions do not need to be |
| // committed. |
| // |
| // For transactions that only read, snapshot read-only |
| // transactions |
| // provide simpler semantics and are almost always faster. |
| // In |
| // particular, read-only transactions do not take locks, so they do |
| // not conflict with read-write transactions. As a consequence of |
| // not |
| // taking locks, they also do not abort, so retry loops are not |
| // needed. |
| // |
| // Transactions may only read/write data in a single database. They |
| // may, however, read/write data in different tables within |
| // that |
| // database. |
| // |
| // ## Locking Read-Write Transactions |
| // |
| // Locking transactions may be used to atomically read-modify-write |
| // data anywhere in a database. This type of transaction is |
| // externally |
| // consistent. |
| // |
| // Clients should attempt to minimize the amount of time a |
| // transaction |
| // is active. Faster transactions commit with higher probability |
| // and cause less contention. Cloud Spanner attempts to keep read |
| // locks |
| // active as long as the transaction continues to do reads, and |
| // the |
| // transaction has not been terminated by |
| // Commit or |
| // Rollback. Long periods of |
| // inactivity at the client may cause Cloud Spanner to release |
| // a |
| // transaction's locks and abort it. |
| // |
| // Conceptually, a read-write transaction consists of zero or more |
| // reads or SQL statements followed by |
| // Commit. At any time before |
| // Commit, the client can send a |
| // Rollback request to abort the |
| // transaction. |
| // |
| // ### Semantics |
| // |
| // Cloud Spanner can commit the transaction if all read locks it |
| // acquired |
| // are still valid at commit time, and it is able to acquire write |
| // locks for all writes. Cloud Spanner can abort the transaction for |
| // any |
| // reason. If a commit attempt returns `ABORTED`, Cloud Spanner |
| // guarantees |
| // that the transaction has not modified any user data in Cloud |
| // Spanner. |
| // |
| // Unless the transaction commits, Cloud Spanner makes no guarantees |
|