google-cloud-spanner 1.15.0 → 2.1.0

data/lib/google/cloud/spanner/instance/config.rb

@@ -77,7 +77,7 @@ module Google
 
           ##
           # @private Creates a new Instance::Config instance from a
-          # Google::Spanner::Admin::Instance::V1::InstanceConfig.
+          # `Google::Cloud::Spanner::Admin::Instance::V1::InstanceConfig`.
           def self.from_grpc grpc
             new grpc
           end

data/lib/google/cloud/spanner/instance/config/list.rb

@@ -142,7 +142,7 @@ module Google
 
             ##
             # @private New Instance::Config::List from a
-            # Google::Spanner::Admin::Instance::V1::ListInstanceConfigsResponse
+            # `Google::Cloud::Spanner::Admin::Instance::V1::ListInstanceConfigsResponse`
             # object.
             def self.from_grpc grpc, service, max = nil
               configs = List.new(Array(grpc.instance_configs).map do |config|

data/lib/google/cloud/spanner/instance/job.rb

@@ -54,7 +54,7 @@ module Google
         #
         class Job
           ##
-          # @private The Google::Gax::Operation gRPC object.
+          # @private The `Gapic::Operation` gRPC object.
           attr_accessor :grpc
 
           ##
@@ -219,7 +219,7 @@ module Google
           end
 
           ##
-          # @private New Instance::Job from a Google::Gax::Operation object.
+          # @private New Instance::Job from a `Gapic::Operation` object.
           def self.from_grpc grpc, service
             new.tap do |job|
               job.instance_variable_set :@grpc, grpc

data/lib/google/cloud/spanner/instance/list.rb

@@ -139,7 +139,7 @@ module Google
 
           ##
           # @private New Instance::List from a
-          # Google::Spanner::Admin::Instance::V1::ListInstancesResponse
+          # `Google::Cloud::Spanner::Admin::Instance::V1::ListInstancesResponse`
           # object.
           def self.from_grpc grpc, service, max = nil
             instances = List.new(Array(grpc.instances).map do |instance|

data/lib/google/cloud/spanner/partition.rb

@@ -172,13 +172,13 @@ module Google
           new.tap do |p|
             if data[:execute]
               execute_sql_grpc = \
-                Google::Spanner::V1::ExecuteSqlRequest.decode(
+                V1::ExecuteSqlRequest.decode(
                   Base64.decode64(data[:execute])
                 )
               p.instance_variable_set :@execute, execute_sql_grpc
             end
             if data[:read]
-              read_grpc = Google::Spanner::V1::ReadRequest.decode \
+              read_grpc = V1::ReadRequest.decode \
                 Base64.decode64(data[:read])
               p.instance_variable_set :@read, read_grpc
             end
@@ -194,7 +194,7 @@ module Google
         end
 
         ##
-        # @private New Partition from a Google::Spanner::V1::ExecuteSqlRequest
+        # @private New Partition from a `Google::Cloud::Spanner::V1::ExecuteSqlRequest`
         # object.
         def self.from_execute_sql_grpc grpc
           new.tap do |p|
@@ -203,7 +203,7 @@ module Google
         end
 
         ##
-        # @private New Partition from a Google::Spanner::V1::ReadRequest object.
+        # @private New Partition from a `Google::Cloud::Spanner::V1::ReadRequest` object.
         def self.from_read_grpc grpc
           new.tap do |p|
             p.instance_variable_set :@read, grpc

data/lib/google/cloud/spanner/policy.rb

@@ -159,7 +159,7 @@ module Google
         end
 
         ##
-        # @private Convert the Policy to a Google::Iam::V1::Policy object.
+        # @private Convert the Policy to a `Google::Iam::V1::Policy` object.
         def to_grpc
           Google::Iam::V1::Policy.new(
             etag: etag,
@@ -174,7 +174,7 @@ module Google
         end
 
         ##
-        # @private New Policy from a Google::Iam::V1::Policy object.
+        # @private New Policy from a `Google::Iam::V1::Policy` object.
         def self.from_grpc grpc
           roles = grpc.bindings.each_with_object({}) do |binding, memo|
             memo[binding.role] = binding.members.to_a

data/lib/google/cloud/spanner/results.rb

@@ -243,11 +243,11 @@ module Google
         def self.execute_query service, session_path, sql, params: nil,
                                types: nil, transaction: nil,
                                partition_token: nil, seqno: nil,
-                               query_options: nil
+                               query_options: nil, call_options: nil
           execute_query_options = {
             transaction: transaction, params: params, types: types,
             partition_token: partition_token, seqno: seqno,
-            query_options: query_options
+            query_options: query_options, call_options: call_options
           }
           enum = service.execute_streaming_sql session_path, sql,
                                                execute_query_options
@@ -262,10 +262,13 @@ module Google
         # @private
         def self.read service, session_path, table, columns, keys: nil,
                       index: nil, limit: nil, transaction: nil,
-                      partition_token: nil
-          read_options = { keys: keys, index: index, limit: limit,
-                           transaction: transaction,
-                           partition_token: partition_token }
+                      partition_token: nil, call_options: nil
+          read_options = {
+            keys: keys, index: index, limit: limit,
+            transaction: transaction,
+            partition_token: partition_token,
+            call_options: call_options
+          }
           enum = service.streaming_read_table \
             session_path, table, columns, read_options
           from_enum(enum, service).tap do |results|

data/lib/google/cloud/spanner/service.rb

@@ -20,7 +20,6 @@ require "google/cloud/spanner/v1"
 require "google/cloud/spanner/admin/instance/v1"
 require "google/cloud/spanner/admin/database/v1"
 require "google/cloud/spanner/convert"
-require "uri"
 
 module Google
   module Cloud
@@ -29,18 +28,17 @@ module Google
       # @private Represents the gRPC Spanner service, including all the API
       # methods.
       class Service
-        attr_accessor :project, :credentials, :timeout, :client_config, :host,
-                      :lib_name, :lib_version
+        attr_accessor :project, :credentials, :timeout, :host, :lib_name,
+                      :lib_version
 
         ##
         # Creates a new Service instance.
-        def initialize project, credentials, host: nil, timeout: nil,
-                       client_config: nil, lib_name: nil, lib_version: nil
+        def initialize project, credentials,
+                       host: nil, timeout: nil, lib_name: nil, lib_version: nil
           @project = project
           @credentials = credentials
-          @host = host || V1::SpannerClient::SERVICE_ADDRESS
+          @host = host
           @timeout = timeout
-          @client_config = client_config || {}
           @lib_name = lib_name
           @lib_version = lib_version
         end
@@ -64,45 +62,42 @@ module Google
         def service
           return mocked_service if mocked_service
           @service ||= \
-            V1::SpannerClient.new(
-              credentials: channel,
-              timeout: timeout,
-              client_config: client_config,
-              service_address: service_address,
-              service_port: service_port,
-              lib_name: lib_name_with_prefix,
-              lib_version: Google::Cloud::Spanner::VERSION
-            )
+            V1::Spanner::Client.new do |config|
+              config.credentials = channel
+              config.timeout = timeout if timeout
+              config.endpoint = host if host
+              config.lib_name = lib_name_with_prefix
+              config.lib_version = Google::Cloud::Spanner::VERSION
+              config.metadata = { "google-cloud-resource-prefix" => "projects/#{@project}" }
+            end
         end
         attr_accessor :mocked_service
 
         def instances
           return mocked_instances if mocked_instances
           @instances ||= \
-            Admin::Instance::V1::InstanceAdminClient.new(
-              credentials: channel,
-              timeout: timeout,
-              client_config: client_config,
-              service_address: service_address,
-              service_port: service_port,
-              lib_name: lib_name_with_prefix,
-              lib_version: Google::Cloud::Spanner::VERSION
-            )
+            Admin::Instance::V1::InstanceAdmin::Client.new do |config|
+              config.credentials = channel
+              config.timeout = timeout if timeout
+              config.endpoint = host if host
+              config.lib_name = lib_name_with_prefix
+              config.lib_version = Google::Cloud::Spanner::VERSION
+              config.metadata = { "google-cloud-resource-prefix" => "projects/#{@project}" }
+            end
         end
         attr_accessor :mocked_instances
 
         def databases
           return mocked_databases if mocked_databases
           @databases ||= \
-            Admin::Database::V1::DatabaseAdminClient.new(
-              credentials: channel,
-              timeout: timeout,
-              client_config: client_config,
-              service_address: service_address,
-              service_port: service_port,
-              lib_name: lib_name_with_prefix,
-              lib_version: Google::Cloud::Spanner::VERSION
-            )
+            Admin::Database::V1::DatabaseAdmin::Client.new do |config|
+              config.credentials = channel
+              config.timeout = timeout if timeout
+              config.endpoint = host if host
+              config.lib_name = lib_name_with_prefix
+              config.lib_version = Google::Cloud::Spanner::VERSION
+              config.metadata = { "google-cloud-resource-prefix" => "projects/#{@project}" }
+            end
         end
         attr_accessor :mocked_databases
 
@@ -110,225 +105,239 @@ module Google
           credentials == :this_channel_is_insecure
         end
 
-        def list_instances token: nil, max: nil
-          call_options = nil
-          call_options = Google::Gax::CallOptions.new page_token: token if token
-
-          execute do
-            paged_enum = instances.list_instances project_path,
-                                                  page_size: max,
-                                                  options: call_options
-
-            paged_enum.page.response
-          end
+        def list_instances token: nil, max: nil, call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:     project_path,
+            page_size:  max,
+            page_token: token
+          }
+          paged_enum = instances.list_instances request, opts
+          paged_enum.response
         end
 
-        def get_instance name
-          execute do
-            instances.get_instance instance_path(name)
-          end
+        def get_instance name, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: instance_path(name) }
+          instances.get_instance request, opts
         end
 
         def create_instance instance_id, name: nil, config: nil, nodes: nil,
-                            labels: nil
+                            labels: nil, call_options: nil
+          opts = default_options call_options: call_options
           labels = Hash[labels.map { |k, v| [String(k), String(v)] }] if labels
 
-          create_obj = Google::Spanner::Admin::Instance::V1::Instance.new({
+          create_obj = Admin::Instance::V1::Instance.new({
             display_name: name, config: instance_config_path(config),
             node_count: nodes, labels: labels
           }.delete_if { |_, v| v.nil? })
 
-          execute do
-            instances.create_instance project_path, instance_id, create_obj
-          end
+          request = {
+            parent:      project_path,
+            instance_id: instance_id,
+            instance:    create_obj
+          }
+          instances.create_instance request, opts
         end
 
-        def update_instance instance_obj
+        def update_instance instance, call_options: nil
+          opts = default_options call_options: call_options
           mask = Google::Protobuf::FieldMask.new(
             paths: %w[display_name node_count labels]
           )
-
-          execute do
-            instances.update_instance instance_obj, mask
-          end
+          request = { instance: instance, field_mask: mask }
+          instances.update_instance request, opts
         end
 
-        def delete_instance name
-          execute do
-            instances.delete_instance instance_path(name)
-          end
+        def delete_instance name, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: instance_path(name) }
+          instances.delete_instance request, opts
         end
 
-        def get_instance_policy name
-          execute do
-            instances.get_iam_policy instance_path(name)
-          end
+        def get_instance_policy name, call_options: nil
+          opts = default_options call_options: call_options
+          request = { resource: instance_path(name) }
+          instances.get_iam_policy request, opts
         end
 
-        def set_instance_policy name, new_policy
-          execute do
-            instances.set_iam_policy instance_path(name), new_policy
-          end
+        def set_instance_policy name, new_policy, call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            resource: instance_path(name),
+            policy:  new_policy
+          }
+          instances.set_iam_policy request, opts
         end
 
-        def test_instance_permissions name, permissions
-          execute do
-            instances.test_iam_permissions instance_path(name), permissions
-          end
+        def test_instance_permissions name, permissions, call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            resource:    instance_path(name),
+            permissions: permissions
+          }
+          instances.test_iam_permissions request, opts
         end
 
-        def list_instance_configs token: nil, max: nil
-          call_options = nil
-          call_options = Google::Gax::CallOptions.new page_token: token if token
-
-          execute do
-            paged_enum = instances.list_instance_configs project_path,
-                                                         page_size: max,
-                                                         options: call_options
-
-            paged_enum.page.response
-          end
+        def list_instance_configs token: nil, max: nil, call_options: nil
+          opts = default_options call_options: call_options
+          request = { parent: project_path, page_size: max, page_token: token }
+          paged_enum = instances.list_instance_configs request, opts
+          paged_enum.response
         end
 
-        def get_instance_config name
-          execute do
-            instances.get_instance_config instance_config_path(name)
-          end
+        def get_instance_config name, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: instance_config_path(name) }
+          instances.get_instance_config request, opts
         end
 
