gcloud 0.6.3 → 0.7.0

data/lib/gcloud/backoff.rb

@@ -1,4 +1,3 @@
-#--
 # Copyright 2014 Google Inc. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-#--
-# Google Cloud Backoff
+
 module Gcloud
   ##
   # Backoff allows users to control how Google API calls are retried.
@@ -25,9 +23,11 @@ module Gcloud
   # retry will be delayed one second, the second retry will be delayed
   # two seconds, and so on.
   #
+  # @example
   #   require "gcloud/backoff"
   #
   #   Gcloud::Backoff.retries = 5 # Set a maximum of five retries per call
+  #
   class Backoff
     class << self
       ##
@@ -36,6 +36,12 @@ module Gcloud
       # The default value is 3.
       attr_accessor :retries
 
+      ##
+      # The GRPC Status Codes that should be retried.
+      #
+      # The default values are 14.
+      attr_accessor :grpc_codes
+
       ##
       # The HTTP Status Codes that should be retried.
       #
@@ -59,52 +65,74 @@ module Gcloud
     end
     # Set the default values
     self.retries = 3
+    self.grpc_codes = [14]
     self.http_codes = [500, 503]
     self.reasons = %w(rateLimitExceeded userRateLimitExceeded)
     self.backoff = ->(retries) { sleep retries.to_i }
 
     ##
+    # @private
     # Creates a new Backoff object to catch common errors when calling
     # the Google API and handle the error by retrying the call.
     #
-    #   Gcloud::Backoff.new(options).execute do
+    #   Gcloud::Backoff.new(options).execute_gapi do
     #     client.execute api_method: service.things.insert,
     #                    parameters: { thing: @thing },
     #                    body_object: { name: thing_name }
     #   end
-    def initialize options = {} #:nodoc:
-      @max_retries  = (options[:retries]    || Backoff.retries).to_i
-      @http_codes   = (options[:http_codes] || Backoff.http_codes).to_a
-      @reasons      = (options[:reasons]    || Backoff.reasons).to_a
-      @backoff      =  options[:backoff]    || Backoff.backoff
+    def initialize options = {}
+      @retries    = (options[:retries]    || Backoff.retries).to_i
+      @grpc_codes = (options[:grpc_codes] || Backoff.grpc_codes).to_a
+      @http_codes = (options[:http_codes] || Backoff.http_codes).to_a
+      @reasons    = (options[:reasons]    || Backoff.reasons).to_a
+      @backoff    =  options[:backoff]    || Backoff.backoff
     end
 
-    def execute #:nodoc:
+    # @private
+    def execute_gapi
       current_retries = 0
       loop do
-        result = yield # Expecting Google::APIClient::Result
-        return result if result.success?
-        break result unless retry? result, current_retries
+        result = yield
+        return result unless result.is_a? Google::APIClient::Result
+        break result if result.success? || !retry?(result, current_retries)
         current_retries += 1
         @backoff.call current_retries
       end
     end
 
+    # @private
+    def execute_grpc
+      current_retries = 0
+      loop do
+        begin
+          return yield
+        rescue GRPC::BadStatus => e
+          raise e unless @grpc_codes.include?(e.code) &&
+                         (current_retries < @retries)
+          current_retries += 1
+          @backoff.call current_retries
+        end
+      end
+    end
+
     protected
 
+    # @private
     def retry? result, current_retries #:nodoc:
-      if current_retries < @max_retries
+      if current_retries < @retries
         return true if retry_http_code? result
         return true if retry_error_reason? result
       end
       false
     end
 
+    # @private
     def retry_http_code? result #:nodoc:
       @http_codes.include? result.response.status
     end
 
-    def retry_error_reason? result #:nodoc:
+    # @private
+    def retry_error_reason? result
       if result.data &&
          result.data["error"] &&
          result.data["error"]["errors"]

data/lib/gcloud/bigquery.rb

@@ -12,40 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 require "gcloud"
 require "gcloud/bigquery/project"
 
-#--
-# Google Cloud BigQuery
 module Gcloud
   ##
-  # Creates a new +Project+ instance connected to the BigQuery service.
+  # Creates a new `Project` instance connected to the BigQuery service.
   # Each call creates a new connection.
   #
