gcloud 0.12.2 → 0.20.0

data/lib/gcloud/bigquery.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 Google Inc. All rights reserved.
+# 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.
@@ -14,384 +14,4 @@
 
 
 require "gcloud"
-require "gcloud/bigquery/project"
-
-module Gcloud
-  ##
-  # Creates a new `Project` instance connected to the BigQuery service.
-  # Each call creates a new connection.
-  #
-  # For more information on connecting to Google Cloud see the [Authentication
-  # Guide](https://googlecloudplatform.github.io/gcloud-ruby/#/docs/guides/authentication).
-  #
-  # @param [String] project Identifier for a BigQuery project. If not present,
-  #   the default project for the credentials is used.
-  # @param [String, Hash] keyfile Keyfile downloaded from Google Cloud. If file
-  #   path the file must be readable.
-  # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
-  #   set of resources and operations that the connection can access. See [Using
-  #   OAuth 2.0 to Access Google
-  #   APIs](https://developers.google.com/identity/protocols/OAuth2).
-  #
-  #   The default scope is:
-  #
-  #   * `https://www.googleapis.com/auth/bigquery`
-  # @param [Integer] retries Number of times to retry requests on server error.
-  #   The default value is `3`. Optional.
-  # @param [Integer] timeout Default timeout to use in requests. Optional.
-  #
-  # @return [Gcloud::Bigquery::Project]
-  #
-  # @example
-  #   require "gcloud/bigquery"
-  #
-  #   bigquery = Gcloud.bigquery
-  #   dataset = bigquery.dataset "my_dataset"
-  #   table = dataset.table "my_table"
-  #
-  def self.bigquery project = nil, keyfile = nil, scope: nil, retries: nil,
-                    timeout: nil
-    project ||= Gcloud::Bigquery::Project.default_project
-    project = project.to_s # Always cast to a string
-    fail ArgumentError, "project is missing" if project.empty?
-
-    if keyfile.nil?
-      credentials = Gcloud::Bigquery::Credentials.default scope: scope
-    else
-      credentials = Gcloud::Bigquery::Credentials.new keyfile, scope: scope
-    end
-
-    Gcloud::Bigquery::Project.new(
-      Gcloud::Bigquery::Service.new(
-        project, credentials, retries: retries, timeout: timeout))
-  end
-
-  ##
-  # # Google Cloud BigQuery
-  #
-  # Google Cloud BigQuery enables super-fast, SQL-like queries against massive
-  # datasets, using the processing power of Google's infrastructure. To learn
-  # more, read [What is
-  # BigQuery?](https://cloud.google.com/bigquery/what-is-bigquery).
-  #
-  # The goal of gcloud-ruby is to provide an API that is comfortable
-  # to Rubyists. Authentication is handled by {Gcloud#bigquery}. You can provide
-  # the project and credential information to connect to the BigQuery service,
-  # or if you are running on Google Compute Engine this configuration is taken
-  # care of for you. You can read more about the options for connecting in the
-  # [Authentication
-  # Guide](https://googlecloudplatform.github.io/gcloud-ruby/#/docs/guides/authentication).
-  #
-  # To help you get started quickly, the first few examples below use a public
-  # dataset provided by Google. As soon as you have [signed
-  # up](https://cloud.google.com/bigquery/sign-up) to use BigQuery, and provided
-  # that you stay in the free tier for queries, you should be able to run these
-  # first examples without the need to set up billing or to load data (although
-  # we'll show you how to do that too.)
-  #
-  # ## Listing Datasets and Tables
-  #
-  # A BigQuery project holds datasets, which in turn hold tables. Assuming that
-  # you have not yet created datasets or tables in your own project, let's
-  # connect to Google's `publicdata` project, and see what you find.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new "publicdata"
-  # bigquery = gcloud.bigquery
-  #
-  # bigquery.datasets.count #=> 1
-  # bigquery.datasets.first.dataset_id #=> "samples"
-  #
-  # dataset = bigquery.datasets.first
-  # tables = dataset.tables
-  #
-  # tables.count #=> 7
-  # tables.map &:table_id #=> [..., "shakespeare", "trigrams", "wikipedia"]
-  # ```
-  #
-  # In addition listing all datasets and tables in the project, you can also
-  # retrieve individual datasets and tables by ID. Let's look at the structure
-  # of the `shakespeare` table, which contains an entry for every word in every
-  # play written by Shakespeare.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new "publicdata"
-  # bigquery = gcloud.bigquery
-  #
-  # dataset = bigquery.dataset "samples"
-  # table = dataset.table "shakespeare"
-  #
-  # table.headers #=> ["word", "word_count", "corpus", "corpus_date"]
-  # table.rows_count #=> 164656
-  # ```
-  #
-  # Now that you know the column names for the Shakespeare table, you can write
-  # and run a query.
-  #
-  # ## Running queries
-  #
-  # BigQuery offers both synchronous and asynchronous methods, as explained in
-  # [Querying Data](https://cloud.google.com/bigquery/querying-data).
-  #
-  # ### Synchronous queries
-  #
-  # Let's start with the simpler synchronous approach. Notice that this time you
-  # are connecting using your own default project. This is necessary for running
-  # a query, since queries need to be able to create tables to hold results.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  #
-  # sql = "SELECT TOP(word, 50) as word, COUNT(*) as count " +
-  #       "FROM publicdata:samples.shakespeare"
-  # data = bigquery.query sql
-  #
-  # data.count #=> 50
-  # data.next? #=> false
-  # data.first #=> {"word"=>"you", "count"=>42}
-  # ```
-  #
-  # The `TOP` function shown above is just one of a variety of functions
-  # offered by BigQuery. See the [Query
-  # Reference](https://cloud.google.com/bigquery/query-reference) for a full
-  # listing.
-  #
-  # ### Asynchronous queries
-  #
-  # Because you probably should not block for most BigQuery operations,
-  # including querying as well as importing, exporting, and copying data, the
-  # BigQuery API enables you to manage longer-running jobs. In the asynchronous
-  # approach to running a query, an instance of {Gcloud::Bigquery::QueryJob} is
-  # returned, rather than an instance of {Gcloud::Bigquery::QueryData}.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  #
-  # sql = "SELECT TOP(word, 50) as word, COUNT(*) as count " +
-  #       "FROM publicdata:samples.shakespeare"
-  # job = bigquery.query_job sql
-  #
-  # job.wait_until_done!
-  # if !job.failed?
-  #   job.query_results.each do |row|
-  #     puts row["word"]
-  #   end
-  # end
-  # ```
-  #
-  # Once you have determined that the job is done and has not failed, you can
-  # obtain an instance of {Gcloud::Bigquery::QueryData} by calling
-  # {Gcloud::Bigquery::QueryJob#query_results}. The query results for both of
-  # the above examples are stored in temporary tables with a lifetime of about
-  # 24 hours. See the final example below for a demonstration of how to store
-  # query results in a permanent table.
-  #
-  # ## Creating Datasets and Tables
-  #
-  # The first thing you need to do in a new BigQuery project is to create a
-  # {Gcloud::Bigquery::Dataset}. Datasets hold tables and control access to
-  # them.
-  #
-  # ```ruby
-  # require "gcloud/bigquery"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  # dataset = bigquery.create_dataset "my_dataset"
-  # ```
-  #
-  # Now that you have a dataset, you can use it to create a table. Every table
-  # is defined by a schema that may contain nested and repeated fields. The
-  # example below shows a schema with a repeated record field named
-  # `cities_lived`. (For more information about nested and repeated fields, see
-  # [Preparing Data for
-  # BigQuery](https://cloud.google.com/bigquery/preparing-data-for-bigquery).)
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  # dataset = bigquery.dataset "my_dataset"
-  #
-  # table = dataset.create_table "people" do |schema|
-  #   schema.string "first_name", mode: :required
-  #   schema.record "cities_lived", mode: :repeated do |nested_schema|
-  #     nested_schema.string "place", mode: :required
-  #     nested_schema.integer "number_of_years", mode: :required
-  #   end
-  # end
-  # ```
-  #
-  # Because of the repeated field in this schema, we cannot use the CSV format
-  # to load data into the table.
-  #
-  # ## Loading records
-  #
-  # In addition to CSV, data can be imported from files that are formatted as
-  # [Newline-delimited JSON](http://jsonlines.org/) or
-  # [Avro](http://avro.apache.org/), or from a Google Cloud Datastore backup. It
-  # can also be "streamed" into BigQuery.
-  #
-  # To follow along with these examples, you will need to set up billing on the
-  # [Google Developers Console](https://console.developers.google.com).
-  #
-  # ### Streaming records
-  #
-  # For situations in which you want new data to be available for querying as
-  # soon as possible, inserting individual records directly from your Ruby
-  # application is a great approach.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  # dataset = bigquery.dataset "my_dataset"
-  # table = dataset.table "people"
-  #
-  # rows = [
-  #     {
-  #         "first_name" => "Anna",
-  #         "cities_lived" => [
-  #             {
-  #                 "place" => "Stockholm",
-  #                 "number_of_years" => 2
-  #             }
-  #         ]
-  #     },
-  #     {
-  #         "first_name" => "Bob",
-  #         "cities_lived" => [
-  #             {
-  #                 "place" => "Seattle",
-  #                 "number_of_years" => 5
-  #             },
-  #             {
-  #                 "place" => "Austin",
-  #                 "number_of_years" => 6
-  #             }
-  #         ]
-  #     }
-  # ]
-  # table.insert rows
-  # ```
-  #
-  # There are some trade-offs involved with streaming, so be sure to read the
-  # discussion of data consistency in [Streaming Data Into
-  # BigQuery](https://cloud.google.com/bigquery/streaming-data-into-bigquery).
-  #
-  # ### Uploading a file
-  #
-  # To follow along with this example, please download the
-  # [names.zip](http://www.ssa.gov/OACT/babynames/names.zip) archive from the
-  # U.S. Social Security Administration. Inside the archive you will find over
-  # 100 files containing baby name records since the year 1880. A PDF file also
-  # contained in the archive specifies the schema used below.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  # dataset = bigquery.dataset "my_dataset"
-  # table = dataset.create_table "baby_names" do |schema|
-  #   schema.string "name", mode: :required
-  #   schema.string "sex", mode: :required
-  #   schema.integer "number", mode: :required
-  # end
-  #
-  # file = File.open "names/yob2014.txt"
-  # load_job = table.load file, format: "csv"
-  # ```
-  #
-  # Because the names data, although formatted as CSV, is distributed in files
-  # with a `.txt` extension, this example explicitly passes the `format` option
-  # in order to demonstrate how to handle such situations. Because CSV is the
-  # default format for load operations, the option is not actually necessary.
-  # For JSON saved with a `.txt` extension, however, it would be.
-  #
-  # ## Exporting query results to Google Cloud Storage
-  #
-  # The example below shows how to pass the `table` option with a query in order
-  # to store results in a permanent table. It also shows how to export the
-  # result data to a Google Cloud Storage file. In order to follow along, you
-  # will need to enable the Google Cloud Storage API in addition to setting up
-  # billing.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery
-  # dataset = bigquery.dataset "my_dataset"
-  # source_table = dataset.table "baby_names"
-  # result_table = dataset.create_table "baby_names_results"
-  #
-  # sql = "SELECT name, number as count " +
-  #       "FROM baby_names " +
-  #       "WHERE name CONTAINS 'Sam' " +
-  #       "ORDER BY count DESC"
-  # query_job = dataset.query_job sql, table: result_table
-  #
-  # query_job.wait_until_done!
-  #
-  # if !query_job.failed?
-  #
-  #   storage = gcloud.storage
-  #   bucket_id = "bigquery-exports-#{SecureRandom.uuid}"
-  #   bucket = storage.create_bucket bucket_id
-  #   extract_url = "gs://#{bucket.id}/baby-names-sam.csv"
-  #
-  #   extract_job = result_table.extract extract_url
-  #
-  #   extract_job.wait_until_done!
-  #
-  #   # Download to local filesystem
-  #   bucket.files.first.download "baby-names-sam.csv"
-  #
-  # end
-  # ```
-  #
-  # If a table you wish to export contains a large amount of data, you can pass
-  # a wildcard URI to export to multiple files (for sharding), or an array of
-  # URIs (for partitioning), or both. See [Exporting Data From
-  # BigQuery](https://cloud.google.com/bigquery/exporting-data-from-bigquery)
-  # for details.
-  #
-  # ## Configuring retries and timeout
-  #
-  # You can configure how many times API requests may be automatically retried.
-  # When an API request fails, the response will be inspected to see if the
-  # request meets criteria indicating that it may succeed on retry, such as
-  # `500` and `503` status codes or a specific internal error code such as
-  # `rateLimitExceeded`. If it meets the criteria, the request will be retried
-  # after a delay. If another error occurs, the delay will be increased before a
-  # subsequent attempt, until the `retries` limit is reached.
-  #
-  # You can also set the request `timeout` value in seconds.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # bigquery = gcloud.bigquery retries: 10, timeout: 120
-  # ```
-  #
-  # See the [BigQuery error
-  # table](https://cloud.google.com/bigquery/troubleshooting-errors#errortable)
-  # for a list of error conditions.
-  #
-  module Bigquery
-  end
-end
+require "google/cloud/bigquery"