-        def list_databases instance_id, token: nil, max: nil
-          call_options = nil
-          call_options = Google::Gax::CallOptions.new page_token: token if token
-
-          execute do
-            paged_enum = databases.list_databases instance_path(instance_id),
-                                                  page_size: max,
-                                                  options: call_options
-
-            paged_enum.page.response
-          end
+        def list_databases instance_id, token: nil, max: nil, call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:     instance_path(instance_id),
+            page_size:  max,
+            page_token: token
+          }
+          paged_enum = databases.list_databases request, opts
+          paged_enum.response
         end
 
-        def get_database instance_id, database_id
-          execute do
-            databases.get_database database_path(instance_id, database_id)
-          end
+        def get_database instance_id, database_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: database_path(instance_id, database_id) }
+          databases.get_database request, opts
         end
 
-        def create_database instance_id, database_id, statements: []
-          execute do
-            databases.create_database \
-              instance_path(instance_id),
-              "CREATE DATABASE `#{database_id}`",
-              extra_statements: Array(statements)
-          end
+        def create_database instance_id, database_id, statements: [],
+                            call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent: instance_path(instance_id),
+            create_statement: "CREATE DATABASE `#{database_id}`",
+            extra_statements: Array(statements)
+          }
+          databases.create_database request, opts
         end
 