-  # === Parameters
+  # For more information on connecting to Google Cloud see the [Authentication
+  # Guide](https://googlecloudplatform.github.io/gcloud-ruby/#/docs/guides/authentication).
   #
-  # +project+::
-  #   Identifier for a BigQuery project. If not present, the default project for
-  #   the credentials is used. (+String+)
-  # +keyfile+::
-  #   Keyfile downloaded from Google Cloud. If file path the file must be
-  #   readable. (+String+ or +Hash+)
-  # +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]. (+String+
-  #   or +Array+)
+  # @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+
-  #
-  # === Returns
+  #   * `https://www.googleapis.com/auth/bigquery`
   #
-  # Gcloud::Bigquery::Project
-  #
-  # === Example
+  # @return [Gcloud::Bigquery::Project]
   #
+  # @example
   #   require "gcloud/bigquery"
   #
   #   bigquery = Gcloud.bigquery
@@ -63,311 +57,333 @@ module Gcloud
   end
 
   ##
-  # = Google Cloud BigQuery
+  # # 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].
+  # more, read [What is
+  # BigQuery?](https://cloud.google.com/bigquery/what-is-bigquery).
   #
   # Gcloud's goal is to provide an API that is familiar and comfortable to
-  # Rubyists. Authentication is handled by Gcloud#bigquery. You can provide
+  # 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}[link:AUTHENTICATION.md].
+  # [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
+  # 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
+  # ## 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.
+  # connect to Google's `publicdata` project, and see what you find.
   #
-  #   require "gcloud"
+  # ```ruby
+  # require "gcloud"
   #
-  #   gcloud = Gcloud.new "publicdata"
-  #   bigquery = gcloud.bigquery
+  # gcloud = Gcloud.new "publicdata"
+  # bigquery = gcloud.bigquery
   #
-  #   bigquery.datasets.count #=> 1
-  #   bigquery.datasets.first.dataset_id #=> "samples"
+  # bigquery.datasets.count #=> 1
+  # bigquery.datasets.first.dataset_id #=> "samples"
   #
-  #   dataset = bigquery.datasets.first
-  #   tables = dataset.tables
+  # dataset = bigquery.datasets.first
+  # tables = dataset.tables
   #
-  #   tables.count #=> 7
-  #   tables.map &:table_id #=> [..., "shakespeare", "trigrams", "wikipedia"]
+  # 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
+  # of the `shakespeare` table, which contains an entry for every word in every
   # play written by Shakespeare.
   #
-  #   require "gcloud"
+  # ```ruby
+  # require "gcloud"
   #
-  #   gcloud = Gcloud.new "publicdata"
-  #   bigquery = gcloud.bigquery
+  # gcloud = Gcloud.new "publicdata"
+  # bigquery = gcloud.bigquery
   #
-  #   dataset = bigquery.dataset "samples"
-  #   table = dataset.table "shakespeare"
+  # dataset = bigquery.dataset "samples"
+  # table = dataset.table "shakespeare"
   #
-  #   table.headers #=> ["word", "word_count", "corpus", "corpus_date"]
-  #   table.rows_count #=> 164656
+  # 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
+  # ## Running queries
   #
   # BigQuery offers both synchronous and asynchronous methods, as explained in
-  # {Querying Data}[https://cloud.google.com/bigquery/querying-data].
+  # [Querying Data](https://cloud.google.com/bigquery/querying-data).
   #
-  # === Synchronous queries
+  # ### 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.
   #
-  #   require "gcloud"
+  # ```ruby
+  # require "gcloud"
   #
-  #   gcloud = Gcloud.new
-  #   bigquery = gcloud.bigquery
+  # gcloud = Gcloud.new
+  # bigquery = gcloud.bigquery
   #
-  #   sql = "SELECT TOP(word, 50) as word, COUNT(*) as count " +
-  #         "FROM publicdata:samples.shakespeare"
-  #   data = bigquery.query sql
+  # 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}
+  # 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
+  # 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
+  # ### 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.
+  # approach to running a query, an instance of {Gcloud::Bigquery::QueryJob} is
+  # returned, rather than an instance of {Gcloud::Bigquery::QueryData}.
   #
-  #   require "gcloud"
+  # ```ruby
+  # require "gcloud"
   #
