google-cloud-spanner 1.2.0 → 1.3.1

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

@@ -101,6 +101,11 @@ module Google
           end
 
           fields = @metadata.row_type.fields
+          if fields.count.zero?
+            @closed = true
+            return []
+          end
+
           values = []
           buffered_responses = []
           buffer_upper_bound = 10
@@ -204,9 +209,9 @@ module Google
 
         # @private
         def self.execute service, session_path, sql, params: nil, types: nil,
-                         transaction: nil
+                         transaction: nil, partition_token: nil
           execute_options = { transaction: transaction, params: params,
-                              types: types }
+                              types: types, partition_token: partition_token }
           enum = service.streaming_execute_sql session_path, sql,
                                                execute_options
           from_enum(enum, service).tap do |results|
@@ -218,9 +223,11 @@ module Google
 
         # @private
         def self.read service, session_path, table, columns, keys: nil,
-                      index: nil, limit: nil, transaction: nil
+                      index: nil, limit: nil, transaction: nil,
+                      partition_token: nil
           read_options = { keys: keys, index: index, limit: limit,
-                           transaction: transaction }
+                           transaction: transaction,
+                           partition_token: partition_token }
           enum = service.streaming_read_table \
             session_path, table, columns, read_options
           from_enum(enum, service).tap do |results|
@@ -267,7 +274,7 @@ module Google
             return left
           elsif left.kind == :struct_value
             # Don't worry about this yet since Spanner isn't return STRUCT
-            fail "STRUCT not implemented yet"
+            raise "STRUCT not implemented yet"
           else
             raise "Can't merge #{left.kind} values"
           end

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

@@ -47,7 +47,8 @@ module Google
               timeout: timeout,
               client_config: client_config,
               lib_name: "gccl",
-              lib_version: Google::Cloud::Spanner::VERSION)
+              lib_version: Google::Cloud::Spanner::VERSION
+            )
         end
         attr_accessor :mocked_service
 
@@ -59,7 +60,8 @@ module Google
               timeout: timeout,
               client_config: client_config,
               lib_name: "gccl",
-              lib_version: Google::Cloud::Spanner::VERSION)
+              lib_version: Google::Cloud::Spanner::VERSION
+            )
         end
         attr_accessor :mocked_instances
 
@@ -71,7 +73,8 @@ module Google
               timeout: timeout,
               client_config: client_config,
               lib_name: "gccl",
-              lib_version: Google::Cloud::Spanner::VERSION)
+              lib_version: Google::Cloud::Spanner::VERSION
+            )
         end
         attr_accessor :mocked_databases
 
@@ -110,7 +113,8 @@ module Google
 
         def update_instance instance_obj
           mask = Google::Protobuf::FieldMask.new(
-            paths: %w(display_name node_count labels))
+            paths: %w[display_name node_count labels]
+          )
 
           execute do
             instances.update_instance instance_obj, mask
@@ -252,43 +256,70 @@ module Google
         end
 
         def streaming_execute_sql session_name, sql, transaction: nil,
-                                  params: nil, types: nil, resume_token: nil
-          input_params = nil
-          input_param_types = nil
-          unless params.nil?
-            input_param_pairs = Convert.to_query_params params, types
-            input_params = Google::Protobuf::Struct.new(
-              fields: Hash[input_param_pairs.map { |k, v| [k, v.first] }])
-            input_param_types = Hash[
-              input_param_pairs.map { |k, v| [k, v.last] }]
-          end
+                                  params: nil, types: nil, resume_token: nil,
+                                  partition_token: nil
           opts = default_options_from_session session_name
           execute do
             service.execute_streaming_sql \
-              session_name, sql, transaction: transaction, params: input_params,
-                                 param_types: input_param_types,
-                                 resume_token: resume_token, options: opts
+              session_name, sql, transaction: transaction, params: params,
+                                 param_types: types,
+                                 resume_token: resume_token,
+                                 partition_token: partition_token, options: opts
           end
         end
 
         def streaming_read_table session_name, table_name, columns, keys: nil,
                                  index: nil, transaction: nil, limit: nil,
-                                 resume_token: nil
-          columns.map!(&:to_s)
+                                 resume_token: nil, partition_token: nil
           opts = default_options_from_session session_name
           execute do
             service.streaming_read \
-              session_name, table_name, columns, key_set(keys),
+              session_name, table_name, columns, keys,
               transaction: transaction, index: index, limit: limit,