-        def drop_database instance_id, database_id
-          execute do
-            databases.drop_database database_path(instance_id, database_id)
-          end
+        def drop_database instance_id, database_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { database: database_path(instance_id, database_id) }
+          databases.drop_database request, opts
         end
 
-        def get_database_ddl instance_id, database_id
-          execute do
-            databases.get_database_ddl database_path(instance_id, database_id)
-          end
+        def get_database_ddl instance_id, database_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { database: database_path(instance_id, database_id) }
+          databases.get_database_ddl request, opts
         end
 
         def update_database_ddl instance_id, database_id, statements: [],
-                                operation_id: nil
-          execute do
-            databases.update_database_ddl \
-              database_path(instance_id, database_id),
-              Array(statements),
-              operation_id: operation_id
-          end
-        end
-
-        def get_database_policy instance_id, database_id
-          execute do
-            databases.get_iam_policy database_path(instance_id, database_id)
-          end
-        end
-
-        def set_database_policy instance_id, database_id, new_policy
-          execute do
-            databases.set_iam_policy \
-              database_path(instance_id, database_id), new_policy
-          end
-        end
-
-        def test_database_permissions instance_id, database_id, permissions
-          execute do
-            databases.test_iam_permissions \
-              database_path(instance_id, database_id), permissions
-          end
-        end
-
-        def get_session session_name
-          opts = default_options_from_session session_name
-          execute do
-            service.get_session session_name, options: opts
-          end
-        end
-
-        def create_session database_name, labels: nil
-          opts = default_options_from_session database_name
-          session = Google::Spanner::V1::Session.new labels: labels if labels
-          execute do
-            service.create_session database_name, session: session,
-                                                  options: opts
-          end
+                                operation_id: nil, call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            database: database_path(instance_id, database_id),
+            statements: Array(statements),
+            operation_id: operation_id
+          }
+          databases.update_database_ddl request, opts
+        end
+
+        def get_database_policy instance_id, database_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { resource: database_path(instance_id, database_id) }
+          databases.get_iam_policy request, opts
+        end
+
+        def set_database_policy instance_id, database_id, new_policy,
+                                call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            resource: database_path(instance_id, database_id),
+            policy:   new_policy
+          }
+          databases.set_iam_policy request, opts
+        end
+
+        def test_database_permissions instance_id, database_id, permissions,
+                                      call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            resource:    database_path(instance_id, database_id),
+            permissions: permissions
+          }
+          databases.test_iam_permissions request, opts
+        end
+
+        def get_session session_name, call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          service.get_session({ name: session_name }, opts)
+        end
+
+        def create_session database_name, labels: nil,
+                           call_options: nil
+          opts = default_options session_name: database_name,
+                                 call_options: call_options
+          session = V1::Session.new labels: labels if labels
+          service.create_session(
+            { database: database_name, session: session }, opts
+          )
         end
 
