google-apis-spanner_v1 0.36.0 → 0.38.0

data/lib/google/apis/spanner_v1/service.rb

@@ -33,6 +33,8 @@ module Google
       #
       # @see https://cloud.google.com/spanner/
       class SpannerService < Google::Apis::Core::BaseService
+        DEFAULT_ENDPOINT_TEMPLATE = "https://spanner.$UNIVERSE_DOMAIN$/"
+
         # @return [String]
         #  API key. Your API key identifies your project and provides you with API access,
         #  quota, and reports. Required unless you provide an OAuth 2.0 token.
@@ -44,12 +46,184 @@ module Google
         attr_accessor :quota_user
 
         def initialize
-          super('https://spanner.googleapis.com/', '',
+          super(DEFAULT_ENDPOINT_TEMPLATE, '',
                 client_name: 'google-apis-spanner_v1',
                 client_version: Google::Apis::SpannerV1::GEM_VERSION)
           @batch_path = 'batch'
         end
         
+        # Lists the user-managed instance configuration long-running operations in the
+        # given project. An instance configuration operation has a name of the form `
+        # projects//instanceConfigs//operations/`. The long-running operation metadata
+        # field type `metadata.type_url` describes the type of the metadata. Operations
+        # returned include those that have completed/failed/canceled within the last 7
+        # days, and pending operations. Operations returned are ordered by `operation.
+        # metadata.value.start_time` in descending order starting from the most recently
+        # started operation.
+        # @param [String] parent
+        #   Required. The project of the instance configuration operations. Values are of
+        #   the form `projects/`.
+        # @param [String] filter
+        #   An expression that filters the list of returned operations. A filter
+        #   expression consists of a field name, a comparison operator, and a value for
+        #   filtering. The value must be a string, a number, or a boolean. The comparison
+        #   operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is
+        #   the contains operator. Filter rules are not case sensitive. The following
+        #   fields in the Operation are eligible for filtering: * `name` - The name of the
+        #   long-running operation * `done` - False if the operation is in progress, else
+        #   true. * `metadata.@type` - the type of metadata. For example, the type string
+        #   for CreateInstanceConfigMetadata is `type.googleapis.com/google.spanner.admin.
+        #   instance.v1.CreateInstanceConfigMetadata`. * `metadata.` - any field in
+        #   metadata.value. `metadata.@type` must be specified first, if filtering on
+        #   metadata fields. * `error` - Error associated with the long-running operation.
+        #   * `response.@type` - the type of response. * `response.` - any field in
+        #   response.value. You can combine multiple expressions by enclosing each
+        #   expression in parentheses. By default, expressions are combined with AND logic.
+        #   However, you can specify AND, OR, and NOT logic explicitly. Here are a few
+        #   examples: * `done:true` - The operation is complete. * `(metadata.@type=` \ `
+        #   type.googleapis.com/google.spanner.admin.instance.v1.
+        #   CreateInstanceConfigMetadata) AND` \ `(metadata.instance_config.name:custom-
+        #   config) AND` \ `(metadata.progress.start_time < \"2021-03-28T14:50:00Z\") AND`
+        #   \ `(error:*)` - Return operations where: * The operation's metadata type is
+        #   CreateInstanceConfigMetadata. * The instance configuration name contains "
+        #   custom-config". * The operation started before 2021-03-28T14:50:00Z. * The
+        #   operation resulted in an error.
+        # @param [Fixnum] page_size
+        #   Number of operations to be returned in the response. If 0 or less, defaults to
+        #   the server's maximum allowed page size.
+        # @param [String] page_token
+        #   If non-empty, `page_token` should contain a next_page_token from a previous
+        #   ListInstanceConfigOperationsResponse to the same `parent` and with the same `
+        #   filter`.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ListInstanceConfigOperationsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ListInstanceConfigOperationsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_project_single_instance_config_operations(parent, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+parent}/instanceConfigOperations', options)
+          command.response_representation = Google::Apis::SpannerV1::ListInstanceConfigOperationsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListInstanceConfigOperationsResponse
+          command.params['parent'] = parent unless parent.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Creates an instance configuration and begins preparing it to be used. The
+        # returned long-running operation can be used to track the progress of preparing
+        # the new instance configuration. The instance configuration name is assigned by
+        # the caller. If the named instance configuration already exists, `
+        # CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request
+        # returns: * The instance configuration is readable via the API, with all
+        # requested attributes. The instance configuration's reconciling field is set to
+        # true. Its state is `CREATING`. While the operation is pending: * Cancelling
+        # the operation renders the instance configuration immediately unreadable via
+        # the API. * Except for deleting the creating resource, all other attempts to
+        # modify the instance configuration are rejected. Upon completion of the
+        # returned operation: * Instances can be created using the instance
+        # configuration. * The instance configuration's reconciling field becomes false.
+        # Its state becomes `READY`. The returned long-running operation will have a
+        # name of the format `/operations/` and can be used to track creation of the
+        # instance configuration. The metadata field type is
+        # CreateInstanceConfigMetadata. The response field type is InstanceConfig, if
+        # successful. Authorization requires `spanner.instanceConfigs.create` permission
+        # on the resource parent.
+        # @param [String] parent
+        #   Required. The name of the project in which to create the instance
+        #   configuration. Values are of the form `projects/`.
+        # @param [Google::Apis::SpannerV1::CreateInstanceConfigRequest] create_instance_config_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def create_instance_config(parent, create_instance_config_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+parent}/instanceConfigs', options)
+          command.request_representation = Google::Apis::SpannerV1::CreateInstanceConfigRequest::Representation
+          command.request_object = create_instance_config_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['parent'] = parent unless parent.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Deletes the instance configuration. Deletion is only allowed when no instances
+        # are using the configuration. If any instances are using the configuration,
+        # returns `FAILED_PRECONDITION`. Only user-managed configurations can be deleted.
+        # Authorization requires `spanner.instanceConfigs.delete` permission on the
+        # resource name.
+        # @param [String] name
+        #   Required. The name of the instance configuration to be deleted. Values are of
+        #   the form `projects//instanceConfigs/`
+        # @param [String] etag
+        #   Used for optimistic concurrency control as a way to help prevent simultaneous
+        #   deletes of an instance configuration from overwriting each other. If not empty,
+        #   the API only deletes the instance configuration when the etag provided
+        #   matches the current status of the requested instance configuration. Otherwise,
+        #   deletes the instance configuration without checking the current status of the
+        #   requested instance configuration.
+        # @param [Boolean] validate_only
+        #   An option to validate, but not actually execute, a request, and provide the
+        #   same response.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def delete_project_instance_config(name, etag: nil, validate_only: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['etag'] = etag unless etag.nil?
+          command.query['validateOnly'] = validate_only unless validate_only.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
         # Gets information about a particular instance configuration.
         # @param [String] name
         #   Required. The name of the requested instance configuration. Values are of the
@@ -81,7 +255,8 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Lists the supported instance configurations for a given project.
+        # Lists the supported instance configurations for a given project. Returns both
+        # Google-managed configurations and user-managed configurations.
         # @param [String] parent
         #   Required. The name of the project for which a list of supported instance
         #   configurations is requested. Values are of the form `projects/`.
@@ -120,14 +295,66 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
+        # Updates an instance configuration. The returned long-running operation can be
+        # used to track the progress of updating the instance. If the named instance
+        # configuration does not exist, returns `NOT_FOUND`. Only user-managed
+        # configurations can be updated. Immediately after the request returns: * The
+        # instance configuration's reconciling field is set to true. While the operation
+        # is pending: * Cancelling the operation sets its metadata's cancel_time. The
+        # operation is guaranteed to succeed at undoing all changes, after which point
+        # it terminates with a `CANCELLED` status. * All other attempts to modify the
+        # instance configuration are rejected. * Reading the instance configuration via
+        # the API continues to give the pre-request values. Upon completion of the
+        # returned operation: * Creating instances using the instance configuration uses
+        # the new values. * The new values of the instance configuration are readable
+        # via the API. * The instance configuration's reconciling field becomes false.
+        # The returned long-running operation will have a name of the format `/
+        # operations/` and can be used to track the instance configuration modification.
+        # The metadata field type is UpdateInstanceConfigMetadata. The response field
+        # type is InstanceConfig, if successful. Authorization requires `spanner.
+        # instanceConfigs.update` permission on the resource name.
+        # @param [String] name
+        #   A unique identifier for the instance configuration. Values are of the form `
+        #   projects//instanceConfigs/a-z*`. User instance configuration must start with `
+        #   custom-`.
+        # @param [Google::Apis::SpannerV1::UpdateInstanceConfigRequest] update_instance_config_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def patch_project_instance_config(name, update_instance_config_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:patch, 'v1/{+name}', options)
+          command.request_representation = Google::Apis::SpannerV1::UpdateInstanceConfigRequest::Representation
+          command.request_object = update_instance_config_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
         # Starts asynchronous cancellation on a long-running operation. The server makes
         # a best effort to cancel the operation, but success is not guaranteed. If the
         # server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
         # 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`.
+        # an operation with an Operation.error value with a google.rpc.Status.code of `1`
+        # , corresponding to `Code.CANCELLED`.
         # @param [String] name
         #   The name of the operation resource to be cancelled.
         # @param [String] fields
@@ -222,13 +449,7 @@ module Google
         end
         
         # Lists operations that match the specified filter in the request. If the server
-        # doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the `name`
-        # binding allows API services to override the binding to use different resource
-        # name schemes, such as `users/*/operations`. To override the binding, API
-        # services can add a binding such as `"/v1/`name=users/*`/operations"` to their
-        # service configuration. For backwards compatibility, the default name includes
-        # the operations collection id, however overriding users must ensure the name
-        # binding is the parent resource, without the operations collection id.
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
         # @param [String] name
         #   The name of the operation's parent resource.
         # @param [String] filter
@@ -267,6 +488,147 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
+        # Starts asynchronous cancellation on a long-running operation. The server makes
+        # a best effort to cancel the operation, but success is not guaranteed. If the
+        # server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+        # 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`.
+        # @param [String] name
+        #   The name of the operation resource to be cancelled.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def cancel_project_instance_config_ssd_cach_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+name}:cancel', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Deletes a long-running operation. This method indicates that the client is no
+        # longer interested in the operation result. It does not cancel the operation.
+        # If the server doesn't support this method, it returns `google.rpc.Code.
+        # UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation resource to be deleted.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def delete_project_instance_config_ssd_cach_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Gets the latest state of a long-running operation. Clients can use this method
+        # to poll the operation result at intervals as recommended by the API service.
+        # @param [String] name
+        #   The name of the operation resource.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def get_project_instance_config_ssd_cach_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Lists operations that match the specified filter in the request. If the server
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation's parent resource.
+        # @param [String] filter
+        #   The standard list filter.
+        # @param [Fixnum] page_size
+        #   The standard list page size.
+        # @param [String] page_token
+        #   The standard list page token.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ListOperationsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ListOperationsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_project_instance_config_ssd_cach_operations(name, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::ListOperationsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListOperationsResponse
+          command.params['name'] = name unless name.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
         # Creates an instance and begins preparing it to begin serving. The returned
         # long-running operation can be used to track the progress of preparing the new
         # instance. The instance name is assigned by the caller. If the named instance
@@ -478,8 +840,69 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Updates an instance, and begins allocating or releasing resources as requested.
-        # The returned long-running operation can be used to track the progress of
+        # Moves an instance to the target instance configuration. You can use the
+        # returned long-running operation to track the progress of moving the instance. `
+        # MoveInstance` returns `FAILED_PRECONDITION` if the instance meets any of the
+        # following criteria: * Is undergoing a move to a different instance
+        # configuration * Has backups * Has an ongoing update * Contains any CMEK-
+        # enabled databases * Is a free trial instance While the operation is pending: *
+        # All other attempts to modify the instance, including changes to its compute
+        # capacity, are rejected. * The following database and backup admin operations
+        # are rejected: * `DatabaseAdmin.CreateDatabase` * `DatabaseAdmin.
+        # UpdateDatabaseDdl` (disabled if default_leader is specified in the request.) *
+        # `DatabaseAdmin.RestoreDatabase` * `DatabaseAdmin.CreateBackup` * `
+        # DatabaseAdmin.CopyBackup` * Both the source and target instance configurations
+        # are subject to hourly compute and storage charges. * The instance might
+        # experience higher read-write latencies and a higher transaction abort rate.
+        # However, moving an instance doesn't cause any downtime. The returned long-
+        # running operation has a name of the format `/operations/` and can be used to
+        # track the move instance operation. The metadata field type is
+        # MoveInstanceMetadata. The response field type is Instance, if successful.
+        # Cancelling the operation sets its metadata's cancel_time. Cancellation is not
+        # immediate because it involves moving any data previously moved to the target
+        # instance configuration back to the original instance configuration. You can
+        # use this operation to track the progress of the cancellation. Upon successful
+        # completion of the cancellation, the operation terminates with `CANCELLED`
+        # status. If not cancelled, upon completion of the returned operation: * The
+        # instance successfully moves to the target instance configuration. * You are
+        # billed for compute and storage in target instance configuration. Authorization
+        # requires the `spanner.instances.update` permission on the resource instance.
+        # For more details, see [Move an instance](https://cloud.google.com/spanner/docs/
+        # move-instance).
+        # @param [String] name
+        #   Required. The instance to move. Values are of the form `projects//instances/`.
+        # @param [Google::Apis::SpannerV1::MoveInstanceRequest] move_instance_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def move_instance(name, move_instance_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+name}:move', options)
+          command.request_representation = Google::Apis::SpannerV1::MoveInstanceRequest::Representation
+          command.request_object = move_instance_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Updates an instance, and begins allocating or releasing resources as requested.
+        # The returned long-running operation can be used to track the progress of
         # updating the instance. If the named instance does not exist, returns `
         # NOT_FOUND`. Immediately upon completion of this request: * For resource types
         # for which a decrease in the instance's allocation has been requested, billing
@@ -702,8 +1125,9 @@ module Google
         # operations/` and can be used to track copying of the backup. The operation is
         # associated with the destination backup. The metadata field type is
         # CopyBackupMetadata. The response field type is Backup, if successful.
-        # Cancelling the returned operation will stop the copying and delete the backup.
-        # Concurrent CopyBackup requests can run on the same source backup.
+        # Cancelling the returned operation will stop the copying and delete the
+        # destination backup. Concurrent CopyBackup requests can run on the same source
+        # backup.
         # @param [String] parent
         #   Required. The name of the destination instance that will contain the backup
         #   copy. Values are of the form: `projects//instances/`.
@@ -760,6 +1184,18 @@ module Google
         #   Optional. The Cloud KMS key that will be used to protect the backup. This
         #   field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`.
         #   Values are of the form `projects//locations//keyRings//cryptoKeys/`.
+        # @param [Array<String>, String] encryption_config_kms_key_names
+        #   Optional. Specifies the KMS configuration for the one or more keys used to
+        #   protect the backup. Values are of the form `projects//locations//keyRings//
+        #   cryptoKeys/`. The keys referenced by `kms_key_names` must fully cover all
+        #   regions of the backup's instance configuration. Some examples: * For regional (
+        #   single-region) instance configurations, specify a regional location KMS key. *
+        #   For multi-region instance configurations of type `GOOGLE_MANAGED`, either
+        #   specify a multi-region location KMS key or multiple regional location KMS keys
+        #   that cover all regions in the instance configuration. * For an instance
+        #   configuration of type `USER_MANAGED`, specify only regional location KMS keys
+        #   to cover each region in the instance configuration. Multi-region location KMS
+        #   keys aren't supported for `USER_MANAGED` type instance configurations.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -777,7 +1213,7 @@ module Google
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def create_project_instance_backup(parent, backup_object = nil, backup_id: nil, encryption_config_encryption_type: nil, encryption_config_kms_key_name: nil, fields: nil, quota_user: nil, options: nil, &block)
+        def create_project_instance_backup(parent, backup_object = nil, backup_id: nil, encryption_config_encryption_type: nil, encryption_config_kms_key_name: nil, encryption_config_kms_key_names: nil, fields: nil, quota_user: nil, options: nil, &block)
           command = make_simple_command(:post, 'v1/{+parent}/backups', options)
           command.request_representation = Google::Apis::SpannerV1::Backup::Representation
           command.request_object = backup_object
@@ -787,6 +1223,7 @@ module Google
           command.query['backupId'] = backup_id unless backup_id.nil?
           command.query['encryptionConfig.encryptionType'] = encryption_config_encryption_type unless encryption_config_encryption_type.nil?
           command.query['encryptionConfig.kmsKeyName'] = encryption_config_kms_key_name unless encryption_config_kms_key_name.nil?
+          command.query['encryptionConfig.kmsKeyNames'] = encryption_config_kms_key_names unless encryption_config_kms_key_names.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
@@ -858,7 +1295,8 @@ module Google
         # empty policy if a database or backup exists but does not have a policy set.
         # Authorization requires `spanner.databases.getIamPolicy` permission on resource.
         # For backups, authorization requires `spanner.backups.getIamPolicy` permission
-        # on resource.
+        # on resource. For backup schedules, authorization requires `spanner.
+        # backupSchedules.getIamPolicy` permission on resource.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which the policy is being retrieved.
         #   The format is `projects//instances/` for instance resources and `projects//
@@ -908,17 +1346,19 @@ module Google
         #   create_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `
         #   expire_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `
         #   version_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `
-        #   size_bytes` You can combine multiple expressions by enclosing each expression
-        #   in parentheses. By default, expressions are combined with AND logic, but you
-        #   can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `
-        #   name:Howl` - The backup's name contains the string "howl". * `database:prod` -
-        #   The database's name contains the string "prod". * `state:CREATING` - The
-        #   backup is pending creation. * `state:READY` - The backup is fully created and
-        #   ready for use. * `(name:howl) AND (create_time < \"2018-03-28T14:50:00Z\")` -
-        #   The backup name contains the string "howl" and `create_time` of the backup is
-        #   before 2018-03-28T14:50:00Z. * `expire_time < \"2018-03-28T14:50:00Z\"` - The
-        #   backup `expire_time` is before 2018-03-28T14:50:00Z. * `size_bytes >
-        #   10000000000` - The backup's size is greater than 10GB
+        #   size_bytes` * `backup_schedules` You can combine multiple expressions by
+        #   enclosing each expression in parentheses. By default, expressions are combined
+        #   with AND logic, but you can specify AND, OR, and NOT logic explicitly. Here
+        #   are a few examples: * `name:Howl` - The backup's name contains the string "
+        #   howl". * `database:prod` - The database's name contains the string "prod". * `
+        #   state:CREATING` - The backup is pending creation. * `state:READY` - The backup
+        #   is fully created and ready for use. * `(name:howl) AND (create_time < \"2018-
+        #   03-28T14:50:00Z\")` - The backup name contains the string "howl" and `
+        #   create_time` of the backup is before 2018-03-28T14:50:00Z. * `expire_time < \"
+        #   2018-03-28T14:50:00Z\"` - The backup `expire_time` is before 2018-03-28T14:50:
+        #   00Z. * `size_bytes > 10000000000` - The backup's size is greater than 10GB * `
+        #   backup_schedules:daily` - The backup is created from a schedule with "daily"
+        #   in its name.
         # @param [Fixnum] page_size
         #   Number of backups to be returned in the response. If 0 or less, defaults to
         #   the server's maximum allowed page size.
@@ -1004,7 +1444,8 @@ module Google
         # Sets the access control policy on a database or backup resource. Replaces any
         # existing policy. Authorization requires `spanner.databases.setIamPolicy`
         # permission on resource. For backups, authorization requires `spanner.backups.
-        # setIamPolicy` permission on resource.
+        # setIamPolicy` permission on resource. For backup schedules, authorization
+        # requires `spanner.backupSchedules.setIamPolicy` permission on resource.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which the policy is being set. The
         #   format is `projects//instances/` for instance resources and `projects//
@@ -1045,7 +1486,9 @@ module Google
         # permission on the containing Cloud Spanner instance. Otherwise returns an
         # empty set of permissions. Calling this method on a backup that does not exist
         # will result in a NOT_FOUND error if the user has `spanner.backups.list`
-        # permission on the containing instance.
+        # permission on the containing instance. Calling this method on a backup
+        # schedule that does not exist will result in a NOT_FOUND error if the user has `
+        # spanner.backupSchedules.list` permission on the containing database.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which permissions are being tested.
         #   The format is `projects//instances/` for instance resources and `projects//
@@ -1086,8 +1529,8 @@ module Google
         # 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`.
+        # an operation with an Operation.error value with a google.rpc.Status.code of `1`
+        # , corresponding to `Code.CANCELLED`.
         # @param [String] name
         #   The name of the operation resource to be cancelled.
         # @param [String] fields
@@ -1182,13 +1625,7 @@ module Google
         end
         
         # Lists operations that match the specified filter in the request. If the server
-        # doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the `name`
-        # binding allows API services to override the binding to use different resource
-        # name schemes, such as `users/*/operations`. To override the binding, API
-        # services can add a binding such as `"/v1/`name=users/*`/operations"` to their
-        # service configuration. For backwards compatibility, the default name includes
-        # the operations collection id, however overriding users must ensure the name
-        # binding is the parent resource, without the operations collection id.
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
         # @param [String] name
         #   The name of the operation's parent resource.
         # @param [String] filter
@@ -1241,7 +1678,7 @@ module Google
         #   filtering. The value must be a string, a number, or a boolean. The comparison
         #   operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is
         #   the contains operator. Filter rules are not case sensitive. The following
-        #   fields in the Operation are eligible for filtering: * `name` - The name of the
+        #   fields in the operation are eligible for filtering: * `name` - The name of the
         #   long-running operation * `done` - False if the operation is in progress, else
         #   true. * `metadata.@type` - the type of metadata. For example, the type string
         #   for RestoreDatabaseMetadata is `type.googleapis.com/google.spanner.admin.
@@ -1297,7 +1734,47 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Creates a new Cloud Spanner database and starts to prepare it for serving. The
+        # `ChangeQuorum` is strictly restricted to databases that use dual-region
+        # instance configurations. Initiates a background operation to change the quorum
+        # of a database from dual-region mode to single-region mode or vice versa. The
+        # returned long-running operation has a name of the format `projects//instances//
+        # databases//operations/` and can be used to track execution of the `
+        # ChangeQuorum`. The metadata field type is ChangeQuorumMetadata. Authorization
+        # requires `spanner.databases.changequorum` permission on the resource database.
+        # @param [String] name
+        #   Required. Name of the database in which to apply `ChangeQuorum`. Values are of
+        #   the form `projects//instances//databases/`.
+        # @param [Google::Apis::SpannerV1::ChangeQuorumRequest] change_quorum_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def changequorum_project_instance_database(name, change_quorum_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+name}:changequorum', options)
+          command.request_representation = Google::Apis::SpannerV1::ChangeQuorumRequest::Representation
+          command.request_object = change_quorum_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Creates a new Spanner database and starts to prepare it for serving. The
         # returned long-running operation will have a name of the format `/operations/`
         # and can be used to track preparation of the database. The metadata field type
         # is CreateDatabaseMetadata. The response field type is Database, if successful.
@@ -1435,7 +1912,8 @@ module Google
         # empty policy if a database or backup exists but does not have a policy set.
         # Authorization requires `spanner.databases.getIamPolicy` permission on resource.
         # For backups, authorization requires `spanner.backups.getIamPolicy` permission
-        # on resource.
+        # on resource. For backup schedules, authorization requires `spanner.
+        # backupSchedules.getIamPolicy` permission on resource.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which the policy is being retrieved.
         #   The format is `projects//instances/` for instance resources and `projects//
@@ -1554,6 +2032,60 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
+        # Updates a Cloud Spanner database. The returned long-running operation can be
+        # used to track the progress of updating the database. If the named database
+        # does not exist, returns `NOT_FOUND`. While the operation is pending: * The
+        # database's reconciling field is set to true. * Cancelling the operation is
+        # best-effort. If the cancellation succeeds, the operation metadata's
+        # cancel_time is set, the updates are reverted, and the operation terminates
+        # with a `CANCELLED` status. * New UpdateDatabase requests will return a `
+        # FAILED_PRECONDITION` error until the pending operation is done (returns
+        # successfully or with error). * Reading the database via the API continues to
+        # give the pre-request values. Upon completion of the returned operation: * The
+        # new values are in effect and readable via the API. * The database's
+        # reconciling field becomes false. The returned long-running operation will have
+        # a name of the format `projects//instances//databases//operations/` and can be
+        # used to track the database modification. The metadata field type is
+        # UpdateDatabaseMetadata. The response field type is Database, if successful.
+        # @param [String] name
+        #   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.
+        # @param [Google::Apis::SpannerV1::Database] database_object
+        # @param [String] update_mask
+        #   Required. The list of fields to update. Currently, only `
+        #   enable_drop_protection` field can be updated.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def patch_project_instance_database(name, database_object = nil, update_mask: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:patch, 'v1/{+name}', options)
+          command.request_representation = Google::Apis::SpannerV1::Database::Representation
+          command.request_object = database_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['updateMask'] = update_mask unless update_mask.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
         # Create a new database by restoring from a completed backup. The new database
         # must be in the same project and in an instance with the same instance
         # configuration as the instance containing the backup. The returned database
@@ -1604,7 +2136,8 @@ module Google
         # Sets the access control policy on a database or backup resource. Replaces any
         # existing policy. Authorization requires `spanner.databases.setIamPolicy`
         # permission on resource. For backups, authorization requires `spanner.backups.
-        # setIamPolicy` permission on resource.
+        # setIamPolicy` permission on resource. For backup schedules, authorization
+        # requires `spanner.backupSchedules.setIamPolicy` permission on resource.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which the policy is being set. The
         #   format is `projects//instances/` for instance resources and `projects//
@@ -1645,7 +2178,9 @@ module Google
         # permission on the containing Cloud Spanner instance. Otherwise returns an
         # empty set of permissions. Calling this method on a backup that does not exist
         # will result in a NOT_FOUND error if the user has `spanner.backups.list`
-        # permission on the containing instance.
+        # permission on the containing instance. Calling this method on a backup
+        # schedule that does not exist will result in a NOT_FOUND error if the user has `
+        # spanner.backupSchedules.list` permission on the containing database.
         # @param [String] resource
         #   REQUIRED: The Cloud Spanner resource for which permissions are being tested.
         #   The format is `projects//instances/` for instance resources and `projects//
@@ -1717,16 +2252,14 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Lists Cloud Spanner database roles.
+        # Creates a new backup schedule.
         # @param [String] parent
-        #   Required. The database whose roles should be listed. Values are of the form `
-        #   projects//instances//databases/`.
-        # @param [Fixnum] page_size
-        #   Number of database roles to be returned in the response. If 0 or less,
-        #   defaults to the server's maximum allowed page size.
-        # @param [String] page_token
-        #   If non-empty, `page_token` should contain a next_page_token from a previous
-        #   ListDatabaseRolesResponse.
+        #   Required. The name of the database that this backup schedule applies to.
+        # @param [Google::Apis::SpannerV1::BackupSchedule] backup_schedule_object
+        # @param [String] backup_schedule_id
+        #   Required. The Id to use for the backup schedule. The `backup_schedule_id`
+        #   appended to `parent` forms the full backup schedule name of the form `projects/
+        #   /instances//databases//backupSchedules/`.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1736,77 +2269,31 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ListDatabaseRolesResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::BackupSchedule] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ListDatabaseRolesResponse]
+        # @return [Google::Apis::SpannerV1::BackupSchedule]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def list_project_instance_database_database_roles(parent, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:get, 'v1/{+parent}/databaseRoles', options)
-          command.response_representation = Google::Apis::SpannerV1::ListDatabaseRolesResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::ListDatabaseRolesResponse
+        def create_project_instance_database_backup_schedule(parent, backup_schedule_object = nil, backup_schedule_id: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+parent}/backupSchedules', options)
+          command.request_representation = Google::Apis::SpannerV1::BackupSchedule::Representation
+          command.request_object = backup_schedule_object
+          command.response_representation = Google::Apis::SpannerV1::BackupSchedule::Representation
+          command.response_class = Google::Apis::SpannerV1::BackupSchedule
           command.params['parent'] = parent unless parent.nil?
-          command.query['pageSize'] = page_size unless page_size.nil?
-          command.query['pageToken'] = page_token unless page_token.nil?
-          command.query['fields'] = fields unless fields.nil?
-          command.query['quotaUser'] = quota_user unless quota_user.nil?
-          execute_or_queue_command(command, &block)
-        end
-        
-        # Returns permissions that the caller has on the specified database or backup
-        # resource. Attempting this RPC on a non-existent Cloud Spanner database will
-        # result in a NOT_FOUND error if the user has `spanner.databases.list`
-        # permission on the containing Cloud Spanner instance. Otherwise returns an
-        # empty set of permissions. Calling this method on a backup that does not exist
-        # will result in a NOT_FOUND error if the user has `spanner.backups.list`
-        # permission on the containing instance.
-        # @param [String] resource
-        #   REQUIRED: The Cloud Spanner resource for which permissions are being tested.
-        #   The format is `projects//instances/` for instance resources and `projects//
-        #   instances//databases/` for database resources.
-        # @param [Google::Apis::SpannerV1::TestIamPermissionsRequest] test_iam_permissions_request_object
-        # @param [String] fields
-        #   Selector specifying which fields to include in a partial response.
-        # @param [String] quota_user
-        #   Available to use for quota purposes for server-side applications. Can be any
-        #   arbitrary string assigned to a user, but should not exceed 40 characters.
-        # @param [Google::Apis::RequestOptions] options
-        #   Request-specific options
-        #
-        # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::TestIamPermissionsResponse] parsed result object
-        # @yieldparam err [StandardError] error object if request failed
-        #
-        # @return [Google::Apis::SpannerV1::TestIamPermissionsResponse]
-        #
-        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
-        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
-        # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def test_database_role_iam_permissions(resource, test_iam_permissions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+resource}:testIamPermissions', options)
-          command.request_representation = Google::Apis::SpannerV1::TestIamPermissionsRequest::Representation
-          command.request_object = test_iam_permissions_request_object
-          command.response_representation = Google::Apis::SpannerV1::TestIamPermissionsResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::TestIamPermissionsResponse
-          command.params['resource'] = resource unless resource.nil?
+          command.query['backupScheduleId'] = backup_schedule_id unless backup_schedule_id.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Starts asynchronous cancellation on a long-running operation. The server makes
-        # a best effort to cancel the operation, but success is not guaranteed. If the
-        # server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
-        # 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`.
+        # Deletes a backup schedule.
         # @param [String] name
-        #   The name of the operation resource to be cancelled.
+        #   Required. The name of the schedule to delete. Values are of the form `projects/
+        #   /instances//databases//backupSchedules/`.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1824,8 +2311,8 @@ module Google
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def cancel_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+name}:cancel', options)
+        def delete_project_instance_database_backup_schedule(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
           command.response_representation = Google::Apis::SpannerV1::Empty::Representation
           command.response_class = Google::Apis::SpannerV1::Empty
           command.params['name'] = name unless name.nil?
@@ -1834,12 +2321,10 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Deletes a long-running operation. This method indicates that the client is no
-        # longer interested in the operation result. It does not cancel the operation.
-        # If the server doesn't support this method, it returns `google.rpc.Code.
-        # UNIMPLEMENTED`.
+        # Gets backup schedule for the input schedule name.
         # @param [String] name
-        #   The name of the operation resource to be deleted.
+        #   Required. The name of the schedule to retrieve. Values are of the form `
+        #   projects//instances//databases//backupSchedules/`.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1849,28 +2334,35 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::BackupSchedule] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Empty]
+        # @return [Google::Apis::SpannerV1::BackupSchedule]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def delete_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:delete, 'v1/{+name}', options)
-          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
-          command.response_class = Google::Apis::SpannerV1::Empty
+        def get_project_instance_database_backup_schedule(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::BackupSchedule::Representation
+          command.response_class = Google::Apis::SpannerV1::BackupSchedule
           command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Gets the latest state of a long-running operation. Clients can use this method
-        # to poll the operation result at intervals as recommended by the API service.
-        # @param [String] name
-        #   The name of the operation resource.
+        # Gets the access control policy for a database or backup resource. Returns an
+        # empty policy if a database or backup exists but does not have a policy set.
+        # Authorization requires `spanner.databases.getIamPolicy` permission on resource.
+        # For backups, authorization requires `spanner.backups.getIamPolicy` permission
+        # on resource. For backup schedules, authorization requires `spanner.
+        # backupSchedules.getIamPolicy` permission on resource.
+        # @param [String] resource
+        #   REQUIRED: The Cloud Spanner resource for which the policy is being retrieved.
+        #   The format is `projects//instances/` for instance resources and `projects//
+        #   instances//databases/` for database resources.
+        # @param [Google::Apis::SpannerV1::GetIamPolicyRequest] get_iam_policy_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1880,40 +2372,36 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Policy] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Operation]
+        # @return [Google::Apis::SpannerV1::Policy]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def get_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:get, 'v1/{+name}', options)
-          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
-          command.response_class = Google::Apis::SpannerV1::Operation
-          command.params['name'] = name unless name.nil?
+        def get_backup_schedule_iam_policy(resource, get_iam_policy_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+resource}:getIamPolicy', options)
+          command.request_representation = Google::Apis::SpannerV1::GetIamPolicyRequest::Representation
+          command.request_object = get_iam_policy_request_object
+          command.response_representation = Google::Apis::SpannerV1::Policy::Representation
+          command.response_class = Google::Apis::SpannerV1::Policy
+          command.params['resource'] = resource unless resource.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Lists operations that match the specified filter in the request. If the server
-        # doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the `name`
-        # binding allows API services to override the binding to use different resource
-        # name schemes, such as `users/*/operations`. To override the binding, API
-        # services can add a binding such as `"/v1/`name=users/*`/operations"` to their
-        # service configuration. For backwards compatibility, the default name includes
-        # the operations collection id, however overriding users must ensure the name
-        # binding is the parent resource, without the operations collection id.
-        # @param [String] name
-        #   The name of the operation's parent resource.
-        # @param [String] filter
-        #   The standard list filter.
+        # Lists all the backup schedules for the database.
+        # @param [String] parent
+        #   Required. Database is the parent resource whose backup schedules should be
+        #   listed. Values are of the form projects//instances//databases/
         # @param [Fixnum] page_size
-        #   The standard list page size.
+        #   Optional. Number of backup schedules to be returned in the response. If 0 or
+        #   less, defaults to the server's maximum allowed page size.
         # @param [String] page_token
-        #   The standard list page token.
+        #   Optional. If non-empty, `page_token` should contain a next_page_token from a
+        #   previous ListBackupSchedulesResponse to the same `parent`.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1923,20 +2411,19 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ListOperationsResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::ListBackupSchedulesResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ListOperationsResponse]
+        # @return [Google::Apis::SpannerV1::ListBackupSchedulesResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def list_project_instance_database_operations(name, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:get, 'v1/{+name}', options)
-          command.response_representation = Google::Apis::SpannerV1::ListOperationsResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::ListOperationsResponse
-          command.params['name'] = name unless name.nil?
-          command.query['filter'] = filter unless filter.nil?
+        def list_project_instance_database_backup_schedules(parent, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+parent}/backupSchedules', options)
+          command.response_representation = Google::Apis::SpannerV1::ListBackupSchedulesResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListBackupSchedulesResponse
+          command.params['parent'] = parent unless parent.nil?
           command.query['pageSize'] = page_size unless page_size.nil?
           command.query['pageToken'] = page_token unless page_token.nil?
           command.query['fields'] = fields unless fields.nil?
@@ -1944,12 +2431,19 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Creates multiple new sessions. This API can be used to initialize a session
-        # cache on the clients. See https://goo.gl/TgSFN2 for best practices on session
-        # cache management.
-        # @param [String] database
-        #   Required. The database in which the new sessions are created.
-        # @param [Google::Apis::SpannerV1::BatchCreateSessionsRequest] batch_create_sessions_request_object
+        # Updates a backup schedule.
+        # @param [String] name
+        #   Identifier. Output only for the CreateBackupSchedule operation. Required for
+        #   the UpdateBackupSchedule operation. A globally unique identifier for the
+        #   backup schedule which cannot be changed. Values are of the form `projects//
+        #   instances//databases//backupSchedules/a-z*[a-z0-9]` The final segment of the
+        #   name must be between 2 and 60 characters in length.
+        # @param [Google::Apis::SpannerV1::BackupSchedule] backup_schedule_object
+        # @param [String] update_mask
+        #   Required. A mask specifying which fields in the BackupSchedule resource should
+        #   be updated. This mask is relative to the BackupSchedule resource, not to the
+        #   request message. The field mask must always be specified; this prevents any
+        #   future fields from being erased accidentally.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1959,31 +2453,37 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::BatchCreateSessionsResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::BackupSchedule] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::BatchCreateSessionsResponse]
+        # @return [Google::Apis::SpannerV1::BackupSchedule]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def batch_create_sessions(database, batch_create_sessions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+database}/sessions:batchCreate', options)
-          command.request_representation = Google::Apis::SpannerV1::BatchCreateSessionsRequest::Representation
-          command.request_object = batch_create_sessions_request_object
-          command.response_representation = Google::Apis::SpannerV1::BatchCreateSessionsResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::BatchCreateSessionsResponse
-          command.params['database'] = database unless database.nil?
+        def patch_project_instance_database_backup_schedule(name, backup_schedule_object = nil, update_mask: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:patch, 'v1/{+name}', options)
+          command.request_representation = Google::Apis::SpannerV1::BackupSchedule::Representation
+          command.request_object = backup_schedule_object
+          command.response_representation = Google::Apis::SpannerV1::BackupSchedule::Representation
+          command.response_class = Google::Apis::SpannerV1::BackupSchedule
+          command.params['name'] = name unless name.nil?
+          command.query['updateMask'] = update_mask unless update_mask.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Begins a new transaction. This step can often be skipped: Read, ExecuteSql and
-        # Commit can begin a new transaction as a side-effect.
-        # @param [String] session
-        #   Required. The session in which the transaction runs.
-        # @param [Google::Apis::SpannerV1::BeginTransactionRequest] begin_transaction_request_object
+        # Sets the access control policy on a database or backup resource. Replaces any
+        # existing policy. Authorization requires `spanner.databases.setIamPolicy`
+        # permission on resource. For backups, authorization requires `spanner.backups.
+        # setIamPolicy` permission on resource. For backup schedules, authorization
+        # requires `spanner.backupSchedules.setIamPolicy` permission on resource.
+        # @param [String] resource
+        #   REQUIRED: The Cloud Spanner resource for which the policy is being set. The
+        #   format is `projects//instances/` for instance resources and `projects//
+        #   instances//databases/` for databases resources.
+        # @param [Google::Apis::SpannerV1::SetIamPolicyRequest] set_iam_policy_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -1993,39 +2493,725 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Transaction] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Policy] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Transaction]
+        # @return [Google::Apis::SpannerV1::Policy]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def begin_session_transaction(session, begin_transaction_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:beginTransaction', options)
-          command.request_representation = Google::Apis::SpannerV1::BeginTransactionRequest::Representation
-          command.request_object = begin_transaction_request_object
-          command.response_representation = Google::Apis::SpannerV1::Transaction::Representation
-          command.response_class = Google::Apis::SpannerV1::Transaction
-          command.params['session'] = session unless session.nil?
-          command.query['fields'] = fields unless fields.nil?
-          command.query['quotaUser'] = quota_user unless quota_user.nil?
+        def set_backup_schedule_iam_policy(resource, set_iam_policy_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+resource}:setIamPolicy', options)
+          command.request_representation = Google::Apis::SpannerV1::SetIamPolicyRequest::Representation
+          command.request_object = set_iam_policy_request_object
+          command.response_representation = Google::Apis::SpannerV1::Policy::Representation
+          command.response_class = Google::Apis::SpannerV1::Policy
+          command.params['resource'] = resource unless resource.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Returns permissions that the caller has on the specified database or backup
+        # resource. Attempting this RPC on a non-existent Cloud Spanner database will
+        # result in a NOT_FOUND error if the user has `spanner.databases.list`
+        # permission on the containing Cloud Spanner instance. Otherwise returns an
+        # empty set of permissions. Calling this method on a backup that does not exist
+        # will result in a NOT_FOUND error if the user has `spanner.backups.list`
+        # permission on the containing instance. Calling this method on a backup
+        # schedule that does not exist will result in a NOT_FOUND error if the user has `
+        # spanner.backupSchedules.list` permission on the containing database.
+        # @param [String] resource
+        #   REQUIRED: The Cloud Spanner resource for which permissions are being tested.
+        #   The format is `projects//instances/` for instance resources and `projects//
+        #   instances//databases/` for database resources.
+        # @param [Google::Apis::SpannerV1::TestIamPermissionsRequest] test_iam_permissions_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::TestIamPermissionsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::TestIamPermissionsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def test_backup_schedule_iam_permissions(resource, test_iam_permissions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+resource}:testIamPermissions', options)
+          command.request_representation = Google::Apis::SpannerV1::TestIamPermissionsRequest::Representation
+          command.request_object = test_iam_permissions_request_object
+          command.response_representation = Google::Apis::SpannerV1::TestIamPermissionsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::TestIamPermissionsResponse
+          command.params['resource'] = resource unless resource.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Lists Cloud Spanner database roles.
+        # @param [String] parent
+        #   Required. The database whose roles should be listed. Values are of the form `
+        #   projects//instances//databases/`.
+        # @param [Fixnum] page_size
+        #   Number of database roles to be returned in the response. If 0 or less,
+        #   defaults to the server's maximum allowed page size.
+        # @param [String] page_token
+        #   If non-empty, `page_token` should contain a next_page_token from a previous
+        #   ListDatabaseRolesResponse.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ListDatabaseRolesResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ListDatabaseRolesResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_project_instance_database_database_roles(parent, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+parent}/databaseRoles', options)
+          command.response_representation = Google::Apis::SpannerV1::ListDatabaseRolesResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListDatabaseRolesResponse
+          command.params['parent'] = parent unless parent.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Returns permissions that the caller has on the specified database or backup
+        # resource. Attempting this RPC on a non-existent Cloud Spanner database will
+        # result in a NOT_FOUND error if the user has `spanner.databases.list`
+        # permission on the containing Cloud Spanner instance. Otherwise returns an
+        # empty set of permissions. Calling this method on a backup that does not exist
+        # will result in a NOT_FOUND error if the user has `spanner.backups.list`
+        # permission on the containing instance. Calling this method on a backup
+        # schedule that does not exist will result in a NOT_FOUND error if the user has `
+        # spanner.backupSchedules.list` permission on the containing database.
+        # @param [String] resource
+        #   REQUIRED: The Cloud Spanner resource for which permissions are being tested.
+        #   The format is `projects//instances/` for instance resources and `projects//
+        #   instances//databases/` for database resources.
+        # @param [Google::Apis::SpannerV1::TestIamPermissionsRequest] test_iam_permissions_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::TestIamPermissionsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::TestIamPermissionsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def test_database_role_iam_permissions(resource, test_iam_permissions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+resource}:testIamPermissions', options)
+          command.request_representation = Google::Apis::SpannerV1::TestIamPermissionsRequest::Representation
+          command.request_object = test_iam_permissions_request_object
+          command.response_representation = Google::Apis::SpannerV1::TestIamPermissionsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::TestIamPermissionsResponse
+          command.params['resource'] = resource unless resource.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Starts asynchronous cancellation on a long-running operation. The server makes
+        # a best effort to cancel the operation, but success is not guaranteed. If the
+        # server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+        # 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`.
+        # @param [String] name
+        #   The name of the operation resource to be cancelled.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def cancel_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+name}:cancel', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Deletes a long-running operation. This method indicates that the client is no
+        # longer interested in the operation result. It does not cancel the operation.
+        # If the server doesn't support this method, it returns `google.rpc.Code.
+        # UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation resource to be deleted.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def delete_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Gets the latest state of a long-running operation. Clients can use this method
+        # to poll the operation result at intervals as recommended by the API service.
+        # @param [String] name
+        #   The name of the operation resource.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Operation]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def get_project_instance_database_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Lists operations that match the specified filter in the request. If the server
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation's parent resource.
+        # @param [String] filter
+        #   The standard list filter.
+        # @param [Fixnum] page_size
+        #   The standard list page size.
+        # @param [String] page_token
+        #   The standard list page token.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ListOperationsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ListOperationsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_project_instance_database_operations(name, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::ListOperationsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListOperationsResponse
+          command.params['name'] = name unless name.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Creates multiple new sessions. This API can be used to initialize a session
+        # cache on the clients. See https://goo.gl/TgSFN2 for best practices on session
+        # cache management.
+        # @param [String] database
+        #   Required. The database in which the new sessions are created.
+        # @param [Google::Apis::SpannerV1::BatchCreateSessionsRequest] batch_create_sessions_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::BatchCreateSessionsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::BatchCreateSessionsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def batch_create_sessions(database, batch_create_sessions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+database}/sessions:batchCreate', options)
+          command.request_representation = Google::Apis::SpannerV1::BatchCreateSessionsRequest::Representation
+          command.request_object = batch_create_sessions_request_object
+          command.response_representation = Google::Apis::SpannerV1::BatchCreateSessionsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::BatchCreateSessionsResponse
+          command.params['database'] = database unless database.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Batches the supplied mutation groups in a collection of efficient transactions.
+        # All mutations in a group are committed atomically. However, mutations across
+        # groups can be committed non-atomically in an unspecified order and thus, they
+        # must be independent of each other. Partial failure is possible, i.e., some
+        # groups may have been committed successfully, while some may have failed. The
+        # results of individual batches are streamed into the response as the batches
+        # are applied. BatchWrite requests are not replay protected, meaning that each
+        # mutation group may be applied more than once. Replays of non-idempotent
+        # mutations may have undesirable effects. For example, replays of an insert
+        # mutation may produce an already exists error or if you use generated or commit
+        # timestamp-based keys, it may result in additional rows being added to the
+        # mutation's table. We recommend structuring your mutation groups to be
+        # idempotent to avoid this issue.
+        # @param [String] session
+        #   Required. The session in which the batch request is to be run.
+        # @param [Google::Apis::SpannerV1::BatchWriteRequest] batch_write_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::BatchWriteResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::BatchWriteResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def batch_session_write(session, batch_write_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:batchWrite', options)
+          command.request_representation = Google::Apis::SpannerV1::BatchWriteRequest::Representation
+          command.request_object = batch_write_request_object
+          command.response_representation = Google::Apis::SpannerV1::BatchWriteResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::BatchWriteResponse
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Begins a new transaction. This step can often be skipped: Read, ExecuteSql and
+        # Commit can begin a new transaction as a side-effect.
+        # @param [String] session
+        #   Required. The session in which the transaction runs.
+        # @param [Google::Apis::SpannerV1::BeginTransactionRequest] begin_transaction_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Transaction] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Transaction]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def begin_session_transaction(session, begin_transaction_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:beginTransaction', options)
+          command.request_representation = Google::Apis::SpannerV1::BeginTransactionRequest::Representation
+          command.request_object = begin_transaction_request_object
+          command.response_representation = Google::Apis::SpannerV1::Transaction::Representation
+          command.response_class = Google::Apis::SpannerV1::Transaction
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Commits a transaction. The request includes the mutations to be applied to
+        # rows in the database. `Commit` might return an `ABORTED` error. This can occur
+        # at any time; commonly, the cause is conflicts with concurrent transactions.
+        # However, it can also happen for a variety of other reasons. If `Commit`
+        # returns `ABORTED`, the caller should re-attempt the transaction from the
+        # beginning, re-using the same session. On very rare occasions, `Commit` might
+        # return `UNKNOWN`. This can happen, for example, if the client job experiences
+        # a 1+ hour networking failure. At that point, Cloud Spanner has lost track of
+        # the transaction outcome and we recommend that you perform another read from
+        # the database to see the state of things as they are now.
+        # @param [String] session
+        #   Required. The session in which the transaction to be committed is running.
+        # @param [Google::Apis::SpannerV1::CommitRequest] commit_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::CommitResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::CommitResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def commit_session(session, commit_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:commit', options)
+          command.request_representation = Google::Apis::SpannerV1::CommitRequest::Representation
+          command.request_object = commit_request_object
+          command.response_representation = Google::Apis::SpannerV1::CommitResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::CommitResponse
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Creates a new session. A session can be used to perform transactions that read
+        # and/or modify data in a Cloud Spanner database. Sessions are meant to be
+        # reused for many consecutive transactions. Sessions can only execute one
+        # transaction at a time. To execute multiple concurrent read-write/write-only
+        # transactions, create multiple sessions. Note that standalone reads and queries
+        # use a transaction internally, and count toward the one transaction limit.
+        # Active sessions use additional server resources, so it is a good idea to
+        # delete idle and unneeded sessions. Aside from explicit deletes, Cloud Spanner
+        # may delete sessions for which no operations are sent for more than an hour. If
+        # a session is deleted, requests to it return `NOT_FOUND`. Idle sessions can be
+        # kept alive by sending a trivial SQL query periodically, e.g., `"SELECT 1"`.
+        # @param [String] database
+        #   Required. The database in which the new session is created.
+        # @param [Google::Apis::SpannerV1::CreateSessionRequest] create_session_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Session] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Session]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def create_project_instance_database_session(database, create_session_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+database}/sessions', options)
+          command.request_representation = Google::Apis::SpannerV1::CreateSessionRequest::Representation
+          command.request_object = create_session_request_object
+          command.response_representation = Google::Apis::SpannerV1::Session::Representation
+          command.response_class = Google::Apis::SpannerV1::Session
+          command.params['database'] = database unless database.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Ends a session, releasing server resources associated with it. This will
+        # asynchronously trigger cancellation of any operations that are running with
+        # this session.
+        # @param [String] name
+        #   Required. The name of the session to delete.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Empty]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def delete_project_instance_database_session(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Executes a batch of SQL DML statements. This method allows many statements to
+        # be run with lower latency than submitting them sequentially with ExecuteSql.
+        # Statements are executed in sequential order. A request can succeed even if a
+        # statement fails. The ExecuteBatchDmlResponse.status field in the response
+        # provides information about the statement that failed. Clients must inspect
+        # this field to determine whether an error occurred. Execution stops after the
+        # first failed statement; the remaining statements are not executed.
+        # @param [String] session
+        #   Required. The session in which the DML statements should be performed.
+        # @param [Google::Apis::SpannerV1::ExecuteBatchDmlRequest] execute_batch_dml_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ExecuteBatchDmlResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ExecuteBatchDmlResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_session_batch_dml(session, execute_batch_dml_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:executeBatchDml', options)
+          command.request_representation = Google::Apis::SpannerV1::ExecuteBatchDmlRequest::Representation
+          command.request_object = execute_batch_dml_request_object
+          command.response_representation = Google::Apis::SpannerV1::ExecuteBatchDmlResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ExecuteBatchDmlResponse
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Executes an SQL statement, returning all results in a single reply. This
+        # method cannot be used to return a result set larger than 10 MiB; if the query
+        # yields more data than that, the query fails with a `FAILED_PRECONDITION` error.
+        # Operations inside read-write transactions might return `ABORTED`. If this
+        # occurs, the application should restart the transaction from the beginning. See
+        # Transaction for more details. Larger result sets can be fetched in streaming
+        # fashion by calling ExecuteStreamingSql instead.
+        # @param [String] session
+        #   Required. The session in which the SQL query should be performed.
+        # @param [Google::Apis::SpannerV1::ExecuteSqlRequest] execute_sql_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ResultSet] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ResultSet]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_session_sql(session, execute_sql_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:executeSql', options)
+          command.request_representation = Google::Apis::SpannerV1::ExecuteSqlRequest::Representation
+          command.request_object = execute_sql_request_object
+          command.response_representation = Google::Apis::SpannerV1::ResultSet::Representation
+          command.response_class = Google::Apis::SpannerV1::ResultSet
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Like ExecuteSql, except returns the result set as a stream. Unlike ExecuteSql,
+        # there is no limit on the size of the returned result set. However, no
+        # individual row in the result set can exceed 100 MiB, and no column value can
+        # exceed 10 MiB.
+        # @param [String] session
+        #   Required. The session in which the SQL query should be performed.
+        # @param [Google::Apis::SpannerV1::ExecuteSqlRequest] execute_sql_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::PartialResultSet] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::PartialResultSet]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_project_instance_database_session_streaming_sql(session, execute_sql_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:executeStreamingSql', options)
+          command.request_representation = Google::Apis::SpannerV1::ExecuteSqlRequest::Representation
+          command.request_object = execute_sql_request_object
+          command.response_representation = Google::Apis::SpannerV1::PartialResultSet::Representation
+          command.response_class = Google::Apis::SpannerV1::PartialResultSet
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Gets a session. Returns `NOT_FOUND` if the session does not exist. This is
+        # mainly useful for determining whether a session is still alive.
+        # @param [String] name
+        #   Required. The name of the session to retrieve.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::Session] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::Session]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def get_project_instance_database_session(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Session::Representation
+          command.response_class = Google::Apis::SpannerV1::Session
+          command.params['name'] = name unless name.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Commits a transaction. The request includes the mutations to be applied to
-        # rows in the database. `Commit` might return an `ABORTED` error. This can occur
-        # at any time; commonly, the cause is conflicts with concurrent transactions.
-        # However, it can also happen for a variety of other reasons. If `Commit`
-        # returns `ABORTED`, the caller should re-attempt the transaction from the
-        # beginning, re-using the same session. On very rare occasions, `Commit` might
-        # return `UNKNOWN`. This can happen, for example, if the client job experiences
-        # a 1+ hour networking failure. At that point, Cloud Spanner has lost track of
-        # the transaction outcome and we recommend that you perform another read from
-        # the database to see the state of things as they are now.
+        # Lists all sessions in a given database.
+        # @param [String] database
+        #   Required. The database in which to list sessions.
+        # @param [String] filter
+        #   An expression for filtering the results of the request. Filter rules are case
+        #   insensitive. The fields eligible for filtering are: * `labels.key` where key
+        #   is the name of a label Some examples of using filters are: * `labels.env:*` -->
+        #   The session has the label "env". * `labels.env:dev` --> The session has the
+        #   label "env" and the value of the label contains the string "dev".
+        # @param [Fixnum] page_size
+        #   Number of sessions to be returned in the response. If 0 or less, defaults to
+        #   the server's maximum allowed page size.
+        # @param [String] page_token
+        #   If non-empty, `page_token` should contain a next_page_token from a previous
+        #   ListSessionsResponse.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ListSessionsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ListSessionsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_project_instance_database_sessions(database, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+database}/sessions', options)
+          command.response_representation = Google::Apis::SpannerV1::ListSessionsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListSessionsResponse
+          command.params['database'] = database unless database.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Creates a set of partition tokens that can be used to execute a query
+        # operation in parallel. Each of the returned partition tokens can be used by
+        # ExecuteStreamingSql to specify a subset of the query result to read. The same
+        # session and read-only transaction must be used by the PartitionQueryRequest
+        # used to create the partition tokens and the ExecuteSqlRequests that use the
+        # partition tokens. Partition tokens become invalid when the session used to
+        # create them is deleted, is idle for too long, begins a new transaction, or
+        # becomes too old. When any of these happen, it is not possible to resume the
+        # query, and the whole operation must be restarted from the beginning.
         # @param [String] session
-        #   Required. The session in which the transaction to be committed is running.
-        # @param [Google::Apis::SpannerV1::CommitRequest] commit_request_object
+        #   Required. The session used to create the partitions.
+        # @param [Google::Apis::SpannerV1::PartitionQueryRequest] partition_query_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2035,40 +3221,40 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::CommitResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::PartitionResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::CommitResponse]
+        # @return [Google::Apis::SpannerV1::PartitionResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def commit_session(session, commit_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:commit', options)
-          command.request_representation = Google::Apis::SpannerV1::CommitRequest::Representation
-          command.request_object = commit_request_object
-          command.response_representation = Google::Apis::SpannerV1::CommitResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::CommitResponse
+        def partition_session_query(session, partition_query_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:partitionQuery', options)
+          command.request_representation = Google::Apis::SpannerV1::PartitionQueryRequest::Representation
+          command.request_object = partition_query_request_object
+          command.response_representation = Google::Apis::SpannerV1::PartitionResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::PartitionResponse
           command.params['session'] = session unless session.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Creates a new session. A session can be used to perform transactions that read
-        # and/or modify data in a Cloud Spanner database. Sessions are meant to be
-        # reused for many consecutive transactions. Sessions can only execute one
-        # transaction at a time. To execute multiple concurrent read-write/write-only
-        # transactions, create multiple sessions. Note that standalone reads and queries
-        # use a transaction internally, and count toward the one transaction limit.
-        # Active sessions use additional server resources, so it is a good idea to
-        # delete idle and unneeded sessions. Aside from explicit deletes, Cloud Spanner
-        # may delete sessions for which no operations are sent for more than an hour. If
-        # a session is deleted, requests to it return `NOT_FOUND`. Idle sessions can be
-        # kept alive by sending a trivial SQL query periodically, e.g., `"SELECT 1"`.
-        # @param [String] database
-        #   Required. The database in which the new session is created.
-        # @param [Google::Apis::SpannerV1::CreateSessionRequest] create_session_request_object
+        # Creates a set of partition tokens that can be used to execute a read operation
+        # in parallel. Each of the returned partition tokens can be used by
+        # StreamingRead to specify a subset of the read result to read. The same session
+        # and read-only transaction must be used by the PartitionReadRequest used to
+        # create the partition tokens and the ReadRequests that use the partition tokens.
+        # There are no ordering guarantees on rows returned among the returned
+        # partition tokens, or even within each individual StreamingRead call issued
+        # with a partition_token. Partition tokens become invalid when the session used
+        # to create them is deleted, is idle for too long, begins a new transaction, or
+        # becomes too old. When any of these happen, it is not possible to resume the
+        # read, and the whole operation must be restarted from the beginning.
+        # @param [String] session
+        #   Required. The session used to create the partitions.
+        # @param [Google::Apis::SpannerV1::PartitionReadRequest] partition_read_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2078,31 +3264,74 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Session] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::PartitionResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Session]
+        # @return [Google::Apis::SpannerV1::PartitionResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def create_project_instance_database_session(database, create_session_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+database}/sessions', options)
-          command.request_representation = Google::Apis::SpannerV1::CreateSessionRequest::Representation
-          command.request_object = create_session_request_object
-          command.response_representation = Google::Apis::SpannerV1::Session::Representation
-          command.response_class = Google::Apis::SpannerV1::Session
-          command.params['database'] = database unless database.nil?
+        def partition_session_read(session, partition_read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:partitionRead', options)
+          command.request_representation = Google::Apis::SpannerV1::PartitionReadRequest::Representation
+          command.request_object = partition_read_request_object
+          command.response_representation = Google::Apis::SpannerV1::PartitionResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::PartitionResponse
+          command.params['session'] = session unless session.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Ends a session, releasing server resources associated with it. This will
-        # asynchronously trigger cancellation of any operations that are running with
-        # this session.
-        # @param [String] name
-        #   Required. The name of the session to delete.
+        # Reads rows from the database using key lookups and scans, as a simple key/
+        # value style alternative to ExecuteSql. This method cannot be used to return a
+        # result set larger than 10 MiB; if the read matches more data than that, the
+        # read fails with a `FAILED_PRECONDITION` error. Reads inside read-write
+        # transactions might return `ABORTED`. If this occurs, the application should
+        # restart the transaction from the beginning. See Transaction for more details.
+        # Larger result sets can be yielded in streaming fashion by calling
+        # StreamingRead instead.
+        # @param [String] session
+        #   Required. The session in which the read should be performed.
+        # @param [Google::Apis::SpannerV1::ReadRequest] read_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::ResultSet] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::ResultSet]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def read_session(session, read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:read', options)
+          command.request_representation = Google::Apis::SpannerV1::ReadRequest::Representation
+          command.request_object = read_request_object
+          command.response_representation = Google::Apis::SpannerV1::ResultSet::Representation
+          command.response_class = Google::Apis::SpannerV1::ResultSet
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Rolls back a transaction, releasing any locks it holds. It is a good idea to
+        # call this for any transaction that includes one or more Read or ExecuteSql
+        # requests and ultimately decides not to commit. `Rollback` returns `OK` if it
+        # successfully aborts the transaction, the transaction was already aborted, or
+        # the transaction is not found. `Rollback` never returns `ABORTED`.
+        # @param [String] session
+        #   Required. The session in which the transaction to roll back is running.
+        # @param [Google::Apis::SpannerV1::RollbackRequest] rollback_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2120,26 +3349,102 @@ module Google
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def delete_project_instance_database_session(name, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:delete, 'v1/{+name}', options)
+        def rollback_session(session, rollback_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:rollback', options)
+          command.request_representation = Google::Apis::SpannerV1::RollbackRequest::Representation
+          command.request_object = rollback_request_object
           command.response_representation = Google::Apis::SpannerV1::Empty::Representation
           command.response_class = Google::Apis::SpannerV1::Empty
-          command.params['name'] = name unless name.nil?
+          command.params['session'] = session unless session.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Executes a batch of SQL DML statements. This method allows many statements to
-        # be run with lower latency than submitting them sequentially with ExecuteSql.
-        # Statements are executed in sequential order. A request can succeed even if a
-        # statement fails. The ExecuteBatchDmlResponse.status field in the response
-        # provides information about the statement that failed. Clients must inspect
-        # this field to determine whether an error occurred. Execution stops after the
-        # first failed statement; the remaining statements are not executed.
+        # Like Read, except returns the result set as a stream. Unlike Read, there is no
+        # limit on the size of the returned result set. However, no individual row in
+        # the result set can exceed 100 MiB, and no column value can exceed 10 MiB.
         # @param [String] session
-        #   Required. The session in which the DML statements should be performed.
-        # @param [Google::Apis::SpannerV1::ExecuteBatchDmlRequest] execute_batch_dml_request_object
+        #   Required. The session in which the read should be performed.
+        # @param [Google::Apis::SpannerV1::ReadRequest] read_request_object
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SpannerV1::PartialResultSet] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SpannerV1::PartialResultSet]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def streaming_project_instance_database_session_read(session, read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+session}:streamingRead', options)
+          command.request_representation = Google::Apis::SpannerV1::ReadRequest::Representation
+          command.request_object = read_request_object
+          command.response_representation = Google::Apis::SpannerV1::PartialResultSet::Representation
+          command.response_class = Google::Apis::SpannerV1::PartialResultSet
+          command.params['session'] = session unless session.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Lists instance partition long-running operations in the given instance. An
+        # instance partition operation has a name of the form `projects//instances//
+        # instancePartitions//operations/`. The long-running operation metadata field
+        # type `metadata.type_url` describes the type of the metadata. Operations
+        # returned include those that have completed/failed/canceled within the last 7
+        # days, and pending operations. Operations returned are ordered by `operation.
+        # metadata.value.start_time` in descending order starting from the most recently
+        # started operation. Authorization requires `spanner.instancePartitionOperations.
+        # list` permission on the resource parent.
+        # @param [String] parent
+        #   Required. The parent instance of the instance partition operations. Values are
+        #   of the form `projects//instances/`.
+        # @param [String] filter
+        #   Optional. An expression that filters the list of returned operations. A filter
+        #   expression consists of a field name, a comparison operator, and a value for
+        #   filtering. The value must be a string, a number, or a boolean. The comparison
+        #   operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is
+        #   the contains operator. Filter rules are not case sensitive. The following
+        #   fields in the Operation are eligible for filtering: * `name` - The name of the
+        #   long-running operation * `done` - False if the operation is in progress, else
+        #   true. * `metadata.@type` - the type of metadata. For example, the type string
+        #   for CreateInstancePartitionMetadata is `type.googleapis.com/google.spanner.
+        #   admin.instance.v1.CreateInstancePartitionMetadata`. * `metadata.` - any field
+        #   in metadata.value. `metadata.@type` must be specified first, if filtering on
+        #   metadata fields. * `error` - Error associated with the long-running operation.
+        #   * `response.@type` - the type of response. * `response.` - any field in
+        #   response.value. You can combine multiple expressions by enclosing each
+        #   expression in parentheses. By default, expressions are combined with AND logic.
+        #   However, you can specify AND, OR, and NOT logic explicitly. Here are a few
+        #   examples: * `done:true` - The operation is complete. * `(metadata.@type=` \ `
+        #   type.googleapis.com/google.spanner.admin.instance.v1.
+        #   CreateInstancePartitionMetadata) AND` \ `(metadata.instance_partition.name:
+        #   custom-instance-partition) AND` \ `(metadata.start_time < \"2021-03-28T14:50:
+        #   00Z\") AND` \ `(error:*)` - Return operations where: * The operation's
+        #   metadata type is CreateInstancePartitionMetadata. * The instance partition
+        #   name contains "custom-instance-partition". * The operation started before 2021-
+        #   03-28T14:50:00Z. * The operation resulted in an error.
+        # @param [String] instance_partition_deadline
+        #   Optional. Deadline used while retrieving metadata for instance partition
+        #   operations. Instance partitions whose operation metadata cannot be retrieved
+        #   within this deadline will be added to unreachable_instance_partitions in
+        #   ListInstancePartitionOperationsResponse.
+        # @param [Fixnum] page_size
+        #   Optional. Number of operations to be returned in the response. If 0 or less,
+        #   defaults to the server's maximum allowed page size.
+        # @param [String] page_token
+        #   Optional. If non-empty, `page_token` should contain a next_page_token from a
+        #   previous ListInstancePartitionOperationsResponse to the same `parent` and with
+        #   the same `filter`.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2149,36 +3454,50 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ExecuteBatchDmlResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::ListInstancePartitionOperationsResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ExecuteBatchDmlResponse]
+        # @return [Google::Apis::SpannerV1::ListInstancePartitionOperationsResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def execute_session_batch_dml(session, execute_batch_dml_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:executeBatchDml', options)
-          command.request_representation = Google::Apis::SpannerV1::ExecuteBatchDmlRequest::Representation
-          command.request_object = execute_batch_dml_request_object
-          command.response_representation = Google::Apis::SpannerV1::ExecuteBatchDmlResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::ExecuteBatchDmlResponse
-          command.params['session'] = session unless session.nil?
+        def list_project_instance_single_instance_partition_operations(parent, filter: nil, instance_partition_deadline: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+parent}/instancePartitionOperations', options)
+          command.response_representation = Google::Apis::SpannerV1::ListInstancePartitionOperationsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListInstancePartitionOperationsResponse
+          command.params['parent'] = parent unless parent.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['instancePartitionDeadline'] = instance_partition_deadline unless instance_partition_deadline.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Executes an SQL statement, returning all results in a single reply. This
-        # method cannot be used to return a result set larger than 10 MiB; if the query
-        # yields more data than that, the query fails with a `FAILED_PRECONDITION` error.
-        # Operations inside read-write transactions might return `ABORTED`. If this
-        # occurs, the application should restart the transaction from the beginning. See
-        # Transaction for more details. Larger result sets can be fetched in streaming
-        # fashion by calling ExecuteStreamingSql instead.
-        # @param [String] session
-        #   Required. The session in which the SQL query should be performed.
-        # @param [Google::Apis::SpannerV1::ExecuteSqlRequest] execute_sql_request_object
+        # Creates an instance partition and begins preparing it to be used. The returned
+        # long-running operation can be used to track the progress of preparing the new
+        # instance partition. The instance partition name is assigned by the caller. If
+        # the named instance partition already exists, `CreateInstancePartition` returns
+        # `ALREADY_EXISTS`. Immediately upon completion of this request: * The instance
+        # partition is readable via the API, with all requested attributes but no
+        # allocated resources. Its state is `CREATING`. Until completion of the returned
+        # operation: * Cancelling the operation renders the instance partition
+        # immediately unreadable via the API. * The instance partition can be deleted. *
+        # All other attempts to modify the instance partition are rejected. Upon
+        # completion of the returned operation: * Billing for all successfully-allocated
+        # resources begins (some types may have lower than the requested levels). *
+        # Databases can start using this instance partition. * The instance partition's
+        # allocated resource levels are readable via the API. * The instance partition's
+        # state becomes `READY`. The returned long-running operation will have a name of
+        # the format `/operations/` and can be used to track creation of the instance
+        # partition. The metadata field type is CreateInstancePartitionMetadata. The
+        # response field type is InstancePartition, if successful.
+        # @param [String] parent
+        #   Required. The name of the instance in which to create the instance partition.
+        #   Values are of the form `projects//instances/`.
+        # @param [Google::Apis::SpannerV1::CreateInstancePartitionRequest] create_instance_partition_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2188,33 +3507,39 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ResultSet] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ResultSet]
+        # @return [Google::Apis::SpannerV1::Operation]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def execute_session_sql(session, execute_sql_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:executeSql', options)
-          command.request_representation = Google::Apis::SpannerV1::ExecuteSqlRequest::Representation
-          command.request_object = execute_sql_request_object
-          command.response_representation = Google::Apis::SpannerV1::ResultSet::Representation
-          command.response_class = Google::Apis::SpannerV1::ResultSet
-          command.params['session'] = session unless session.nil?
+        def create_instance_partition(parent, create_instance_partition_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+parent}/instancePartitions', options)
+          command.request_representation = Google::Apis::SpannerV1::CreateInstancePartitionRequest::Representation
+          command.request_object = create_instance_partition_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['parent'] = parent unless parent.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Like ExecuteSql, except returns the result set as a stream. Unlike ExecuteSql,
-        # there is no limit on the size of the returned result set. However, no
-        # individual row in the result set can exceed 100 MiB, and no column value can
-        # exceed 10 MiB.
-        # @param [String] session
-        #   Required. The session in which the SQL query should be performed.
-        # @param [Google::Apis::SpannerV1::ExecuteSqlRequest] execute_sql_request_object
+        # Deletes an existing instance partition. Requires that the instance partition
+        # is not used by any database or backup and is not the default instance
+        # partition of an instance. Authorization requires `spanner.instancePartitions.
+        # delete` permission on the resource name.
+        # @param [String] name
+        #   Required. The name of the instance partition to be deleted. Values are of the
+        #   form `projects/`project`/instances/`instance`/instancePartitions/`
+        #   instance_partition``
+        # @param [String] etag
+        #   Optional. If not empty, the API only deletes the instance partition when the
+        #   etag provided matches the current status of the requested instance partition.
+        #   Otherwise, deletes the instance partition without checking the current status
+        #   of the requested instance partition.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2224,30 +3549,30 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::PartialResultSet] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::PartialResultSet]
+        # @return [Google::Apis::SpannerV1::Empty]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def execute_project_instance_database_session_streaming_sql(session, execute_sql_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:executeStreamingSql', options)
-          command.request_representation = Google::Apis::SpannerV1::ExecuteSqlRequest::Representation
-          command.request_object = execute_sql_request_object
-          command.response_representation = Google::Apis::SpannerV1::PartialResultSet::Representation
-          command.response_class = Google::Apis::SpannerV1::PartialResultSet
-          command.params['session'] = session unless session.nil?
+        def delete_project_instance_instance_partition(name, etag: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
+          command.query['etag'] = etag unless etag.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Gets a session. Returns `NOT_FOUND` if the session does not exist. This is
-        # mainly useful for determining whether a session is still alive.
+        # Gets information about a particular instance partition.
         # @param [String] name
-        #   Required. The name of the session to retrieve.
+        #   Required. The name of the requested instance partition. Values are of the form
+        #   `projects/`project`/instances/`instance`/instancePartitions/`
+        #   instance_partition``.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2257,39 +3582,40 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Session] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::InstancePartition] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Session]
+        # @return [Google::Apis::SpannerV1::InstancePartition]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def get_project_instance_database_session(name, fields: nil, quota_user: nil, options: nil, &block)
+        def get_project_instance_instance_partition(name, fields: nil, quota_user: nil, options: nil, &block)
           command = make_simple_command(:get, 'v1/{+name}', options)
-          command.response_representation = Google::Apis::SpannerV1::Session::Representation
-          command.response_class = Google::Apis::SpannerV1::Session
+          command.response_representation = Google::Apis::SpannerV1::InstancePartition::Representation
+          command.response_class = Google::Apis::SpannerV1::InstancePartition
           command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Lists all sessions in a given database.
-        # @param [String] database
-        #   Required. The database in which to list sessions.
-        # @param [String] filter
-        #   An expression for filtering the results of the request. Filter rules are case
-        #   insensitive. The fields eligible for filtering are: * `labels.key` where key
-        #   is the name of a label Some examples of using filters are: * `labels.env:*` -->
-        #   The session has the label "env". * `labels.env:dev` --> The session has the
-        #   label "env" and the value of the label contains the string "dev".
+        # Lists all instance partitions for the given instance.
+        # @param [String] parent
+        #   Required. The instance whose instance partitions should be listed. Values are
+        #   of the form `projects//instances/`. Use ``instance` = '-'` to list instance
+        #   partitions for all Instances in a project, e.g., `projects/myproject/instances/
+        #   -`.
+        # @param [String] instance_partition_deadline
+        #   Optional. Deadline used while retrieving metadata for instance partitions.
+        #   Instance partitions whose metadata cannot be retrieved within this deadline
+        #   will be added to unreachable in ListInstancePartitionsResponse.
         # @param [Fixnum] page_size
-        #   Number of sessions to be returned in the response. If 0 or less, defaults to
-        #   the server's maximum allowed page size.
+        #   Number of instance partitions to be returned in the response. If 0 or less,
+        #   defaults to the server's maximum allowed page size.
         # @param [String] page_token
         #   If non-empty, `page_token` should contain a next_page_token from a previous
-        #   ListSessionsResponse.
+        #   ListInstancePartitionsResponse.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2299,20 +3625,20 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ListSessionsResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::ListInstancePartitionsResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ListSessionsResponse]
+        # @return [Google::Apis::SpannerV1::ListInstancePartitionsResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def list_project_instance_database_sessions(database, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:get, 'v1/{+database}/sessions', options)
-          command.response_representation = Google::Apis::SpannerV1::ListSessionsResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::ListSessionsResponse
-          command.params['database'] = database unless database.nil?
-          command.query['filter'] = filter unless filter.nil?
+        def list_project_instance_instance_partitions(parent, instance_partition_deadline: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+parent}/instancePartitions', options)
+          command.response_representation = Google::Apis::SpannerV1::ListInstancePartitionsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListInstancePartitionsResponse
+          command.params['parent'] = parent unless parent.nil?
+          command.query['instancePartitionDeadline'] = instance_partition_deadline unless instance_partition_deadline.nil?
           command.query['pageSize'] = page_size unless page_size.nil?
           command.query['pageToken'] = page_token unless page_token.nil?
           command.query['fields'] = fields unless fields.nil?
@@ -2320,18 +3646,33 @@ module Google
           execute_or_queue_command(command, &block)
         end
         
-        # Creates a set of partition tokens that can be used to execute a query
-        # operation in parallel. Each of the returned partition tokens can be used by
-        # ExecuteStreamingSql to specify a subset of the query result to read. The same
-        # session and read-only transaction must be used by the PartitionQueryRequest
-        # used to create the partition tokens and the ExecuteSqlRequests that use the
-        # partition tokens. Partition tokens become invalid when the session used to
-        # create them is deleted, is idle for too long, begins a new transaction, or
-        # becomes too old. When any of these happen, it is not possible to resume the
-        # query, and the whole operation must be restarted from the beginning.
-        # @param [String] session
-        #   Required. The session used to create the partitions.
-        # @param [Google::Apis::SpannerV1::PartitionQueryRequest] partition_query_request_object
+        # Updates an instance partition, and begins allocating or releasing resources as
+        # requested. The returned long-running operation can be used to track the
+        # progress of updating the instance partition. If the named instance partition
+        # does not exist, returns `NOT_FOUND`. Immediately upon completion of this
+        # request: * For resource types for which a decrease in the instance partition's
+        # allocation has been requested, billing is based on the newly-requested level.
+        # Until completion of the returned operation: * Cancelling the operation sets
+        # its metadata's cancel_time, and begins restoring resources to their pre-
+        # request values. The operation is guaranteed to succeed at undoing all resource
+        # changes, after which point it terminates with a `CANCELLED` status. * All
+        # other attempts to modify the instance partition are rejected. * Reading the
+        # instance partition via the API continues to give the pre-request resource
+        # levels. Upon completion of the returned operation: * Billing begins for all
+        # successfully-allocated resources (some types may have lower than the requested
+        # levels). * All newly-reserved resources are available for serving the instance
+        # partition's tables. * The instance partition's new resource levels are
+        # readable via the API. The returned long-running operation will have a name of
+        # the format `/operations/` and can be used to track the instance partition
+        # modification. The metadata field type is UpdateInstancePartitionMetadata. The
+        # response field type is InstancePartition, if successful. Authorization
+        # requires `spanner.instancePartitions.update` permission on the resource name.
+        # @param [String] name
+        #   Required. A unique identifier for the instance partition. Values are of the
+        #   form `projects//instances//instancePartitions/a-z*[a-z0-9]`. The final segment
+        #   of the name must be between 2 and 64 characters in length. An instance
+        #   partition's name cannot be changed after the instance partition is created.
+        # @param [Google::Apis::SpannerV1::UpdateInstancePartitionRequest] update_instance_partition_request_object
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2341,40 +3682,36 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::PartitionResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::PartitionResponse]
+        # @return [Google::Apis::SpannerV1::Operation]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def partition_session_query(session, partition_query_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:partitionQuery', options)
-          command.request_representation = Google::Apis::SpannerV1::PartitionQueryRequest::Representation
-          command.request_object = partition_query_request_object
-          command.response_representation = Google::Apis::SpannerV1::PartitionResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::PartitionResponse
-          command.params['session'] = session unless session.nil?
+        def patch_project_instance_instance_partition(name, update_instance_partition_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:patch, 'v1/{+name}', options)
+          command.request_representation = Google::Apis::SpannerV1::UpdateInstancePartitionRequest::Representation
+          command.request_object = update_instance_partition_request_object
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Creates a set of partition tokens that can be used to execute a read operation
-        # in parallel. Each of the returned partition tokens can be used by
-        # StreamingRead to specify a subset of the read result to read. The same session
-        # and read-only transaction must be used by the PartitionReadRequest used to
-        # create the partition tokens and the ReadRequests that use the partition tokens.
-        # There are no ordering guarantees on rows returned among the returned
-        # partition tokens, or even within each individual StreamingRead call issued
-        # with a partition_token. Partition tokens become invalid when the session used
-        # to create them is deleted, is idle for too long, begins a new transaction, or
-        # becomes too old. When any of these happen, it is not possible to resume the
-        # read, and the whole operation must be restarted from the beginning.
-        # @param [String] session
-        #   Required. The session used to create the partitions.
-        # @param [Google::Apis::SpannerV1::PartitionReadRequest] partition_read_request_object
+        # Starts asynchronous cancellation on a long-running operation. The server makes
+        # a best effort to cancel the operation, but success is not guaranteed. If the
+        # server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+        # 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`.
+        # @param [String] name
+        #   The name of the operation resource to be cancelled.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2384,37 +3721,30 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::PartitionResponse] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::PartitionResponse]
+        # @return [Google::Apis::SpannerV1::Empty]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def partition_session_read(session, partition_read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:partitionRead', options)
-          command.request_representation = Google::Apis::SpannerV1::PartitionReadRequest::Representation
-          command.request_object = partition_read_request_object
-          command.response_representation = Google::Apis::SpannerV1::PartitionResponse::Representation
-          command.response_class = Google::Apis::SpannerV1::PartitionResponse
-          command.params['session'] = session unless session.nil?
+        def cancel_project_instance_instance_partition_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:post, 'v1/{+name}:cancel', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Reads rows from the database using key lookups and scans, as a simple key/
-        # value style alternative to ExecuteSql. This method cannot be used to return a
-        # result set larger than 10 MiB; if the read matches more data than that, the
-        # read fails with a `FAILED_PRECONDITION` error. Reads inside read-write
-        # transactions might return `ABORTED`. If this occurs, the application should
-        # restart the transaction from the beginning. See Transaction for more details.
-        # Larger result sets can be yielded in streaming fashion by calling
-        # StreamingRead instead.
-        # @param [String] session
-        #   Required. The session in which the read should be performed.
-        # @param [Google::Apis::SpannerV1::ReadRequest] read_request_object
+        # Deletes a long-running operation. This method indicates that the client is no
+        # longer interested in the operation result. It does not cancel the operation.
+        # If the server doesn't support this method, it returns `google.rpc.Code.
+        # UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation resource to be deleted.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2424,34 +3754,28 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::ResultSet] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::ResultSet]
+        # @return [Google::Apis::SpannerV1::Empty]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def read_session(session, read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:read', options)
-          command.request_representation = Google::Apis::SpannerV1::ReadRequest::Representation
-          command.request_object = read_request_object
-          command.response_representation = Google::Apis::SpannerV1::ResultSet::Representation
-          command.response_class = Google::Apis::SpannerV1::ResultSet
-          command.params['session'] = session unless session.nil?
+        def delete_project_instance_instance_partition_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:delete, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
+          command.response_class = Google::Apis::SpannerV1::Empty
+          command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Rolls back a transaction, releasing any locks it holds. It is a good idea to
-        # call this for any transaction that includes one or more Read or ExecuteSql
-        # requests and ultimately decides not to commit. `Rollback` returns `OK` if it
-        # successfully aborts the transaction, the transaction was already aborted, or
-        # the transaction is not found. `Rollback` never returns `ABORTED`.
-        # @param [String] session
-        #   Required. The session in which the transaction to roll back is running.
-        # @param [Google::Apis::SpannerV1::RollbackRequest] rollback_request_object
+        # Gets the latest state of a long-running operation. Clients can use this method
+        # to poll the operation result at intervals as recommended by the API service.
+        # @param [String] name
+        #   The name of the operation resource.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2461,32 +3785,34 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::Empty] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::Operation] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::Empty]
+        # @return [Google::Apis::SpannerV1::Operation]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def rollback_session(session, rollback_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:rollback', options)
-          command.request_representation = Google::Apis::SpannerV1::RollbackRequest::Representation
-          command.request_object = rollback_request_object
-          command.response_representation = Google::Apis::SpannerV1::Empty::Representation
-          command.response_class = Google::Apis::SpannerV1::Empty
-          command.params['session'] = session unless session.nil?
+        def get_project_instance_instance_partition_operation(name, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::Operation::Representation
+          command.response_class = Google::Apis::SpannerV1::Operation
+          command.params['name'] = name unless name.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
         
-        # Like Read, except returns the result set as a stream. Unlike Read, there is no
-        # limit on the size of the returned result set. However, no individual row in
-        # the result set can exceed 100 MiB, and no column value can exceed 10 MiB.
-        # @param [String] session
-        #   Required. The session in which the read should be performed.
-        # @param [Google::Apis::SpannerV1::ReadRequest] read_request_object
+        # Lists operations that match the specified filter in the request. If the server
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
+        # @param [String] name
+        #   The name of the operation's parent resource.
+        # @param [String] filter
+        #   The standard list filter.
+        # @param [Fixnum] page_size
+        #   The standard list page size.
+        # @param [String] page_token
+        #   The standard list page token.
         # @param [String] fields
         #   Selector specifying which fields to include in a partial response.
         # @param [String] quota_user
@@ -2496,21 +3822,22 @@ module Google
         #   Request-specific options
         #
         # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::SpannerV1::PartialResultSet] parsed result object
+        # @yieldparam result [Google::Apis::SpannerV1::ListOperationsResponse] parsed result object
         # @yieldparam err [StandardError] error object if request failed
         #
-        # @return [Google::Apis::SpannerV1::PartialResultSet]
+        # @return [Google::Apis::SpannerV1::ListOperationsResponse]
         #
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
         # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
         # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def streaming_project_instance_database_session_read(session, read_request_object = nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:post, 'v1/{+session}:streamingRead', options)
-          command.request_representation = Google::Apis::SpannerV1::ReadRequest::Representation
-          command.request_object = read_request_object
-          command.response_representation = Google::Apis::SpannerV1::PartialResultSet::Representation
-          command.response_class = Google::Apis::SpannerV1::PartialResultSet
-          command.params['session'] = session unless session.nil?
+        def list_project_instance_instance_partition_operations(name, filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v1/{+name}', options)
+          command.response_representation = Google::Apis::SpannerV1::ListOperationsResponse::Representation
+          command.response_class = Google::Apis::SpannerV1::ListOperationsResponse
+          command.params['name'] = name unless name.nil?
+          command.query['filter'] = filter unless filter.nil?
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
           command.query['fields'] = fields unless fields.nil?
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
@@ -2522,8 +3849,8 @@ module Google
         # 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`.
+        # an operation with an Operation.error value with a google.rpc.Status.code of `1`
+        # , corresponding to `Code.CANCELLED`.
         # @param [String] name
         #   The name of the operation resource to be cancelled.
         # @param [String] fields
@@ -2618,13 +3945,7 @@ module Google
         end
         
         # Lists operations that match the specified filter in the request. If the server
-        # doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the `name`
-        # binding allows API services to override the binding to use different resource
-        # name schemes, such as `users/*/operations`. To override the binding, API
-        # services can add a binding such as `"/v1/`name=users/*`/operations"` to their
-        # service configuration. For backwards compatibility, the default name includes
-        # the operations collection id, however overriding users must ensure the name
-        # binding is the parent resource, without the operations collection id.
+        # doesn't support this method, it returns `UNIMPLEMENTED`.
         # @param [String] name
         #   The name of the operation's parent resource.
         # @param [String] filter