# Copyright 2015 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module SpannerV1 # A backup of a Cloud Spanner database. class Backup include Google::Apis::Core::Hashable # Output only. The backup will contain an externally consistent copy of the # database at the timestamp specified by `create_time`. `create_time` is # approximately the time the CreateBackup request is received. # Corresponds to the JSON property `createTime` # @return [String] attr_accessor :create_time # Required for the CreateBackup operation. Name of the database from which this # backup was created. This needs to be in the same instance as the backup. # Values are of the form `projects//instances//databases/`. # Corresponds to the JSON property `database` # @return [String] attr_accessor :database # Required for the CreateBackup operation. The expiration time of the backup, # with microseconds granularity that must be at least 6 hours and at most 366 # days from the time the CreateBackup request is processed. Once the ` # expire_time` has passed, the backup is eligible to be automatically deleted by # Cloud Spanner to free the resources used by the backup. # Corresponds to the JSON property `expireTime` # @return [String] attr_accessor :expire_time # Output only for the CreateBackup operation. Required for the UpdateBackup # operation. A globally unique identifier for the backup which cannot be changed. # Values are of the form `projects//instances//backups/a-z*[a-z0-9]` The final # segment of the name must be between 2 and 60 characters in length. The backup # is stored in the location(s) specified in the instance configuration of the # instance containing the backup, identified by the prefix of the backup name of # the form `projects//instances/`. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Output only. The names of the restored databases that reference the backup. # The database names are of the form `projects//instances//databases/`. # Referencing databases may exist in different instances. The existence of any # referencing database prevents the backup from being deleted. When a restored # database from the backup enters the `READY` state, the reference to the backup # is removed. # Corresponds to the JSON property `referencingDatabases` # @return [Array] attr_accessor :referencing_databases # Output only. Size of the backup in bytes. # Corresponds to the JSON property `sizeBytes` # @return [Fixnum] attr_accessor :size_bytes # Output only. The current state of the backup. # Corresponds to the JSON property `state` # @return [String] attr_accessor :state def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @create_time = args[:create_time] if args.key?(:create_time) @database = args[:database] if args.key?(:database) @expire_time = args[:expire_time] if args.key?(:expire_time) @name = args[:name] if args.key?(:name) @referencing_databases = args[:referencing_databases] if args.key?(:referencing_databases) @size_bytes = args[:size_bytes] if args.key?(:size_bytes) @state = args[:state] if args.key?(:state) end end # Information about a backup. class BackupInfo include Google::Apis::Core::Hashable # Name of the backup. # Corresponds to the JSON property `backup` # @return [String] attr_accessor :backup # The backup contains an externally consistent copy of `source_database` at the # timestamp specified by `create_time`. # Corresponds to the JSON property `createTime` # @return [String] attr_accessor :create_time # Name of the database the backup was created from. # Corresponds to the JSON property `sourceDatabase` # @return [String] attr_accessor :source_database def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @backup = args[:backup] if args.key?(:backup) @create_time = args[:create_time] if args.key?(:create_time) @source_database = args[:source_database] if args.key?(:source_database) end end # The request for BatchCreateSessions. class BatchCreateSessionsRequest include Google::Apis::Core::Hashable # 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). # Corresponds to the JSON property `sessionCount` # @return [Fixnum] attr_accessor :session_count # A session in the Cloud Spanner API. # Corresponds to the JSON property `sessionTemplate` # @return [Google::Apis::SpannerV1::Session] attr_accessor :session_template def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @session_count = args[:session_count] if args.key?(:session_count) @session_template = args[:session_template] if args.key?(:session_template) end end # The response for BatchCreateSessions. class BatchCreateSessionsResponse include Google::Apis::Core::Hashable # The freshly created sessions. # Corresponds to the JSON property `session` # @return [Array] attr_accessor :session def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @session = args[:session] if args.key?(:session) end end # The request for BeginTransaction. class BeginTransactionRequest include Google::Apis::Core::Hashable # # Transactions Each session can have at most one active transaction at a time ( # note that standalone reads and queries use a transaction internally and do # count towards the one transaction limit). 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 about how long the transaction's locks were # held for. It is an error to use Cloud Spanner locks for any sort of mutual # exclusion other than between Cloud Spanner transactions themselves. ### # Retrying Aborted Transactions When a transaction aborts, the application can # choose to retry the whole transaction again. To maximize the chances of # successfully committing the retry, the client should execute the retry in the # same session as the original attempt. The original session's lock priority # increases with each consecutive abort, meaning that each attempt has a # slightly better chance of success than the previous. Under some circumstances ( # e.g., many transactions attempting to modify the same row(s)), a transaction # can abort many times in a short period before successfully committing. Thus, # it is not a good idea to cap the number of retries a transaction can attempt; # instead, it is better to limit the total amount of wall time spent retrying. ## # # Idle Transactions A transaction is considered idle if it has no outstanding # reads or SQL queries and has not started a read or SQL query within the last # 10 seconds. Idle transactions can be aborted by Cloud Spanner so that they don' # t hold on to locks indefinitely. In that case, the commit will fail with error # `ABORTED`. If this behavior is undesirable, periodically executing a simple # SQL query in the transaction (e.g., `SELECT 1`) prevents the transaction from # becoming idle. ## Snapshot Read-Only Transactions Snapshot read-only # transactions provides a simpler method than locking read-write transactions # for doing several consistent reads. However, this type of transaction does not # support writes. Snapshot transactions do not take locks. Instead, they work by # choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. # Since they do not acquire locks, they do not block concurrent read-write # transactions. Unlike locking read-write transactions, snapshot read-only # transactions never abort. They can fail if the chosen read timestamp is # garbage collected; however, the default garbage collection policy is generous # enough that most applications do not need to worry about this in practice. # Snapshot read-only transactions do not need to call Commit or Rollback (and in # fact are not permitted to do so). To execute a snapshot transaction, the # client specifies a timestamp bound, which tells Cloud Spanner how to choose a # read timestamp. The types of timestamp bound are: - Strong (the default). - # Bounded staleness. - Exact staleness. If the Cloud Spanner database to be read # is geographically distributed, stale read-only transactions can execute more # quickly than strong or read-write transaction, because they are able to # execute far from the leader replica. Each type of timestamp bound is discussed # in detail below. ### Strong Strong reads are guaranteed to see the effects of # all transactions that have committed before the start of the read. Furthermore, # all rows yielded by a single read are consistent with each other -- if any # part of the read observes a transaction, all parts of the read see the # transaction. Strong reads are not repeatable: two consecutive strong read-only # transactions might return inconsistent results if there are concurrent writes. # If consistency across reads is required, the reads should be executed within a # transaction or at an exact read timestamp. See TransactionOptions.ReadOnly. # strong. ### Exact Staleness These timestamp bounds execute reads at a user- # specified timestamp. Reads at a timestamp are guaranteed to see a consistent # prefix of the global transaction history: they observe modifications done by # all transactions with a commit timestamp <= the read timestamp, and observe # none of the modifications done by transactions with a larger commit timestamp. # They will block until all conflicting transactions that may be assigned commit # timestamps <= the read timestamp have finished. The timestamp can either be # expressed as an absolute Cloud Spanner commit timestamp or a staleness # relative to the current time. These modes do not require a "negotiation phase" # to pick a timestamp. As a result, they execute slightly faster than the # equivalent boundedly stale concurrency modes. On the other hand, boundedly # stale reads usually return fresher results. See TransactionOptions.ReadOnly. # read_timestamp and TransactionOptions.ReadOnly.exact_staleness. ### Bounded # Staleness Bounded staleness modes allow Cloud Spanner to pick the read # timestamp, subject to a user-provided staleness bound. Cloud Spanner chooses # the newest timestamp within the staleness bound that allows execution of the # reads at the closest available replica without blocking. All rows yielded are # consistent with each other -- if any part of the read observes a transaction, # all parts of the read see the transaction. Boundedly stale reads are not # repeatable: two stale reads, even if they use the same staleness bound, can # execute at different timestamps and thus return inconsistent results. # Boundedly stale reads execute in two phases: the first phase negotiates a # timestamp among all replicas needed to serve the read. In the second phase, # reads are executed at the negotiated timestamp. As a result of the two phase # execution, bounded staleness reads are usually a little slower than comparable # exact staleness reads. However, they are typically able to return fresher # results, and are more likely to execute at the closest replica. Because the # timestamp negotiation requires up-front knowledge of which rows will be read, # it can only be used with single-use read-only transactions. See # TransactionOptions.ReadOnly.max_staleness and TransactionOptions.ReadOnly. # min_read_timestamp. ### Old Read Timestamps and Garbage Collection Cloud # Spanner continuously garbage collects deleted and overwritten data in the # background to reclaim storage space. This process is known as "version GC". By # default, version GC reclaims versions after they are one hour old. Because of # this, Cloud Spanner cannot perform reads at read timestamps more than one hour # in the past. This restriction also applies to in-progress reads and/or SQL # queries whose timestamp become too old while executing. Reads and SQL queries # with too-old read timestamps fail with the error `FAILED_PRECONDITION`. ## # Partitioned DML Transactions Partitioned DML transactions are used to execute # DML statements with a different execution strategy that provides different, # and often better, scalability properties for large, table-wide operations than # DML in a ReadWrite transaction. Smaller scoped statements, such as an OLTP # workload, should prefer using ReadWrite transactions. Partitioned DML # partitions the keyspace and runs the DML statement on each partition in # separate, internal transactions. These transactions commit automatically when # complete, and run independently from one another. To reduce lock contention, # this execution strategy only acquires read locks on rows that match the WHERE # clause of the statement. Additionally, the smaller per-partition transactions # hold locks for less time. That said, Partitioned DML is not a drop-in # replacement for standard DML used in ReadWrite transactions. - The DML # statement must be fully-partitionable. Specifically, the statement must be # expressible as the union of many statements which each access only a single # row of the table. - The statement is not applied atomically to all rows of the # table. Rather, the statement is applied atomically to partitions of the table, # in independent transactions. Secondary index rows are updated atomically with # the base table rows. - Partitioned DML does not guarantee exactly-once # execution semantics against a partition. The statement will be applied at # least once to each partition. It is strongly recommended that the DML # statement should be idempotent to avoid unexpected results. For instance, it # is potentially dangerous to run a statement such as `UPDATE table SET column = # column + 1` as it could be run multiple times against some rows. - The # partitions are committed automatically - there is no support for Commit or # Rollback. If the call returns an error, or if the client issuing the # ExecuteSql call dies, it is possible that some rows had the statement executed # on them successfully. It is also possible that statement was never executed # against other rows. - Partitioned DML transactions may only contain the # execution of a single DML statement via ExecuteSql or ExecuteStreamingSql. - # If any error is encountered during the execution of the partitioned DML # operation (for instance, a UNIQUE INDEX violation, division by zero, or a # value that cannot be stored due to schema constraints), then the operation is # stopped at that point and an error is returned. It is possible that at this # point, some partitions have been committed (or even committed multiple times), # and other partitions have not been run at all. Given the above, Partitioned # DML is good fit for large, database-wide, operations that are idempotent, such # as deleting old rows from a very large table. # Corresponds to the JSON property `options` # @return [Google::Apis::SpannerV1::TransactionOptions] attr_accessor :options def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @options = args[:options] if args.key?(:options) end end # Associates `members` with a `role`. class Binding include Google::Apis::Core::Hashable # A client-specified ID for this binding. Expected to be globally unique to # support the internal bindings-by-ID API. # Corresponds to the JSON property `bindingId` # @return [String] attr_accessor :binding_id # Represents a textual expression in the Common Expression Language (CEL) syntax. # CEL is a C-like expression language. The syntax and semantics of CEL are # documented at https://github.com/google/cel-spec. Example (Comparison): title: # "Summary size limit" description: "Determines if a summary is less than 100 # chars" expression: "document.summary.size() < 100" Example (Equality): title: " # Requestor is owner" description: "Determines if requestor is the document # owner" expression: "document.owner == request.auth.claims.email" Example ( # Logic): title: "Public documents" description: "Determine whether the document # should be publicly visible" expression: "document.type != 'private' && # document.type != 'internal'" Example (Data Manipulation): title: "Notification # string" description: "Create a notification string with a timestamp." # expression: "'New message received at ' + string(document.create_time)" The # exact variables and functions that may be referenced within an expression are # determined by the service that evaluates it. See the service documentation for # additional information. # Corresponds to the JSON property `condition` # @return [Google::Apis::SpannerV1::Expr] attr_accessor :condition # 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`. * `deleted:user:`emailid`?uid= # `uniqueid``: An email address (plus unique identifier) representing a user # that has been recently deleted. For example, `alice@example.com?uid= # 123456789012345678901`. If the user is recovered, this value reverts to `user:` # emailid`` and the recovered user retains the role in the binding. * `deleted: # serviceAccount:`emailid`?uid=`uniqueid``: An email address (plus unique # identifier) representing a service account that has been recently deleted. For # example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. # If the service account is undeleted, this value reverts to `serviceAccount:` # emailid`` and the undeleted service account retains the role in the binding. * # `deleted:group:`emailid`?uid=`uniqueid``: An email address (plus unique # identifier) representing a Google group that has been recently deleted. For # example, `admins@example.com?uid=123456789012345678901`. If the group is # recovered, this value reverts to `group:`emailid`` and the recovered group # retains the role in the binding. * `domain:`domain``: The G Suite domain ( # primary) that represents all the users of that domain. For example, `google. # com` or `example.com`. # Corresponds to the JSON property `members` # @return [Array] attr_accessor :members # Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor` # , or `roles/owner`. # Corresponds to the JSON property `role` # @return [String] attr_accessor :role def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @binding_id = args[:binding_id] if args.key?(:binding_id) @condition = args[:condition] if args.key?(:condition) @members = args[:members] if args.key?(:members) @role = args[:role] if args.key?(:role) end end # Metadata associated with a parent-child relationship appearing in a PlanNode. class ChildLink include Google::Apis::Core::Hashable # The node to which the link points. # Corresponds to the JSON property `childIndex` # @return [Fixnum] attr_accessor :child_index # 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. # Corresponds to the JSON property `type` # @return [String] attr_accessor :type # 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. # Corresponds to the JSON property `variable` # @return [String] attr_accessor :variable def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @child_index = args[:child_index] if args.key?(:child_index) @type = args[:type] if args.key?(:type) @variable = args[:variable] if args.key?(:variable) end end # The request for Commit. class CommitRequest include Google::Apis::Core::Hashable # The mutations to be executed when this transaction commits. All mutations are # applied atomically, in the order they appear in this list. # Corresponds to the JSON property `mutations` # @return [Array] attr_accessor :mutations # # Transactions Each session can have at most one active transaction at a time ( # note that standalone reads and queries use a transaction internally and do # count towards the one transaction limit). 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 about how long the transaction's locks were # held for. It is an error to use Cloud Spanner locks for any sort of mutual # exclusion other than between Cloud Spanner transactions themselves. ### # Retrying Aborted Transactions When a transaction aborts, the application can # choose to retry the whole transaction again. To maximize the chances of # successfully committing the retry, the client should execute the retry in the # same session as the original attempt. The original session's lock priority # increases with each consecutive abort, meaning that each attempt has a # slightly better chance of success than the previous. Under some circumstances ( # e.g., many transactions attempting to modify the same row(s)), a transaction # can abort many times in a short period before successfully committing. Thus, # it is not a good idea to cap the number of retries a transaction can attempt; # instead, it is better to limit the total amount of wall time spent retrying. ## # # Idle Transactions A transaction is considered idle if it has no outstanding # reads or SQL queries and has not started a read or SQL query within the last # 10 seconds. Idle transactions can be aborted by Cloud Spanner so that they don' # t hold on to locks indefinitely. In that case, the commit will fail with error # `ABORTED`. If this behavior is undesirable, periodically executing a simple # SQL query in the transaction (e.g., `SELECT 1`) prevents the transaction from # becoming idle. ## Snapshot Read-Only Transactions Snapshot read-only # transactions provides a simpler method than locking read-write transactions # for doing several consistent reads. However, this type of transaction does not # support writes. Snapshot transactions do not take locks. Instead, they work by # choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. # Since they do not acquire locks, they do not block concurrent read-write # transactions. Unlike locking read-write transactions, snapshot read-only # transactions never abort. They can fail if the chosen read timestamp is # garbage collected; however, the default garbage collection policy is generous # enough that most applications do not need to worry about this in practice. # Snapshot read-only transactions do not need to call Commit or Rollback (and in # fact are not permitted to do so). To execute a snapshot transaction, the # client specifies a timestamp bound, which tells Cloud Spanner how to choose a # read timestamp. The types of timestamp bound are: - Strong (the default). - # Bounded staleness. - Exact staleness. If the Cloud Spanner database to be read # is geographically distributed, stale read-only transactions can execute more # quickly than strong or read-write transaction, because they are able to # execute far from the leader replica. Each type of timestamp bound is discussed # in detail below. ### Strong Strong reads are guaranteed to see the effects of # all transactions that have committed before the start of the read. Furthermore, # all rows yielded by a single read are consistent with each other -- if any # part of the read observes a transaction, all parts of the read see the # transaction. Strong reads are not repeatable: two consecutive strong read-only # transactions might return inconsistent results if there are concurrent writes. # If consistency across reads is required, the reads should be executed within a # transaction or at an exact read timestamp. See TransactionOptions.ReadOnly. # strong. ### Exact Staleness These timestamp bounds execute reads at a user- # specified timestamp. Reads at a timestamp are guaranteed to see a consistent # prefix of the global transaction history: they observe modifications done by # all transactions with a commit timestamp <= the read timestamp, and observe # none of the modifications done by transactions with a larger commit timestamp. # They will block until all conflicting transactions that may be assigned commit # timestamps <= the read timestamp have finished. The timestamp can either be # expressed as an absolute Cloud Spanner commit timestamp or a staleness # relative to the current time. These modes do not require a "negotiation phase" # to pick a timestamp. As a result, they execute slightly faster than the # equivalent boundedly stale concurrency modes. On the other hand, boundedly # stale reads usually return fresher results. See TransactionOptions.ReadOnly. # read_timestamp and TransactionOptions.ReadOnly.exact_staleness. ### Bounded # Staleness Bounded staleness modes allow Cloud Spanner to pick the read # timestamp, subject to a user-provided staleness bound. Cloud Spanner chooses # the newest timestamp within the staleness bound that allows execution of the # reads at the closest available replica without blocking. All rows yielded are # consistent with each other -- if any part of the read observes a transaction, # all parts of the read see the transaction. Boundedly stale reads are not # repeatable: two stale reads, even if they use the same staleness bound, can # execute at different timestamps and thus return inconsistent results. # Boundedly stale reads execute in two phases: the first phase negotiates a # timestamp among all replicas needed to serve the read. In the second phase, # reads are executed at the negotiated timestamp. As a result of the two phase # execution, bounded staleness reads are usually a little slower than comparable # exact staleness reads. However, they are typically able to return fresher # results, and are more likely to execute at the closest replica. Because the # timestamp negotiation requires up-front knowledge of which rows will be read, # it can only be used with single-use read-only transactions. See # TransactionOptions.ReadOnly.max_staleness and TransactionOptions.ReadOnly. # min_read_timestamp. ### Old Read Timestamps and Garbage Collection Cloud # Spanner continuously garbage collects deleted and overwritten data in the # background to reclaim storage space. This process is known as "version GC". By # default, version GC reclaims versions after they are one hour old. Because of # this, Cloud Spanner cannot perform reads at read timestamps more than one hour # in the past. This restriction also applies to in-progress reads and/or SQL # queries whose timestamp become too old while executing. Reads and SQL queries # with too-old read timestamps fail with the error `FAILED_PRECONDITION`. ## # Partitioned DML Transactions Partitioned DML transactions are used to execute # DML statements with a different execution strategy that provides different, # and often better, scalability properties for large, table-wide operations than # DML in a ReadWrite transaction. Smaller scoped statements, such as an OLTP # workload, should prefer using ReadWrite transactions. Partitioned DML # partitions the keyspace and runs the DML statement on each partition in # separate, internal transactions. These transactions commit automatically when # complete, and run independently from one another. To reduce lock contention, # this execution strategy only acquires read locks on rows that match the WHERE # clause of the statement. Additionally, the smaller per-partition transactions # hold locks for less time. That said, Partitioned DML is not a drop-in # replacement for standard DML used in ReadWrite transactions. - The DML # statement must be fully-partitionable. Specifically, the statement must be # expressible as the union of many statements which each access only a single # row of the table. - The statement is not applied atomically to all rows of the # table. Rather, the statement is applied atomically to partitions of the table, # in independent transactions. Secondary index rows are updated atomically with # the base table rows. - Partitioned DML does not guarantee exactly-once # execution semantics against a partition. The statement will be applied at # least once to each partition. It is strongly recommended that the DML # statement should be idempotent to avoid unexpected results. For instance, it # is potentially dangerous to run a statement such as `UPDATE table SET column = # column + 1` as it could be run multiple times against some rows. - The # partitions are committed automatically - there is no support for Commit or # Rollback. If the call returns an error, or if the client issuing the # ExecuteSql call dies, it is possible that some rows had the statement executed # on them successfully. It is also possible that statement was never executed # against other rows. - Partitioned DML transactions may only contain the # execution of a single DML statement via ExecuteSql or ExecuteStreamingSql. - # If any error is encountered during the execution of the partitioned DML # operation (for instance, a UNIQUE INDEX violation, division by zero, or a # value that cannot be stored due to schema constraints), then the operation is # stopped at that point and an error is returned. It is possible that at this # point, some partitions have been committed (or even committed multiple times), # and other partitions have not been run at all. Given the above, Partitioned # DML is good fit for large, database-wide, operations that are idempotent, such # as deleting old rows from a very large table. # Corresponds to the JSON property `singleUseTransaction` # @return [Google::Apis::SpannerV1::TransactionOptions] attr_accessor :single_use_transaction # Commit a previously-started transaction. # Corresponds to the JSON property `transactionId` # NOTE: Values are automatically base64 encoded/decoded in the client library. # @return [String] attr_accessor :transaction_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @mutations = args[:mutations] if args.key?(:mutations) @single_use_transaction = args[:single_use_transaction] if args.key?(:single_use_transaction) @transaction_id = args[:transaction_id] if args.key?(:transaction_id) end end # The response for Commit. class CommitResponse include Google::Apis::Core::Hashable # The Cloud Spanner timestamp at which the transaction committed. # Corresponds to the JSON property `commitTimestamp` # @return [String] attr_accessor :commit_timestamp def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @commit_timestamp = args[:commit_timestamp] if args.key?(:commit_timestamp) end end # Metadata type for the operation returned by CreateBackup. class CreateBackupMetadata include Google::Apis::Core::Hashable # The time at which cancellation of this operation was received. Operations. # CancelOperation starts asynchronous cancellation on a long-running operation. # The server makes a best effort to cancel the operation, but success is not # guaranteed. Clients can use Operations.GetOperation or other methods to check # whether the cancellation succeeded or whether the operation completed despite # cancellation. On successful cancellation, the operation is not deleted; # instead, it becomes an operation with an Operation.error value with a google. # rpc.Status.code of 1, corresponding to `Code.CANCELLED`. # Corresponds to the JSON property `cancelTime` # @return [String] attr_accessor :cancel_time # The name of the database the backup is created from. # Corresponds to the JSON property `database` # @return [String] attr_accessor :database # The name of the backup being created. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Encapsulates progress related information for a Cloud Spanner long running # operation. # Corresponds to the JSON property `progress` # @return [Google::Apis::SpannerV1::OperationProgress] attr_accessor :progress def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cancel_time = args[:cancel_time] if args.key?(:cancel_time) @database = args[:database] if args.key?(:database) @name = args[:name] if args.key?(:name) @progress = args[:progress] if args.key?(:progress) end end # Metadata type for the operation returned by CreateDatabase. class CreateDatabaseMetadata include Google::Apis::Core::Hashable # The database being created. # Corresponds to the JSON property `database` # @return [String] attr_accessor :database def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @database = args[:database] if args.key?(:database) end end # The request for CreateDatabase. class CreateDatabaseRequest include Google::Apis::Core::Hashable # 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 (`` ` ``). # Corresponds to the JSON property `createStatement` # @return [String] attr_accessor :create_statement # Optional. A 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. # Corresponds to the JSON property `extraStatements` # @return [Array] attr_accessor :extra_statements def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @create_statement = args[:create_statement] if args.key?(:create_statement) @extra_statements = args[:extra_statements] if args.key?(:extra_statements) end end # Metadata type for the operation returned by CreateInstance. class CreateInstanceMetadata include Google::Apis::Core::Hashable # 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. # Corresponds to the JSON property `cancelTime` # @return [String] attr_accessor :cancel_time # The time at which this operation failed or was completed successfully. # Corresponds to the JSON property `endTime` # @return [String] attr_accessor :end_time # An isolated set of Cloud Spanner resources on which databases can be hosted. # Corresponds to the JSON property `instance` # @return [Google::Apis::SpannerV1::Instance] attr_accessor :instance # The time at which the CreateInstance request was received. # Corresponds to the JSON property `startTime` # @return [String] attr_accessor :start_time def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cancel_time = args[:cancel_time] if args.key?(:cancel_time) @end_time = args[:end_time] if args.key?(:end_time) @instance = args[:instance] if args.key?(:instance) @start_time = args[:start_time] if args.key?(:start_time) end end # The request for CreateInstance. class CreateInstanceRequest include Google::Apis::Core::Hashable # An isolated set of Cloud Spanner resources on which databases can be hosted. # Corresponds to the JSON property `instance` # @return [Google::Apis::SpannerV1::Instance] attr_accessor :instance # 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. # Corresponds to the JSON property `instanceId` # @return [String] attr_accessor :instance_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @instance = args[:instance] if args.key?(:instance) @instance_id = args[:instance_id] if args.key?(:instance_id) end end # The request for CreateSession. class CreateSessionRequest include Google::Apis::Core::Hashable # A session in the Cloud Spanner API. # Corresponds to the JSON property `session` # @return [Google::Apis::SpannerV1::Session] attr_accessor :session def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @session = args[:session] if args.key?(:session) end end # A Cloud Spanner database. class Database include Google::Apis::Core::Hashable # Output only. If exists, the time at which the database creation started. # Corresponds to the JSON property `createTime` # @return [String] attr_accessor :create_time # Required. The name of the database. Values are of the form `projects// # instances//databases/`, where `` is as specified in the `CREATE DATABASE` # statement. This name can be passed to other API methods to identify the # database. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Information about the database restore. # Corresponds to the JSON property `restoreInfo` # @return [Google::Apis::SpannerV1::RestoreInfo] attr_accessor :restore_info # Output only. The current database state. # Corresponds to the JSON property `state` # @return [String] attr_accessor :state def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @create_time = args[:create_time] if args.key?(:create_time) @name = args[:name] if args.key?(:name) @restore_info = args[:restore_info] if args.key?(:restore_info) @state = args[:state] if args.key?(:state) end end # Arguments to delete operations. class Delete include Google::Apis::Core::Hashable # `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. # Corresponds to the JSON property `keySet` # @return [Google::Apis::SpannerV1::KeySet] attr_accessor :key_set # Required. The table whose rows will be deleted. # Corresponds to the JSON property `table` # @return [String] attr_accessor :table def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @key_set = args[:key_set] if args.key?(:key_set) @table = args[:table] if args.key?(:table) end end # 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 ````. class Empty include Google::Apis::Core::Hashable def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) end end # The request for ExecuteBatchDml. class ExecuteBatchDmlRequest include Google::Apis::Core::Hashable # Required. 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. # Corresponds to the JSON property `seqno` # @return [Fixnum] attr_accessor :seqno # Required. 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. # Corresponds to the JSON property `statements` # @return [Array] attr_accessor :statements # This message is used to select the transaction in which a Read or ExecuteSql # call runs. See TransactionOptions for more information about transactions. # Corresponds to the JSON property `transaction` # @return [Google::Apis::SpannerV1::TransactionSelector] attr_accessor :transaction def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @seqno = args[:seqno] if args.key?(:seqno) @statements = args[:statements] if args.key?(:statements) @transaction = args[:transaction] if args.key?(:transaction) end end # 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. class ExecuteBatchDmlResponse include Google::Apis::Core::Hashable # 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. # Corresponds to the JSON property `resultSets` # @return [Array] attr_accessor :result_sets # 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). # Corresponds to the JSON property `status` # @return [Google::Apis::SpannerV1::Status] attr_accessor :status def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @result_sets = args[:result_sets] if args.key?(:result_sets) @status = args[:status] if args.key?(:status) end end # The request for ExecuteSql and ExecuteStreamingSql. class ExecuteSqlRequest include Google::Apis::Core::Hashable # 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. # Corresponds to the JSON property `paramTypes` # @return [Hash] attr_accessor :param_types # 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 must conform to the naming # requirements of identifiers as specified at https://cloud.google.com/spanner/ # docs/lexical#identifiers. 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. # Corresponds to the JSON property `params` # @return [Hash] attr_accessor :params # 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. # Corresponds to the JSON property `partitionToken` # NOTE: Values are automatically base64 encoded/decoded in the client library. # @return [String] attr_accessor :partition_token # 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. # Corresponds to the JSON property `queryMode` # @return [String] attr_accessor :query_mode # Query optimizer configuration. # Corresponds to the JSON property `queryOptions` # @return [Google::Apis::SpannerV1::QueryOptions] attr_accessor :query_options # 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. # Corresponds to the JSON property `resumeToken` # NOTE: Values are automatically base64 encoded/decoded in the client library. # @return [String] attr_accessor :resume_token # 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. # Corresponds to the JSON property `seqno` # @return [Fixnum] attr_accessor :seqno # Required. The SQL string. # Corresponds to the JSON property `sql` # @return [String] attr_accessor :sql # This message is used to select the transaction in which a Read or ExecuteSql # call runs. See TransactionOptions for more information about transactions. # Corresponds to the JSON property `transaction` # @return [Google::Apis::SpannerV1::TransactionSelector] attr_accessor :transaction def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @param_types = args[:param_types] if args.key?(:param_types) @params = args[:params] if args.key?(:params) @partition_token = args[:partition_token] if args.key?(:partition_token) @query_mode = args[:query_mode] if args.key?(:query_mode) @query_options = args[:query_options] if args.key?(:query_options) @resume_token = args[:resume_token] if args.key?(:resume_token) @seqno = args[:seqno] if args.key?(:seqno) @sql = args[:sql] if args.key?(:sql) @transaction = args[:transaction] if args.key?(:transaction) end end # Represents a textual expression in the Common Expression Language (CEL) syntax. # CEL is a C-like expression language. The syntax and semantics of CEL are # documented at https://github.com/google/cel-spec. Example (Comparison): title: # "Summary size limit" description: "Determines if a summary is less than 100 # chars" expression: "document.summary.size() < 100" Example (Equality): title: " # Requestor is owner" description: "Determines if requestor is the document # owner" expression: "document.owner == request.auth.claims.email" Example ( # Logic): title: "Public documents" description: "Determine whether the document # should be publicly visible" expression: "document.type != 'private' && # document.type != 'internal'" Example (Data Manipulation): title: "Notification # string" description: "Create a notification string with a timestamp." # expression: "'New message received at ' + string(document.create_time)" The # exact variables and functions that may be referenced within an expression are # determined by the service that evaluates it. See the service documentation for # additional information. class Expr include Google::Apis::Core::Hashable # Optional. Description of the expression. This is a longer text which describes # the expression, e.g. when hovered over it in a UI. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # Textual representation of an expression in Common Expression Language syntax. # Corresponds to the JSON property `expression` # @return [String] attr_accessor :expression # Optional. String indicating the location of the expression for error reporting, # e.g. a file name and a position in the file. # Corresponds to the JSON property `location` # @return [String] attr_accessor :location # 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. # Corresponds to the JSON property `title` # @return [String] attr_accessor :title def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @expression = args[:expression] if args.key?(:expression) @location = args[:location] if args.key?(:location) @title = args[:title] if args.key?(:title) end end # Message representing a single field of a struct. class Field include Google::Apis::Core::Hashable # 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. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # `Type` indicates the type of a Cloud Spanner value, as might be stored in a # table cell or returned from an SQL query. # Corresponds to the JSON property `type` # @return [Google::Apis::SpannerV1::Type] attr_accessor :type def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @name = args[:name] if args.key?(:name) @type = args[:type] if args.key?(:type) end end # The response for GetDatabaseDdl. class GetDatabaseDdlResponse include Google::Apis::Core::Hashable # A list of formatted DDL statements defining the schema of the database # specified in the request. # Corresponds to the JSON property `statements` # @return [Array] attr_accessor :statements def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @statements = args[:statements] if args.key?(:statements) end end # Request message for `GetIamPolicy` method. class GetIamPolicyRequest include Google::Apis::Core::Hashable # Encapsulates settings provided to GetIamPolicy. # Corresponds to the JSON property `options` # @return [Google::Apis::SpannerV1::GetPolicyOptions] attr_accessor :options def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @options = args[:options] if args.key?(:options) end end # Encapsulates settings provided to GetIamPolicy. class GetPolicyOptions include Google::Apis::Core::Hashable # 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. To learn which resources support conditions in their IAM policies, # see the [IAM documentation](https://cloud.google.com/iam/help/conditions/ # resource-policies). # Corresponds to the JSON property `requestedPolicyVersion` # @return [Fixnum] attr_accessor :requested_policy_version def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @requested_policy_version = args[:requested_policy_version] if args.key?(:requested_policy_version) end end # An isolated set of Cloud Spanner resources on which databases can be hosted. class Instance include Google::Apis::Core::Hashable # Required. The name of the instance's configuration. Values are of the form ` # projects//instanceConfigs/`. See also InstanceConfig and ListInstanceConfigs. # Corresponds to the JSON property `config` # @return [String] attr_accessor :config # 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. # Corresponds to the JSON property `displayName` # @return [String] attr_accessor :display_name # Deprecated. This field is not populated. # Corresponds to the JSON property `endpointUris` # @return [Array] attr_accessor :endpoint_uris # 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. # Corresponds to the JSON property `labels` # @return [Hash] attr_accessor :labels # Required. A unique identifier for the instance, which cannot be changed after # the instance is created. Values are of the form `projects//instances/a-z*[a-z0- # 9]`. The final segment of the name must be between 2 and 64 characters in # length. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # 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#node_count) for # more information about nodes. # Corresponds to the JSON property `nodeCount` # @return [Fixnum] attr_accessor :node_count # 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`. # Corresponds to the JSON property `state` # @return [String] attr_accessor :state def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @config = args[:config] if args.key?(:config) @display_name = args[:display_name] if args.key?(:display_name) @endpoint_uris = args[:endpoint_uris] if args.key?(:endpoint_uris) @labels = args[:labels] if args.key?(:labels) @name = args[:name] if args.key?(:name) @node_count = args[:node_count] if args.key?(:node_count) @state = args[:state] if args.key?(:state) end end # A possible configuration for a Cloud Spanner instance. Configurations define # the geographic placement of nodes and their replication. class InstanceConfig include Google::Apis::Core::Hashable # The name of this instance configuration as it appears in UIs. # Corresponds to the JSON property `displayName` # @return [String] attr_accessor :display_name # A unique identifier for the instance configuration. Values are of the form ` # projects//instanceConfigs/a-z*` # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # The geographic placement of nodes in this instance configuration and their # replication properties. # Corresponds to the JSON property `replicas` # @return [Array] attr_accessor :replicas def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @display_name = args[:display_name] if args.key?(:display_name) @name = args[:name] if args.key?(:name) @replicas = args[:replicas] if args.key?(:replicas) end end # 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. class KeyRange include Google::Apis::Core::Hashable # If the end is closed, then the range includes all rows whose first `len( # end_closed)` key columns exactly match `end_closed`. # Corresponds to the JSON property `endClosed` # @return [Array