-        def batch_create_sessions database_name, session_count, labels: nil
-          opts = default_options_from_session database_name
-          session = Google::Spanner::V1::Session.new labels: labels if labels
-          execute do
-            # The response may have fewer sessions than requested in the RPC.
-            service.batch_create_sessions database_name,
-                                          session_count,
-                                          session_template: session,
-                                          options: opts
-          end
+        def batch_create_sessions database_name, session_count, labels: nil,
+                                  call_options: nil
+          opts = default_options session_name: database_name,
+                                 call_options: call_options
+          session = V1::Session.new labels: labels if labels
+          # The response may have fewer sessions than requested in the RPC.
+          request = {
+            database: database_name,
+            session_count: session_count,
+            session_template: session
+          }
+          service.batch_create_sessions request, opts
         end
 
-        def delete_session session_name
-          opts = default_options_from_session session_name
-          execute do
-            service.delete_session session_name, options: opts
-          end
+        def delete_session session_name, call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          service.delete_session({ name: session_name }, opts)
         end
 
         def execute_streaming_sql session_name, sql, transaction: nil,
                                   params: nil, types: nil, resume_token: nil,
                                   partition_token: nil, seqno: nil,
-                                  query_options: nil
-          opts = default_options_from_session session_name
-          execute do
-            service.execute_streaming_sql \
-              session_name, sql, transaction: transaction,
-                                 params: params,
-                                 param_types: types,
-                                 resume_token: resume_token,
-                                 partition_token: partition_token,
-                                 seqno: seqno,
-                                 query_options: query_options,
-                                 options: opts
-          end
-        end
-
-        def execute_batch_dml session_name, transaction, statements, seqno
-          opts = default_options_from_session session_name
+                                  query_options: nil, call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request =  {
+            session: session_name,
+            sql: sql,
+            transaction: transaction,
+            params: params,
+            param_types: types,
+            resume_token: resume_token,
+            partition_token: partition_token,
+            seqno: seqno,
+            query_options: query_options
+          }
+          service.execute_streaming_sql request, opts
+        end
+
+        def execute_batch_dml session_name, transaction, statements, seqno,
+                              call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
           statements = statements.map(&:to_grpc)