-  #   gcloud = Gcloud.new
-  #   bigquery = gcloud.bigquery
+  # 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
+  # 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
+  # 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
+  # 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
+  # ## 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.
+  # {Gcloud::Bigquery::Dataset}. Datasets hold tables and control access to
+  # them.
   #
-  #   require "gcloud/bigquery"
+  # ```ruby
+  # require "gcloud/bigquery"
   #
-  #   gcloud = Gcloud.new
-  #   bigquery = gcloud.bigquery
-  #   dataset = bigquery.create_dataset "my_dataset"
+  # 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].)
-  #
-  #   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
+  # `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
+  # ## 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
+  # [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].
+  # [Google Developers Console](https://console.developers.google.com).
   #
-  # === Streaming records
+  # ### 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.
   #
-  #   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
+  # ```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].
+  # discussion of data consistency in [Streaming Data Into
+  # BigQuery](https://cloud.google.com/bigquery/streaming-data-into-bigquery).
   #
-  # === Uploading a file
+  # ### 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
+  # [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.
   #
-  #   require "gcloud"
+  # ```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
+  # 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"
+  # 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
+  # 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.
+  # For JSON saved with a `.txt` extension, however, it would be.
   #
-  # === A note about large uploads
+  # ### A note about large uploads
   #
-  # You may encounter a Broken pipe (Errno::EPIPE) error when attempting to
+  # You may encounter a Broken pipe (`Errno::EPIPE`) error when attempting to
   # upload large files. To avoid this problem, add the
-  # {httpclient}[https://rubygems.org/gems/httpclient] gem to your project, and
+  # [httpclient](https://rubygems.org/gems/httpclient) gem to your project, and
   # the line (or lines) of configuration shown below. These lines must execute
   # after you require gcloud but before you make your first gcloud connection.
-  # The first statement configures {Faraday}[https://rubygems.org/gems/faraday]
+  # The first statement configures [Faraday](https://rubygems.org/gems/faraday)
   # to use httpclient. The second statement, which should only be added if you
-  # are using a version of Faraday at or above 0.9.2, is a workaround for {this
-  # gzip issue}[https://github.com/GoogleCloudPlatform/gcloud-ruby/issues/367].
+  # are using a version of Faraday at or above 0.9.2, is a workaround for [this
+  # gzip issue](https://github.com/GoogleCloudPlatform/gcloud-ruby/issues/367).
   #
-  #   require "gcloud"
+  # ```ruby
+  # require "gcloud"
   #
-  #   # Use httpclient to avoid broken pipe errors with large uploads
-  #   Faraday.default_adapter = :httpclient
+  # # Use httpclient to avoid broken pipe errors with large uploads
+  # Faraday.default_adapter = :httpclient
   #
-  #   # Only add the following statement if using Faraday >= 0.9.2
-  #   # Override gzip middleware with no-op for httpclient
-  #   Faraday::Response.register_middleware :gzip =>
-  #                                           Faraday::Response::Middleware
+  # # Only add the following statement if using Faraday >= 0.9.2
+  # # Override gzip middleware with no-op for httpclient
+  # Faraday::Response.register_middleware :gzip =>
+  #                                         Faraday::Response::Middleware
   #
-  #   gcloud = Gcloud.new
-  #   bigquery = gcloud.bigquery
+  # gcloud = Gcloud.new
+  # bigquery = gcloud.bigquery
+  # ```
   #
-  # == Exporting query results to Google Cloud Storage
+  # ## Exporting query results to Google Cloud Storage
   #
-  # The example below shows how to pass the +table+ option with a query in order
+  # 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.
   #
-  #   require "gcloud"
+  # ```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"
+  # 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
+  # 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!
+  # query_job.wait_until_done!
   #
-  #   if !query_job.failed?
+  # 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"
+  #   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 = result_table.extract extract_url
   #
-  #     extract_job.wait_until_done!
+  #   extract_job.wait_until_done!
   #
-  #     # Download to local filesystem
-  #     bucket.files.first.download "baby-names-sam.csv"
+  #   # Download to local filesystem
+  #   bucket.files.first.download "baby-names-sam.csv"
   #
-  #   end
+  # 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]
+  # URIs (for partitioning), or both. See [Exporting Data From
+  # BigQuery](https://cloud.google.com/bigquery/exporting-data-from-bigquery)
   # for details.
   #
   module Bigquery