-              resume_token: resume_token, options: opts
+              resume_token: resume_token, partition_token: partition_token,
+              options: opts
+          end
+        end
+
+        def partition_read session_name, table_name, columns, transaction,
+                           keys: nil, index: nil, partition_size_bytes: nil,
+                           max_partitions: 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
+        end
+
+        def partition_query session_name, sql, transaction, params: nil,
+                            types: nil, partition_size_bytes: nil,
+                            max_partitions: 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
         end
 
         def commit session_name, mutations = [], transaction_id: 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 = Google::Spanner::V1::TransactionOptions.new(
+              read_write: Google::Spanner::V1::TransactionOptions::ReadWrite.new
+            )
           end
           opts = default_options_from_session session_name
           execute do
@@ -307,8 +338,9 @@ module Google
         end
 
         def begin_transaction session_name
-          tx_opts = Google::Spanner::V1::TransactionOptions.new(read_write:
-            Google::Spanner::V1::TransactionOptions::ReadWrite.new)
+          tx_opts = Google::Spanner::V1::TransactionOptions.new(
+            read_write: Google::Spanner::V1::TransactionOptions::ReadWrite.new
+          )
           opts = default_options_from_session session_name
           execute do
             service.begin_transaction session_name, tx_opts, options: opts
@@ -317,13 +349,16 @@ module Google
 
         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({
-              strong: strong,
-              read_timestamp: Convert.time_to_timestamp(timestamp),
-              exact_staleness: Convert.number_to_duration(staleness),
-              return_read_timestamp: true
-            }.delete_if { |_, v| v.nil? }))
+          tx_opts = Google::Spanner::V1::TransactionOptions.new(
+            read_only: Google::Spanner::V1::TransactionOptions::ReadOnly.new(
+              {
+                strong: strong,
+                read_timestamp: Convert.time_to_timestamp(timestamp),
+                exact_staleness: Convert.number_to_duration(staleness),
+                return_read_timestamp: true
+              }.delete_if { |_, v| v.nil? }
+            )
+          )
           opts = default_options_from_session session_name
           execute do
             service.begin_transaction session_name, tx_opts, options: opts
@@ -336,37 +371,22 @@ module Google
 
         protected
 
-        def key_set keys
-          return Google::Spanner::V1::KeySet.new(all: true) if keys.nil?
-          keys = [keys] unless keys.is_a? Array
-          return Google::Spanner::V1::KeySet.new(all: true) if keys.empty?
-          if keys_are_ranges? keys
-            keys = [keys] unless keys.is_a? Array
-            key_ranges = keys.map do |r|
-              Convert.to_key_range(r)
-            end
-            return Google::Spanner::V1::KeySet.new(ranges: key_ranges)
-          end
-          key_list = Array(keys).map do |i|
-            Convert.raw_to_value(Array(i)).list_value
-          end
-          Google::Spanner::V1::KeySet.new keys: key_list
-        end
-
-        def keys_are_ranges? keys
-          keys.each do |key|
-            return true if key.is_a? ::Range
-            return true if key.is_a? Google::Cloud::Spanner::Range
-          end
-          false
-        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 }
         end
 
+        def partition_options partition_size_bytes, max_partitions
+          return nil unless partition_size_bytes || max_partitions
+          partition_opts = Google::Spanner::V1::PartitionOptions.new
+          if partition_size_bytes
+            partition_opts.partition_size_bytes = partition_size_bytes
+          end
+          partition_opts.max_partitions = max_partitions if max_partitions
+          partition_opts
+        end
+
         def project_path
           Admin::Instance::V1::InstanceAdminClient.project_path project
         end
@@ -374,23 +394,27 @@ module Google
         def instance_path name
           return name if name.to_s.include? "/"
           Admin::Instance::V1::InstanceAdminClient.instance_path(
-            project, name)
+            project, 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)
+            project, name.to_s
+          )
         end
 
         def database_path instance_id, database_id
           Admin::Database::V1::DatabaseAdminClient.database_path(
-            project, instance_id, database_id)
+            project, instance_id, database_id
+          )
         end
 
         def session_path instance_id, database_id, session_id
           V1::SpannerClient.session_path(
-            project, instance_id, database_id, session_id)
+            project, instance_id, database_id, session_id
+          )
         end
 
         def execute

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

@@ -180,15 +180,17 @@ module Google
         #     puts "User #{row[:id]} is #{row[:name]}"
         #   end
         #
-        def execute sql, params: nil, types: nil, transaction: nil
+        def execute sql, params: nil, types: nil, transaction: nil,
+                    partition_token: nil
           ensure_service!
+
           results = Results.execute service, path, sql,
                                     params: params, types: types,
-                                    transaction: transaction
+                                    transaction: transaction,
+                                    partition_token: partition_token
           @last_updated_at = Time.now
           results
         end