-          results = execute do
-            service.execute_batch_dml session_name,
-                                      transaction,
-                                      statements,
-                                      seqno,
-                                      options: opts
-          end
+          request = {
+            session: session_name,
+            transaction: transaction,
+            statements: statements,
+            seqno: seqno
+          }
+          results = service.execute_batch_dml request, opts
+
           if results.status.code.zero?
             results.result_sets.map { |rs| rs.stats.row_count_exact }
           else
@@ -342,87 +351,89 @@ module Google
 
         def streaming_read_table session_name, table_name, columns, keys: nil,
                                  index: nil, transaction: nil, limit: nil,
-                                 resume_token: nil, partition_token: nil
-          opts = default_options_from_session session_name
-          execute do
-            service.streaming_read \
-              session_name, table_name, columns, keys,
-              transaction: transaction, index: index, limit: limit,
-              resume_token: resume_token, partition_token: partition_token,
-              options: opts
-          end
+                                 resume_token: nil, partition_token: nil,
+                                 call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = {
+            session: session_name, table: table_name, columns: columns,
+            key_set: keys, transaction: transaction, index: index,
+            limit: limit, resume_token: resume_token,
+            partition_token: partition_token
+          }
+          service.streaming_read request, opts
         end
 
         def partition_read session_name, table_name, columns, transaction,
                            keys: nil, index: nil, partition_size_bytes: nil,