data/lib/gcloud/datastore.rb

@@ -1,4 +1,4 @@
-# Copyright 2014 Google Inc. All rights reserved.
+# 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.
@@ -14,578 +14,4 @@
 
 
 require "gcloud"
-require "gcloud/datastore/errors"
-require "gcloud/datastore/dataset"
-require "gcloud/datastore/transaction"
-require "gcloud/datastore/credentials"
-
-module Gcloud
-  ##
-  # Creates a new object for connecting to the Datastore service.
-  # Each call creates a new connection.
-  #
-  # For more information on connecting to Google Cloud see the [Authentication
-  # Guide](https://googlecloudplatform.github.io/gcloud-ruby/#/docs/guides/authentication).
-  #
-  # @param [String] project Dataset identifier for the Datastore you are
-  #   connecting to.
-  # @param [String, Hash] keyfile Keyfile downloaded from Google Cloud. If file
-  #   path the file must be readable.
-  # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
-  #   set of resources and operations that the connection can access. See [Using
-  #   OAuth 2.0 to Access Google
-  #   APIs](https://developers.google.com/identity/protocols/OAuth2).
-  #
-  #   The default scope is:
-  #
-  #   * `https://www.googleapis.com/auth/datastore`
-  # @param [Integer] retries Number of times to retry requests on server error.
-  #   The default value is `3`. Optional.
-  # @param [Integer] timeout Default timeout to use in requests. Optional.
-  #
-  # @return [Gcloud::Datastore::Dataset]
-  #
-  # @example
-  #   require "gcloud/datastore"
-  #
-  #   datastore = Gcloud.datastore "my-todo-project",
-  #                              "/path/to/keyfile.json"
-  #
-  #   task = datastore.entity "Task", "sampleTask" do |t|
-  #     t["type"] = "Personal"
-  #     t["done"] = false
-  #     t["priority"] = 4
-  #     t["description"] = "Learn Cloud Datastore"
-  #   end
-  #
-  #   datastore.save task
-  #
-  def self.datastore project = nil, keyfile = nil, scope: nil, retries: nil,
-                     timeout: nil
-    project ||= Gcloud::Datastore::Dataset.default_project
-    project = project.to_s # Always cast to a string
-    fail ArgumentError, "project is missing" if project.empty?
-
-    if ENV["DATASTORE_EMULATOR_HOST"]
-      return Gcloud::Datastore::Dataset.new(
-        Gcloud::Datastore::Service.new(
-          project, :this_channel_is_insecure,
-          host: ENV["DATASTORE_EMULATOR_HOST"], retries: retries))
-    end
-
-    if keyfile.nil?
-      credentials = Gcloud::Datastore::Credentials.default scope: scope
-    else
-      credentials = Gcloud::Datastore::Credentials.new keyfile, scope: scope
-    end
-
-    Gcloud::Datastore::Dataset.new(
-      Gcloud::Datastore::Service.new(
-        project, credentials, retries: retries, timeout: timeout))
-  end
-
-  ##
-  # # Google Cloud Datastore
-  #
-  # Google Cloud Datastore is a fully managed, schemaless database for storing
-  # non-relational data. You should feel at home if you are familiar with
-  # relational databases, but there are some key differences to be aware of to
-  # make the most of using Datastore.
-  #
-  # The goal of gcloud-ruby is to provide a API that is comfortable to
-  # Rubyists. Authentication is handled by {Gcloud#datastore}. You can provide
-  # the project and credential information to connect to the Datastore service,
-  # or if you are running on Google Compute Engine this configuration is taken
-  # care of for you.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new "my-todo-project",
-  #                     "/path/to/keyfile.json"
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.find "Task", "sampleTask"
-  # task["priority"] = 5
-  # datastore.save task
-  # ```
-  #
-  # You can learn more about various options for connection on the
-  # [Authentication
-  # Guide](https://googlecloudplatform.github.io/gcloud-ruby/#/docs/guides/authentication).
-  #
-  # To learn more about Datastore, read the
-  # [Google Cloud Datastore Concepts Overview
-  # ](https://cloud.google.com/datastore/docs/concepts/overview).
-  #
-  # ## Retrieving records
-  #
-  # Records, called "entities" in Datastore, are retrieved by using a key.
-  # The key is more than a numeric identifier, it is a complex data structure
-  # that can be used to model relationships. The simplest key has a string
-  # <tt>kind</tt> value, and either a numeric <tt>id</tt> value, or a string
-  # <tt>name</tt> value. A single record can be retrieved by calling
-  # {Gcloud::Datastore::Dataset#find} and passing the parts of the key:
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.find "Task", "sampleTask"
-  # ```
-  #
-  # Optionally, {Gcloud::Datastore::Dataset#find} can be given a key object:
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task_key = datastore.key "Task", 123456
-  # task = datastore.find task_key
-  # ```
-  #
-  # See {Gcloud::Datastore::Dataset#find}
-  #
-  # ## Querying records
-  #
-  # Multiple records can be found that match criteria.
-  # (See {Gcloud::Datastore::Query#where})
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # query = datastore.query("Task").
-  #   where("done", "=", false)
-  #
-  # tasks = datastore.run query
-  # ```
-  #
-  # Records can also be ordered. (See {Gcloud::Datastore::Query#order})
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # query = datastore.query("Task").
-  #   order("created")
-  #
-  # tasks = datastore.run query
-  # ```
-  #
-  # The number of records returned can be specified.
-  # (See {Gcloud::Datastore::Query#limit})
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # query = datastore.query("Task").
-  #   limit(5)
-  #
-  # tasks = datastore.run query
-  # ```
-  #
-  # Records' key structures can also be queried.
-  # (See {Gcloud::Datastore::Query#ancestor})
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task_list_key = datastore.key "TaskList", "default"
-  #
-  # query = datastore.query("Task").
-  #   ancestor(task_list_key)
-  #
-  # tasks = datastore.run query
-  # ```
-  #
-  # See {Gcloud::Datastore::Query} and {Gcloud::Datastore::Dataset#run}
-  #
-  # ### Paginating records
-  #
-  # All records may not return at once, but multiple calls can be made to
-  # Datastore to return them all.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # query = datastore.query("Task")
-  # tasks = datastore.run query
-  # tasks.all do |task|
-  #   puts t["description"]
-  # end
-  # ```
-  #
-  # See {Gcloud::Datastore::Dataset::LookupResults} and
-  # {Gcloud::Datastore::Dataset::QueryResults}
-  #
-  # ## Creating records
-  #
-  # New entities can be created and persisted buy calling
-  # {Gcloud::Datastore::Dataset#save}. The entity must have a key to be saved.
-  # If the key is incomplete then it will be completed when saved.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.entity "Task" do |t|
-  #   t["type"] = "Personal"
-  #   t["done"] = false
-  #   t["priority"] = 4
-  #   t["description"] = "Learn Cloud Datastore"
-  # end
-  # task.key.id #=> nil
-  # datastore.save task
-  # task.key.id #=> 123456
-  # ```
-  #
-  # Multiple new entities may be created in a batch.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task1 = datastore.entity "Task" do |t|
-  #   t["type"] = "Personal"
-  #   t["done"] = false
-  #   t["priority"] = 4
-  #   t["description"] = "Learn Cloud Datastore"
-  # end
-  #
-  # task2 = datastore.entity "Task" do |t|
-  #   t["type"] = "Personal"
-  #   t["done"] = false
-  #   t["priority"] = 5
-  #   t["description"] = "Integrate Cloud Datastore"
-  # end
-  #
-  # tasks = datastore.save(task1, task2)
-  # task_key1 = tasks[0].key
-  # task_key2 = tasks[1].key
-  # ```
-  #
-  # Entities in Datastore form a hierarchically structured space similar to the
-  # directory structure of a file system. When you create an entity, you can
-  # optionally designate another entity as its parent; the new entity is a child
-  # of the parent entity.
-  #
-  # ```ruby
-  # task_key = datastore.key "Task", "sampleTask"
-  # task_key.parent = datastore.key "TaskList", "default"
-  #
-  # task = datastore.entity task_key do |t|
-  #   t["type"] = "Personal"
-  #   t["done"] = false
-  #   t["priority"] = 5
-  #   t["description"] = "Integrate Cloud Datastore"
-  # end
-  # ```
-  #
-  # ## Setting properties
-  #
-  # Entities hold properties. A property has a name that is a string or symbol,
-  # and a value that is an object. Most value objects are supported, including
-  # String, Integer, Date, Time, and even other entity or key objects. Changes
-  # to the entity's properties are persisted by calling
-  # {Gcloud::Datastore::Dataset#save}.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.find "Task", "sampleTask"
-  # # Read the priority property
-  # task["priority"] #=> 4
-  # # Write the priority property
-  # task["priority"] = 5
-  # # Persist the changes
-  # datastore.save task
-  # ```
-  #
-  # Array properties can be used to store more than one value.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.entity "Task", "sampleTask" do |t|
-  #   t["tags"] = ["fun", "programming"]
-  #   t["collaborators"] = ["alice", "bob"]
-  # end
-  # ```
-  #
-  # ## Deleting records
-  #
-  # Entities can be removed from Datastore by calling
-  # {Gcloud::Datastore::Dataset#delete} and passing the entity object or the
-  # entity's key object.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.find "Task", "sampleTask"
-  # datastore.delete task
-  # ```
-  #
-  # Multiple entities may be deleted in a batch.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task_key1 = datastore.key "Task", "sampleTask1"
-  # task_key2 = datastore.key "Task", "sampleTask2"
-  # datastore.delete task_key1, task_key2
-  # ```
-  #
-  # ## Transactions
-  #
-  # Complex logic can be wrapped in a Transaction. All queries and updates
-  # within the {Gcloud::Datastore::Dataset#transaction} block are run within the
-  # transaction scope, and will be automatically committed when the block
-  # completes.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task_key = datastore.key "Task", "sampleTask"
-  #
-  # datastore.transaction do |tx|
-  #   if tx.find(task_key).nil?
-  #     task = datastore.entity task_key do |t|
-  #       t["type"] = "Personal"
-  #       t["done"] = false
-  #       t["priority"] = 4
-  #       t["description"] = "Learn Cloud Datastore"
-  #     end
-  #     tx.save task
-  #   end
-  # end
-  # ```
-  #
-  # Alternatively, if no block is given the transaction object is returned
-  # allowing you to commit or rollback manually.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore
-  #
-  # task_key = datastore.key "Task", "sampleTask"
-  #
-  # tx = datastore.transaction
-  # begin
-  #   if tx.find(task_key).nil?
-  #     task = datastore.entity task_key do |t|
-  #       t["type"] = "Personal"
-  #       t["done"] = false
-  #       t["priority"] = 4
-  #       t["description"] = "Learn Cloud Datastore"
-  #     end
-  #     tx.save task
-  #   end
-  #   tx.commit
-  # rescue
-  #   tx.rollback
-  # end
-  # ```
-  #
-  # See {Gcloud::Datastore::Transaction} and
-  # {Gcloud::Datastore::Dataset#transaction}
-  #
-  # ## Querying metadata
-  #
-  # Datastore provides programmatic access to some of its metadata to support
-  # meta-programming, implementing backend administrative functions, simplify
-  # consistent caching, and similar purposes. The metadata available includes
-  # information about the entity groups, namespaces, entity kinds, and
-  # properties your application uses, as well as the property representations
-  # for each property.
-  #
-  # The special entity kind `__namespace__` can be used to find all the
-  # namespaces used in your application entities.
-  #
-  # ```ruby
-  # query = datastore.query("__namespace__").
-  #   select("__key__").
-  #   where("__key__", ">=", datastore.key("__namespace__", "g")).
-  #   where("__key__", "<", datastore.key("__namespace__", "h"))
-  #
-  # namespaces = datastore.run(query).map do |entity|
-  #   entity.key.name
-  # end
-  # ```
-  #
-  # The special entity kind `__kind__` can be used to return all the
-  # kinds used in your application.
-  #
-  # ```ruby
-  # query = datastore.query("__kind__").
-  #   select("__key__")
-  #
-  # kinds = datastore.run(query).map do |entity|
-  #   entity.key.name
-  # end
-  # ```
-  #
-  # Property queries return entities of kind `__property__` denoting the indexed
-  # properties associated with an entity kind. (Unindexed properties are not
-  # included.)
-  #
-  # ```ruby
-  # query = datastore.query("__property__").
-  #   select("__key__")
-  #
-  # entities = datastore.run(query)
-  # properties_by_kind = entities.each_with_object({}) do |entity, memo|
-  #   kind = entity.key.parent.name
-  #   prop = entity.key.name
-  #   memo[kind] ||= []
-  #   memo[kind] << prop
-  # end
-  # ```
-  #
-  # Property queries support ancestor filtering on a `__kind__` or
-  # `__property__` key, to limit the query results to a single kind or property.
-  # The `property_representation` property in the entity representing property
-  # `p` of kind `k` is an array containing all representations of `p`'s value in
-  # any entity of kind `k`.
-  #
-  # ```ruby
-  # ancestor_key = datastore.key "__kind__", "Task"
-  # query = datastore.query("__property__").
-  #   ancestor(ancestor_key)
-  #
-  # entities = datastore.run(query)
-  # representations = entities.each_with_object({}) do |entity, memo|
-  #   property_name = entity.key.name
-  #   property_types = entity["property_representation"]
-  #   memo[property_name] = property_types
-  # end
-  # ```
-  #
-  # Property queries can also be filtered with a range over the pseudo-property
-  # `__key__`, where the keys denote either `__kind__` or `__property__`
-  # entities.
-  #
-  # ```ruby
-  # start_key = datastore.key "__property__", "priority"
-  # start_key.parent = datastore.key "__kind__", "Task"
-  # query = datastore.query("__property__").
-  #   select("__key__").
-  #   where("__key__", ">=", start_key)
-  #
-  # entities = datastore.run(query)
-  # properties_by_kind = entities.each_with_object({}) do |entity, memo|
-  #   kind = entity.key.parent.name
-  #   prop = entity.key.name
-  #   memo[kind] ||= []
-  #   memo[kind] << prop
-  # end
-  # ```
-  #
-  # ## Configuring retries and timeout
-  #
-  # You can configure how many times API requests may be automatically retried.
-  # When an API request fails, the response will be inspected to see if the
-  # request meets criteria indicating that it may succeed on retry, such as
-  # `500` and `503` status codes or a specific internal error code such as
-  # `rateLimitExceeded`. If it meets the criteria, the request will be retried
-  # after a delay. If another error occurs, the delay will be increased before a
-  # subsequent attempt, until the `retries` limit is reached.
-  #
-  # You can also set the request `timeout` value in seconds.
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # gcloud = Gcloud.new
-  # datastore = gcloud.datastore retries: 10, timeout: 120
-  # ```
-  #
-  # See the [Datastore error
-  # codes](https://cloud.google.com/datastore/docs/concepts/errors#error_codes)
-  # for a list of error conditions.
-  #
-  # ## The Cloud Datastore Emulator
-  #
-  # As of this release, the Cloud Datastore emulator that is part of the gcloud
-  # SDK is no longer compatible with gcloud-ruby. This is because the gcloud
-  # SDK's Cloud Datastore emulator does not yet support gRPC as a transport
-  # layer.
-  #
-  # A gRPC-compatible emulator is available until the gcloud SDK Cloud Datastore
-  # emulator supports gRPC. To use it you must [download the gRPC
-  # emulator](https://storage.googleapis.com/gcd/tools/cloud-datastore-emulator-1.1.1.zip)
-  # and use the `cloud_datastore_emulator` script.
-  #
-  # When you run the Cloud Datastore emulator you will see a message similar to
-  # the following printed:
-  #
-  # ```
-  # If you are using a library that supports the DATASTORE_EMULATOR_HOST
-  # environment variable, run:
-  #
-  # export DATASTORE_EMULATOR_HOST=localhost:8978
-  # ```
-  #
-  # Now you can connect to the emulator using the `DATASTORE_EMULATOR_HOST`
-  # environment variable:
-  #
-  # ```ruby
-  # require "gcloud"
-  #
-  # # Make Datastore use the emulator
-  # ENV["DATASTORE_EMULATOR_HOST"] = "localhost:8978"
-  #
-  # gcloud = Gcloud.new "emulator-project-id"
-  # datastore = gcloud.datastore
-  #
-  # task = datastore.entity "Task", "emulatorTask" do |t|
-  #   t["type"] = "Testing"
-  #   t["done"] = false
-  #   t["priority"] = 5
-  #   t["description"] = "Use Datastore Emulator"
-  # end
-  #
-  # datastore.save task
-  # ```
-  #
-  module Datastore
-  end
-end
+require "google/cloud/datastore"