google-cloud-datastore 0.20.1 → 0.21.0

data/lib/google/cloud/datastore/key.rb

@@ -46,12 +46,13 @@ module Google
         # @return [String]
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new "my-todo-project",
-        #                       "/path/to/keyfile.json"
+        #   datastore = Google::Cloud::Datastore.new(
+        #     project: "my-todo-project",
+        #     keyfile: "/path/to/keyfile.json"
+        #   )
         #
-        #   datastore = gcloud.datastore
         #   task = datastore.find "Task", "sampleTask"
         #   task.key.project #=> "my-todo-project"
         #
@@ -65,12 +66,13 @@ module Google
         # @return [String, nil]
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new "my-todo-project",
-        #                       "/path/to/keyfile.json"
+        #   datastore = Google::Cloud::Datastore.new(
+        #     project: "my-todo-project",
+        #     keyfile: "/path/to/keyfile.json"
+        #   )
         #
-        #   datastore = gcloud.datastore
         #   task = datastore.find "Task", "sampleTask"
         #   task.key.namespace #=> "ns~todo-project"
         #
@@ -186,10 +188,9 @@ module Google
         # @return [Key, nil]
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new
-        #   datastore = gcloud.datastore
+        #   datastore = Google::Cloud::Datastore.new
         #
         #   task_list = datastore.find "TaskList", "default"
         #   query = datastore.query("Task").

data/lib/google/cloud/datastore/properties.rb

@@ -92,7 +92,7 @@ module Google
         # Ensures the key is the proper type,
         # otherwise a PropertyError is raised.
         def ensure_key_type key
-          return key.to_str if key.respond_to? :to_str
+          return key.to_s if key.respond_to? :to_s
           fail "Property key #{key} must be a String."
         end
 

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

@@ -13,46 +13,55 @@
 # limitations under the License.
 
 
+require "google/cloud/errors"
 require "google/cloud/datastore/credentials"
-require "google/datastore/v1/datastore_pb"
-require "google/cloud/core/grpc_backoff"
+require "google/cloud/datastore/version"
+require "google/cloud/datastore/v1"
+require "google/gax/errors"
 
 module Google
   module Cloud
     module Datastore
       ##
-      # @private Represents the gRPC Datastore service, including all the API
+      # @private Represents the GAX Datastore service, including all the API
       # methods.
       class Service
-        attr_accessor :project, :credentials, :host, :retries, :timeout
+        attr_accessor :project, :credentials, :host, :timeout, :client_config
 
         ##
         # Creates a new Service instance.
-        def initialize project, credentials, host: nil, retries: nil,
-                       timeout: nil
+        def initialize project, credentials, host: nil, timeout: nil,
+                       client_config: nil
           @project = project
           @credentials = credentials
-          @host = host || "datastore.googleapis.com"
-          @retries = retries
+          @host = host || V1::DatastoreApi::SERVICE_ADDRESS
           @timeout = timeout
+          @client_config = client_config || {}
         end
 
-        def creds
+        def channel
+          require "grpc"
+          GRPC::Core::Channel.new host, nil, chan_creds
+        end
+
+        def chan_creds
           return credentials if insecure?
+          require "grpc"
           GRPC::Core::ChannelCredentials.new.compose \
             GRPC::Core::CallCredentials.new credentials.client.updater_proc
         end
 
-        def datastore
-          return mocked_datastore if mocked_datastore
-          @datastore ||= begin
-            require "google/datastore/v1/datastore_services_pb"
-
-            Google::Datastore::V1::Datastore::Stub.new(
-              host, creds, timeout: timeout)
-          end
+        def service
+          return mocked_service if mocked_service
+          @service ||= V1::DatastoreApi.new(
+            service_path: host,
+            channel: channel,
+            timeout: timeout,
+            client_config: client_config,
+            app_name: "gcloud-ruby",
+            app_version: Google::Cloud::Datastore::VERSION)
         end
-        attr_accessor :mocked_datastore
+        attr_accessor :mocked_service
 
         def insecure?
           credentials == :this_channel_is_insecure
@@ -62,98 +71,72 @@ module Google
         # Allocate IDs for incomplete keys.
         # (This is useful for referencing an entity before it is inserted.)
         def allocate_ids *incomplete_keys