-                           max_partitions: nil
+                           max_partitions: nil, call_options: nil
           partition_opts = partition_options partition_size_bytes,
                                              max_partitions
 
-          opts = default_options_from_session session_name
-
-          execute do
-            service.partition_read \
-              session_name, table_name, keys,
-              transaction: transaction, index: index, columns: columns,
-              partition_options: partition_opts, options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = {
+            session: session_name, table: table_name, key_set: keys,
+            transaction: transaction, index: index, columns: columns,
+            partition_options: partition_opts
+          }
+          service.partition_read request, opts
         end
 
         def partition_query session_name, sql, transaction, params: nil,
                             types: nil, partition_size_bytes: nil,
-                            max_partitions: nil
+                            max_partitions: nil, call_options: nil
           partition_opts = partition_options partition_size_bytes,
                                              max_partitions
 
-          opts = default_options_from_session session_name
-
-          execute do
-            service.partition_query \
-              session_name, sql,
-              transaction: transaction,
-              params: params, param_types: types,
-              partition_options: partition_opts, options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = {
+            session: session_name, sql: sql, transaction: transaction,
+            params: params, param_types: types,
+            partition_options: partition_opts
+          }
+          service.partition_query request, opts
         end
 
-        def commit session_name, mutations = [], transaction_id: nil
+        def commit session_name, mutations = [], transaction_id: nil,
+                   call_options: nil
           tx_opts = nil
           if transaction_id.nil?