-        alias_method :query, :execute
 
         ##
         # Read rows from a database table, as a simple alternative to
@@ -227,12 +229,44 @@ module Google
         #   end
         #
         def read table, columns, keys: nil, index: nil, limit: nil,
-                 transaction: nil
+                 transaction: nil, partition_token: nil
           ensure_service!
+
           results = Results.read service, path, table, columns,
                                  keys: keys, index: index, limit: limit,
-                                 transaction: transaction
+                                 transaction: transaction,
+                                 partition_token: partition_token
+          @last_updated_at = Time.now
+          results
+        end
+
+        def partition_query sql, transaction, params: nil, types: nil,
+                            partition_size_bytes: nil, max_partitions: nil
+          ensure_service!
+
+          results = service.partition_query \
+            path, sql, transaction, params: params, types: types,
+                                    partition_size_bytes: partition_size_bytes,
+                                    max_partitions: max_partitions
+
           @last_updated_at = Time.now
+
+          results
+        end
+
+        def partition_read table, columns, transaction, keys: nil,
+                           index: nil, partition_size_bytes: nil,
+                           max_partitions: nil
+          ensure_service!
+
+          results = service.partition_read \
+            path, table, columns, transaction,
+            keys: keys, index: index,
+            partition_size_bytes: partition_size_bytes,
+            max_partitions: max_partitions
+
+          @last_updated_at = Time.now
+
           results
         end
 
@@ -313,7 +347,7 @@ module Google
             c.upsert table, rows
           end
         end
-        alias_method :save, :upsert
+        alias save upsert
 
         ##
         # Inserts new rows in a table. If any of the rows already exist, the
@@ -503,7 +537,8 @@ module Google
         rescue Google::Cloud::NotFoundError
           @grpc = service.create_session \
             Admin::Database::V1::DatabaseAdminClient.database_path(
-              project_id, instance_id, database_id)
+              project_id, instance_id, database_id
+            )
           @last_updated_at = Time.now
           return self
         end
@@ -518,7 +553,8 @@ module Google
         rescue Google::Cloud::NotFoundError
           @grpc = service.create_session \
             Admin::Database::V1::DatabaseAdminClient.database_path(
-              project_id, instance_id, database_id)
+              project_id, instance_id, database_id
+            )
           return false
         end
 
@@ -557,7 +593,7 @@ module Google
         # @private Raise an error unless an active connection to the service is
         # available.
         def ensure_service!
-          fail "Must have active connection to service" unless service
+          raise "Must have active connection to service" unless service
         end
       end
     end

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

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 
+require "google/cloud/spanner/convert"
 require "google/cloud/spanner/results"
 
 module Google
@@ -150,10 +151,13 @@ module Google
         #
         def execute sql, params: nil, types: nil
           ensure_session!
+
+          params, types = Convert.to_input_params_and_types params, types
+
           session.execute sql, params: params, types: types,
                                transaction: tx_selector
         end
-        alias_method :query, :execute
+        alias query execute
 
         ##
         # Read rows from a database table, as a simple alternative to
@@ -191,6 +195,10 @@ module Google
         #
         def read table, columns, keys: nil, index: nil, limit: nil
           ensure_session!
+
+          columns = Array(columns).map(&:to_s)
+          keys = Convert.to_key_set keys
+
           session.read table, columns, keys: keys, index: index, limit: limit,
                                        transaction: tx_selector
         end
@@ -252,7 +260,7 @@ module Google
         # @private Raise an error unless an active connection to the service is
         # available.
         def ensure_session!
-          fail "Must have active connection to service" unless session
+          raise "Must have active connection to service" unless session
         end
       end
     end

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

@@ -42,10 +42,11 @@ module Google
       #
       #   job = spanner.create_database "my-instance",
       #                                 "my-new-database"
+      #   job.wait_until_done!
       #
-      #   job.error? # true
-      #
-      #   status = job.error
+      #   if job.error?
+      #     status = job.error
+      #   end
       #
       class Status
         attr_reader :code, :description, :message, :details
@@ -67,12 +68,12 @@ module Google
 
         # @private Get a descriptive symbol for a google.rpc.Code integer
         def self.description_for code
-          descriptions = %w(
+          descriptions = %w[
             OK CANCELLED UNKNOWN INVALID_ARGUMENT DEADLINE_EXCEEDED NOT_FOUND
             ALREADY_EXISTS PERMISSION_DENIED RESOURCE_EXHAUSTED
             FAILED_PRECONDITION ABORTED OUT_OF_RANGE UNIMPLEMENTED INTERNAL
             UNAVAILABLE DATA_LOSS UNAUTHENTICATED
-          )
+          ]
           descriptions[code]
         end
       end