-          allocate_req = Google::Datastore::V1::AllocateIdsRequest.new(
-            project_id: project,
-            keys: incomplete_keys
-          )
-
-          execute { datastore.allocate_ids allocate_req }
+          execute do
+            service.allocate_ids project, incomplete_keys,
+                                 options: default_options
+          end
         end
 
         ##
         # Look up entities by keys.
         def lookup *keys, consistency: nil, transaction: nil
-          lookup_req = Google::Datastore::V1::LookupRequest.new(
-            project_id: project,
-            keys: keys
-          )
-          lookup_req.read_options = generate_read_options consistency,
-                                                          transaction
+          read_options = generate_read_options consistency, transaction
 
-          execute { datastore.lookup lookup_req }
+          execute do
+            service.lookup project, read_options, keys, options: default_options
+          end
         end
 
         # Query for entities.
         def run_query query, namespace = nil, consistency: nil, transaction: nil
-          run_req = Google::Datastore::V1::RunQueryRequest.new(
-            project_id: project)
-          if query.is_a? Google::Datastore::V1::Query
-            run_req["query"] = query
-          elsif query.is_a? Google::Datastore::V1::GqlQuery
-            run_req["gql_query"] = query
-          else
-            fail ArgumentError, "Unable to query with a #{query.class} object."
+          gql_query = nil
+          if query.is_a? Google::Datastore::V1::GqlQuery
+            gql_query = query
+            query = nil
           end
-          run_req.read_options = generate_read_options consistency, transaction
-
-          run_req.partition_id = Google::Datastore::V1::PartitionId.new(
+          read_options = generate_read_options consistency, transaction
+          partition_id = Google::Datastore::V1::PartitionId.new(
             namespace_id: namespace) if namespace
 
-          execute { datastore.run_query run_req }
+          execute do
+            service.run_query project,
+                              partition_id,
+                              read_options,
+                              query: query,
+                              gql_query: gql_query,
+                              options: default_options
+          end
         end
 
         ##
         # Begin a new transaction.
         def begin_transaction
-          tx_req = Google::Datastore::V1::BeginTransactionRequest.new(
-            project_id: project
-          )
-
-          execute { datastore.begin_transaction tx_req }
+          execute { service.begin_transaction project }
         end
 
         ##
         # Commit a transaction, optionally creating, deleting or modifying
         # some entities.
         def commit mutations, transaction: nil
-          commit_req = Google::Datastore::V1::CommitRequest.new(
-            project_id: project,
-            mode: :NON_TRANSACTIONAL,
-            mutations: mutations
-          )
-          if transaction
-            commit_req.mode = :TRANSACTIONAL
-            commit_req.transaction = transaction
+          mode =  transaction.nil? ? :NON_TRANSACTIONAL : :TRANSACTIONAL
+          execute do
+            service.commit project, mode, mutations, transaction: transaction,
+                                                     options: default_options
           end
-
-          execute { datastore.commit commit_req }
         end
 
         ##
         # Roll back a transaction.
         def rollback transaction
-          rb_req = Google::Datastore::V1::RollbackRequest.new(
-            project_id: project,
-            transaction: transaction
-          )
-
-          execute { datastore.rollback rb_req }
+          execute do
+            service.rollback project, transaction, options: default_options
+          end
         end
 
         def inspect
           "#{self.class}(#{@project})"
         end
 
-        ##
-        # Performs backoff and error handling
-        def execute
-          Google::Cloud::Core::GrpcBackoff.new(retries: retries).execute do
-            yield
-          end
-        rescue GRPC::BadStatus => e
-          raise Google::Cloud::Error.from_error(e)
-        end
-
         protected
 
         def generate_read_options consistency, transaction
@@ -169,6 +152,21 @@ module Google
           end
           nil
         end
+
+        def default_headers
+          { "google-cloud-resource-prefix" => "projects/#{@project}" }
+        end
+
+        def default_options
+          Google::Gax::CallOptions.new kwargs: default_headers
+        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)
+        end
       end
     end
   end

data/lib/google/cloud/datastore/transaction.rb

@@ -59,7 +59,7 @@ module Google
 
         ##
         # @private Creates a new Transaction instance.