-            tx_opts = Google::Spanner::V1::TransactionOptions.new(
-              read_write: Google::Spanner::V1::TransactionOptions::ReadWrite.new
+            tx_opts = V1::TransactionOptions.new(
+              read_write: V1::TransactionOptions::ReadWrite.new
             )
           end
-          opts = default_options_from_session session_name
-          execute do
-            service.commit \
-              session_name, mutations,
-              transaction_id: transaction_id, single_use_transaction: tx_opts,
-              options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = {
+            session: session_name, transaction_id: transaction_id,
+            single_use_transaction: tx_opts, mutations: mutations
+          }
+          service.commit request, opts
         end
 
-        def rollback session_name, transaction_id
-          opts = default_options_from_session session_name
-          execute do
-            service.rollback session_name, transaction_id, options: opts
-          end
+        def rollback session_name, transaction_id, call_options: nil
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = { session: session_name, transaction_id: transaction_id }
+          service.rollback request, opts
         end
 
-        def begin_transaction session_name
-          tx_opts = Google::Spanner::V1::TransactionOptions.new(
-            read_write: Google::Spanner::V1::TransactionOptions::ReadWrite.new
+        def begin_transaction session_name, call_options: nil
+          tx_opts = V1::TransactionOptions.new(
+            read_write: V1::TransactionOptions::ReadWrite.new
           )
-          opts = default_options_from_session session_name
-          execute do
-            service.begin_transaction session_name, tx_opts, options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = { session: session_name, options: tx_opts }
+          service.begin_transaction request, opts
         end
 
         def create_snapshot session_name, strong: nil, timestamp: nil,
-                            staleness: nil
-          tx_opts = Google::Spanner::V1::TransactionOptions.new(
-            read_only: Google::Spanner::V1::TransactionOptions::ReadOnly.new(
+                            staleness: nil, call_options: nil
+          tx_opts = V1::TransactionOptions.new(
+            read_only: V1::TransactionOptions::ReadOnly.new(
               {
                 strong: strong,
                 read_timestamp: Convert.time_to_timestamp(timestamp),
@@ -431,21 +442,107 @@ module Google
               }.delete_if { |_, v| v.nil? }
             )
           )
-          opts = default_options_from_session session_name
-          execute do
-            service.begin_transaction session_name, tx_opts, options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = { session: session_name, options: tx_opts }
+          service.begin_transaction request, opts
         end
 
-        def create_pdml session_name
-          tx_opts = Google::Spanner::V1::TransactionOptions.new(
-            partitioned_dml: \
-              Google::Spanner::V1::TransactionOptions::PartitionedDml.new
+        def create_pdml session_name, call_options: nil
+          tx_opts = V1::TransactionOptions.new(
+            partitioned_dml: V1::TransactionOptions::PartitionedDml.new
           )
-          opts = default_options_from_session session_name
-          execute do
-            service.begin_transaction session_name, tx_opts, options: opts
-          end
+          opts = default_options session_name: session_name,
+                                 call_options: call_options
+          request = { session: session_name, options: tx_opts }
+          service.begin_transaction request, opts
+        end
+
+        def create_backup instance_id, database_id, backup_id, expire_time,
+                          call_options: nil
+          opts = default_options call_options: call_options
+          backup = {
+            database: database_path(instance_id, database_id),
+            expire_time: expire_time
+          }
+          request = {
+            parent:    instance_path(instance_id),
+            backup_id: backup_id,
+            backup:    backup
+          }
+          databases.create_backup request, opts
+        end
+
+        def get_backup instance_id, backup_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: backup_path(instance_id, backup_id) }
+          databases.get_backup request, opts
+        end
+
+        def update_backup backup, update_mask, call_options: nil
+          opts = default_options call_options: call_options
+          request = { backup: backup, update_mask: update_mask }
+          databases.update_backup request, opts
+        end
+
+        def delete_backup instance_id, backup_id, call_options: nil
+          opts = default_options call_options: call_options
+          request = { name: backup_path(instance_id, backup_id) }
+          databases.delete_backup request, opts
+        end
+
+        def list_backups instance_id,
+                         filter: nil, page_size: nil, page_token: nil,
+                         call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:    instance_path(instance_id),
+            filter:    filter,
+            page_size: page_size,
+            page_token: page_token
+          }
+          databases.list_backups request, opts
+        end
+
+        def list_database_operations instance_id,
+                                     filter: nil,
+                                     page_size: nil,
+                                     page_token: nil,
+                                     call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:     instance_path(instance_id),
+            filter:     filter,
+            page_size:  page_size,
+            page_token: page_token
+          }
+          databases.list_database_operations request, opts
+        end
+
+        def list_backup_operations instance_id,
+                                   filter: nil, page_size: nil,
+                                   page_token: nil,
+                                   call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:     instance_path(instance_id),
+            filter:     filter,
+            page_size:  page_size,
+            page_token: page_token
+          }
+          databases.list_backup_operations request, opts
+        end
+
+        def restore_database backup_instance_id, backup_id,
+                             database_instance_id, database_id,
+                             call_options: nil
+          opts = default_options call_options: call_options
+          request = {
+            parent:      instance_path(database_instance_id),
+            database_id: database_id,
+            backup:      backup_path(backup_instance_id, backup_id)
+          }
+          databases.restore_database request, opts
         end
 
         def inspect
@@ -454,16 +551,6 @@ module Google
 
         protected
 
-        def service_address
-          return nil if host.nil?
-          URI.parse("//#{host}").host
-        end
-
-        def service_port
-          return nil if host.nil?
-          URI.parse("//#{host}").port
-        end
-
         def lib_name_with_prefix
           return "gccl" if [nil, "gccl"].include? lib_name
 
@@ -472,15 +559,22 @@ module Google
           value << " gccl"
         end
 
-        def default_options_from_session session_name
-          default_prefix = session_name.split("/sessions/").first
-          Google::Gax::CallOptions.new kwargs: \
-            { "google-cloud-resource-prefix" => default_prefix }
+        def default_options session_name: nil, call_options: nil
+          opts = {}
+          if session_name
+            default_prefix = session_name.split("/sessions/").first
+            opts[:metadata] = { "google-cloud-resource-prefix" => default_prefix }
+          end
+          if call_options
+            opts[:timeout] = call_options[:timeout] if call_options[:timeout]
+            opts[:retry_policy] = call_options[:retry_policy] if call_options[:retry_policy]
+          end
+          return opts unless opts.empty?
         end
 
         def partition_options partition_size_bytes, max_partitions
           return nil unless partition_size_bytes || max_partitions
-          partition_opts = Google::Spanner::V1::PartitionOptions.new
+          partition_opts = V1::PartitionOptions.new
           if partition_size_bytes
             partition_opts.partition_size_bytes = partition_size_bytes
           end
@@ -489,42 +583,38 @@ module Google
         end
 
         def project_path
-          Admin::Instance::V1::InstanceAdminClient.project_path project
+          Admin::Instance::V1::InstanceAdmin::Paths.project_path \
+            project: project
         end
 
         def instance_path name
           return name if name.to_s.include? "/"
-          Admin::Instance::V1::InstanceAdminClient.instance_path(
-            project, name
-          )
+
+          Admin::Instance::V1::InstanceAdmin::Paths.instance_path \
+            project: project, instance: name
         end
 
         def instance_config_path name
           return name if name.to_s.include? "/"
-          Admin::Instance::V1::InstanceAdminClient.instance_config_path(
-            project, name.to_s
-          )
+
+          Admin::Instance::V1::InstanceAdmin::Paths.instance_config_path \
+            project: project, instance_config: name
         end
 
         def database_path instance_id, database_id
-          Admin::Database::V1::DatabaseAdminClient.database_path(
-            project, instance_id, database_id
-          )
+          Admin::Database::V1::DatabaseAdmin::Paths.database_path \
+            project: project, instance: instance_id, database: database_id
         end
 
         def session_path instance_id, database_id, session_id
-          V1::SpannerClient.session_path(
-            project, instance_id, database_id, session_id
-          )
+          V1::Spanner::Paths.session_path \
+            project: project, instance: instance_id, database: database_id,
+            session: session_id
         end
 
-        def execute
-          yield
-        rescue Google::Gax::GaxError => e
-          # GaxError wraps BadStatus, but exposes it as #cause
-          raise Google::Cloud::Error.from_error(e.cause)
-        rescue GRPC::BadStatus => e
-          raise Google::Cloud::Error.from_error(e)
+        def backup_path instance_id, backup_id
+          Admin::Database::V1::DatabaseAdmin::Paths.backup_path \
+            project: project, instance: instance_id, backup: backup_id
         end
       end
     end