-        # Takes a Connection and Service instead of project and Credentials.
+        # Takes a Service instead of project and Credentials.
         def initialize service
           @service = service
           reset!
@@ -191,8 +191,7 @@ module Google
         # @return [Google::Cloud::Datastore::Dataset::LookupResults]
         #
         # @example
-        #   gcloud = Google::Cloud.new
-        #   datastore = gcloud.datastore
+        #   datastore = Google::Cloud::Datastore.new
         #   task_key1 = datastore.key "Task", 123456
         #   task_key2 = datastore.key "Task", 987654
         #   tasks = datastore.find_all task_key1, task_key2
@@ -259,10 +258,9 @@ module Google
         # @yieldparam [Commit] commit The object that changes are made on
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new
-        #   datastore = gcloud.datastore
+        #   datastore = Google::Cloud::Datastore.new
         #
         #   task = datastore.entity "Task" do |t|
         #     t["type"] = "Personal"
@@ -282,10 +280,9 @@ module Google
         #   end
         #
         # @example Commit can be passed a block, same as {Dataset#commit}:
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new
-        #   datastore = gcloud.datastore
+        #   datastore = Google::Cloud::Datastore.new
         #
         #   tx = datastore.transaction
         #   begin
@@ -321,10 +318,9 @@ module Google
         # Rolls a transaction back.
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/datastore"
         #
-        #   gcloud = Google::Cloud.new
-        #   datastore = gcloud.datastore
+        #   datastore = Google::Cloud::Datastore.new
         #
         #   task = datastore.entity "Task" do |t|
         #     t["type"] = "Personal"

data/lib/google/cloud/datastore/v1.rb

@@ -0,0 +1,16 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/datastore/v1/datastore_api"

data/lib/google/cloud/datastore/v1/datastore_api.rb

@@ -0,0 +1,396 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# EDITING INSTRUCTIONS
+# This file was generated from the file
+# https://github.com/googleapis/googleapis/blob/master/google/datastore/v1/datastore.proto,
+# and updates to that file get reflected here through a refresh process.
+# For the short term, the refresh process will only be runnable by Google
+# engineers.
+#
+# The only allowed edits are to method and file documentation. A 3-way
+# merge preserves those additions if the generated source changes.
+
+require "json"
+require "pathname"
+
+require "google/gax"
+require "google/datastore/v1/datastore_pb"
+
+module Google
+  module Cloud
+    module Datastore
+      module V1
+        # Each RPC normalizes the partition IDs of the keys in its input entities,
+        # and always returns entities with keys with normalized partition IDs.
+        # This applies to all keys and entities, including those in values, except keys
+        # with both an empty path and an empty or unset partition ID. Normalization of
+        # input keys sets the project ID (if not already set) to the project ID from
+        # the request.
+        #
+        # @!attribute [r] datastore_stub
+        #   @return [Google::Datastore::V1::Datastore::Stub]
+        class DatastoreApi
+          attr_reader :datastore_stub
+
+          # The default address of the service.
+          SERVICE_ADDRESS = "datastore.googleapis.com".freeze
+
+          # The default port of the service.
+          DEFAULT_SERVICE_PORT = 443
+
+          CODE_GEN_NAME_VERSION = "gapic/0.1.0".freeze
+
+          DEFAULT_TIMEOUT = 30
+
+          # The scopes needed to make gRPC calls to all of the methods defined in
+          # this service.
+          ALL_SCOPES = [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/datastore"
+          ].freeze
+
+          # @param service_path [String]
+          #   The domain name of the API remote host.
+          # @param port [Integer]
+          #   The port on which to connect to the remote host.
+          # @param channel [Channel]
+          #   A Channel object through which to make calls.
+          # @param chan_creds [Grpc::ChannelCredentials]
+          #   A ChannelCredentials for the setting up the RPC client.
+          # @param client_config[Hash]
+          #   A Hash for call options for each method. See
+          #   Google::Gax#construct_settings for the structure of
+          #   this data. Falls back to the default config if not specified
+          #   or the specified config is missing data points.
+          # @param timeout [Numeric]
+          #   The default timeout, in seconds, for calls made through this client.
+          # @param app_name [String]
+          #   The codename of the calling service.
+          # @param app_version [String]
+          #   The version of the calling service.
+          def initialize \
+              service_path: SERVICE_ADDRESS,
+              port: DEFAULT_SERVICE_PORT,
+              channel: nil,
+              chan_creds: nil,
+              scopes: ALL_SCOPES,
+              client_config: {},
+              timeout: DEFAULT_TIMEOUT,
+              app_name: "gax",
+              app_version: Google::Gax::VERSION
+            # These require statements are intentionally placed here to initialize
+            # the gRPC module only when it's required.
+            # See https://github.com/googleapis/toolkit/issues/446
+            require "google/gax/grpc"
+            require "google/datastore/v1/datastore_services_pb"
+
+            google_api_client = "#{app_name}/#{app_version} " \
+              "#{CODE_GEN_NAME_VERSION} gax/#{Google::Gax::VERSION} " \
+              "ruby/#{RUBY_VERSION}".freeze
+            headers = { :"x-goog-api-client" => google_api_client }
+            client_config_file = Pathname.new(__dir__).join(
+              "datastore_client_config.json"
+            )
+            defaults = client_config_file.open do |f|
+              Google::Gax.construct_settings(
+                "google.datastore.v1.Datastore",
+                JSON.parse(f.read),
+                client_config,
+                Google::Gax::Grpc::STATUS_CODE_NAMES,
+                timeout,
+                errors: Google::Gax::Grpc::API_ERRORS,
+                kwargs: headers
+              )
+            end
+            @datastore_stub = Google::Gax::Grpc.create_stub(
+              service_path,
+              port,
+              chan_creds: chan_creds,
+              channel: channel,
+              scopes: scopes,
+              &Google::Datastore::V1::Datastore::Stub.method(:new)
+            )
+
+            @lookup = Google::Gax.create_api_call(
+              @datastore_stub.method(:lookup),
+              defaults["lookup"]
+            )
+            @run_query = Google::Gax.create_api_call(
+              @datastore_stub.method(:run_query),
+              defaults["run_query"]
+            )
+            @begin_transaction = Google::Gax.create_api_call(
+              @datastore_stub.method(:begin_transaction),
+              defaults["begin_transaction"]
+            )
+            @commit = Google::Gax.create_api_call(
+              @datastore_stub.method(:commit),
+              defaults["commit"]
+            )
+            @rollback = Google::Gax.create_api_call(
+              @datastore_stub.method(:rollback),
+              defaults["rollback"]
+            )
+            @allocate_ids = Google::Gax.create_api_call(
+              @datastore_stub.method(:allocate_ids),
+              defaults["allocate_ids"]
+            )
+          end
+
+          # Service calls
+
+          # Looks up entities by key.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param read_options [Google::Datastore::V1::ReadOptions]
+          #   The options for this lookup request.
+          # @param keys [Array<Google::Datastore::V1::Key>]
+          #   Keys of entities to look up.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::LookupResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #   ReadOptions = Google::Datastore::V1::ReadOptions
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   read_options = ReadOptions.new
+          #   keys = []
+          #   response = datastore_api.lookup(project_id, read_options, keys)
+
+          def lookup \
+              project_id,
+              read_options,
+              keys,
+              options: nil
+            req = Google::Datastore::V1::LookupRequest.new(
+              project_id: project_id,
+              read_options: read_options,
+              keys: keys
+            )
+            @lookup.call(req, options)
+          end
+
+          # Queries for entities.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param partition_id [Google::Datastore::V1::PartitionId]
+          #   Entities are partitioned into subsets, identified by a partition ID.
+          #   Queries are scoped to a single partition.
+          #   This partition ID is normalized with the standard default context
+          #   partition ID.
+          # @param read_options [Google::Datastore::V1::ReadOptions]
+          #   The options for this query.
+          # @param query [Google::Datastore::V1::Query]
+          #   The query to run.
+          # @param gql_query [Google::Datastore::V1::GqlQuery]
+          #   The GQL query to run.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::RunQueryResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #   PartitionId = Google::Datastore::V1::PartitionId
+          #   ReadOptions = Google::Datastore::V1::ReadOptions
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   partition_id = PartitionId.new
+          #   read_options = ReadOptions.new
+          #   response = datastore_api.run_query(project_id, partition_id, read_options)
+
+          def run_query \
+              project_id,
+              partition_id,
+              read_options,
+              query: nil,
+              gql_query: nil,
+              options: nil
+            req = Google::Datastore::V1::RunQueryRequest.new(
+              project_id: project_id,
+              partition_id: partition_id,
+              read_options: read_options
+            )
+            req.query = query unless query.nil?
+            req.gql_query = gql_query unless gql_query.nil?
+            @run_query.call(req, options)
+          end
+
+          # Begins a new transaction.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::BeginTransactionResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   response = datastore_api.begin_transaction(project_id)
+
+          def begin_transaction \
+              project_id,
+              options: nil
+            req = Google::Datastore::V1::BeginTransactionRequest.new(
+              project_id: project_id
+            )
+            @begin_transaction.call(req, options)
+          end
+
+          # Commits a transaction, optionally creating, deleting or modifying some
+          # entities.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param mode [Google::Datastore::V1::CommitRequest::Mode]
+          #   The type of commit to perform. Defaults to +TRANSACTIONAL+.
+          # @param transaction [String]
+          #   The identifier of the transaction associated with the commit. A
+          #   transaction identifier is returned by a call to
+          #   Datastore::BeginTransaction.
+          # @param mutations [Array<Google::Datastore::V1::Mutation>]
+          #   The mutations to perform.
+          #
+          #   When mode is +TRANSACTIONAL+, mutations affecting a single entity are
+          #   applied in order. The following sequences of mutations affecting a single
+          #   entity are not permitted in a single +Commit+ request:
+          #
+          #   - +insert+ followed by +insert+
+          #   - +update+ followed by +insert+
+          #   - +upsert+ followed by +insert+
+          #   - +delete+ followed by +update+
+          #
+          #   When mode is +NON_TRANSACTIONAL+, no two mutations may affect a single
+          #   entity.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::CommitResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #   Mode = Google::Datastore::V1::CommitRequest::Mode
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   mode = Mode::MODE_UNSPECIFIED
+          #   mutations = []
+          #   response = datastore_api.commit(project_id, mode, mutations)
+
+          def commit \
+              project_id,
+              mode,
+              mutations,
+              transaction: nil,
+              options: nil
+            req = Google::Datastore::V1::CommitRequest.new(
+              project_id: project_id,
+              mode: mode,
+              mutations: mutations
+            )
+            req.transaction = transaction unless transaction.nil?
+            @commit.call(req, options)
+          end
+
+          # Rolls back a transaction.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param transaction [String]
+          #   The transaction identifier, returned by a call to
+          #   Datastore::BeginTransaction.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::RollbackResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   transaction = ''
+          #   response = datastore_api.rollback(project_id, transaction)
+
+          def rollback \
+              project_id,
+              transaction,
+              options: nil
+            req = Google::Datastore::V1::RollbackRequest.new(
+              project_id: project_id,
+              transaction: transaction
+            )
+            @rollback.call(req, options)
+          end
+
+          # Allocates IDs for the given keys, which is useful for referencing an entity
+          # before it is inserted.
+          #
+          # @param project_id [String]
+          #   The ID of the project against which to make the request.
+          # @param keys [Array<Google::Datastore::V1::Key>]
+          #   A list of keys with incomplete key paths for which to allocate IDs.
+          #   No key may be reserved/read-only.
+          # @param options [Google::Gax::CallOptions]
+          #   Overrides the default settings for this call, e.g, timeout,
+          #   retries, etc.
+          # @return [Google::Datastore::V1::AllocateIdsResponse]
+          # @raise [Google::Gax::GaxError] if the RPC is aborted.
+          # @example
+          #   require "google/cloud/datastore/v1/datastore_api"
+          #
+          #   DatastoreApi = Google::Cloud::Datastore::V1::DatastoreApi
+          #
+          #   datastore_api = DatastoreApi.new
+          #   project_id = ''
+          #   keys = []
+          #   response = datastore_api.allocate_ids(project_id, keys)
+
+          def allocate_ids \
+              project_id,
+              keys,
+              options: nil
+            req = Google::Datastore::V1::AllocateIdsRequest.new(
+              project_id: project_id,
+              keys: keys
+            )
+            @allocate_ids.call(req, options)
+          end
+        end
+      end
+    end
+  end
+end