google-cloud-bigquery 1.12.0 → 1.38.1

data/lib/google/cloud/bigquery/standard_sql.rb

@@ -18,89 +18,226 @@ module Google
     module Bigquery
       ##
       # BigQuery standard SQL is compliant with the SQL 2011 standard and has
-      # extensions that support querying nested and repeated data.
+      # extensions that support querying nested and repeated data. See {Routine} and {Argument}.
+      #
+      # @example
+      #   require "google/cloud/bigquery"
+      #
+      #   bigquery = Google::Cloud::Bigquery.new
+      #   dataset = bigquery.dataset "my_dataset"
+      #   routine = dataset.create_routine "my_routine" do |r|
+      #     r.routine_type = "SCALAR_FUNCTION"
+      #     r.language = :SQL
+      #     r.body = "(SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem)"
+      #     r.arguments = [
+      #       Google::Cloud::Bigquery::Argument.new(
+      #         name: "arr",
+      #         argument_kind: "FIXED_TYPE",
+      #         data_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+      #           type_kind: "ARRAY",
+      #           array_element_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+      #             type_kind: "STRUCT",
+      #             struct_type: Google::Cloud::Bigquery::StandardSql::StructType.new(
+      #               fields: [
+      #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+      #                   name: "name",
+      #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "STRING")
+      #                 ),
+      #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+      #                   name: "val",
+      #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "INT64")
+      #                 )
+      #               ]
+      #             )
+      #           )
+      #         )
+      #       )
+      #     ]
+      #   end
+      #
       module StandardSql
         ##
-        # A field or a column.
+        # A field or a column. See {Routine} and {Argument}.
+        #
+        # @example
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #   routine = dataset.create_routine "my_routine" do |r|
+        #     r.routine_type = "SCALAR_FUNCTION"
+        #     r.language = :SQL
+        #     r.body = "(SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem)"
+        #     r.arguments = [
+        #       Google::Cloud::Bigquery::Argument.new(
+        #         name: "arr",
+        #         argument_kind: "FIXED_TYPE",
+        #         data_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #           type_kind: "ARRAY",
+        #           array_element_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #             type_kind: "STRUCT",
+        #             struct_type: Google::Cloud::Bigquery::StandardSql::StructType.new(
+        #               fields: [
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "name",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "STRING")
+        #                 ),
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "val",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "INT64")
+        #                 )
+        #               ]
+        #             )
+        #           )
+        #         )
+        #       )
+        #     ]
+        #   end
+        #
         class Field
           ##
-          # @private Create an empty StandardSql::Field object.
-          def initialize
-            @gapi_json = nil
+          # Creates a new, immutable StandardSql::Field object.
+          #
+          # @overload initialize(name, type)
+          #   @param [String] name The name of the field. Optional. Can be absent for struct fields.
+          #   @param [StandardSql::DataType, String] type The type of the field. Optional. Absent if not explicitly
+          #     specified (e.g., `CREATE FUNCTION` statement can omit the return type; in this case the output parameter
+          #     does not have this "type" field).
+          #
+          def initialize **kwargs
+            # Convert client object kwargs to a gapi object
+            kwargs[:type] = DataType.gapi_from_string_or_data_type kwargs[:type] if kwargs[:type]
+            @gapi = Google::Apis::BigqueryV2::StandardSqlField.new(**kwargs)
           end
 
           ##
-          # The name of the field. (Can be absent for struct fields.)
+          # The name of the field. Optional. Can be absent for struct fields.
           #
           # @return [String, nil]
           #
           def name
-            return nil if @gapi_json[:name] == "".freeze
-
-            @gapi_json[:name]
+            return if @gapi.name == "".freeze
+            @gapi.name
           end
 
           ##
-          # The type of the field.
+          # The type of the field. Optional. Absent if not explicitly specified (e.g., `CREATE FUNCTION` statement can
+          # omit the return type; in this case the output parameter does not have this "type" field).
           #
-          # @return [DataType]
+          # @return [DataType, nil] The type of the field.
           #
           def type
-            DataType.from_gapi_json @gapi_json[:type]
+            DataType.from_gapi @gapi.type if @gapi.type
+          end
+
+          ##
+          # @private New Google::Apis::BigqueryV2::StandardSqlField object.
+          def to_gapi
+            @gapi
           end
 
           ##
-          # @private New StandardSql::Field from a JSON object.
-          def self.from_gapi_json gapi_json
+          # @private New StandardSql::Field from a Google::Apis::BigqueryV2::StandardSqlField object.
+          def self.from_gapi gapi
             new.tap do |f|
-              f.instance_variable_set :@gapi_json, gapi_json
+              f.instance_variable_set :@gapi, gapi
             end
           end
         end
 
         ##
-        # The type of a field or a column.
+        # The type of a variable, e.g., a function argument. See {Routine} and {Argument}.
+        #
+        # @example
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #   routine = dataset.create_routine "my_routine" do |r|
+        #     r.routine_type = "SCALAR_FUNCTION"
+        #     r.language = :SQL
+        #     r.body = "(SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem)"
+        #     r.arguments = [
+        #       Google::Cloud::Bigquery::Argument.new(
+        #         name: "arr",
+        #         argument_kind: "FIXED_TYPE",
+        #         data_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #           type_kind: "ARRAY",
+        #           array_element_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #             type_kind: "STRUCT",
+        #             struct_type: Google::Cloud::Bigquery::StandardSql::StructType.new(
+        #               fields: [
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "name",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "STRING")
+        #                 ),
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "val",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "INT64")
+        #                 )
+        #               ]
+        #             )
+        #           )
+        #         )
+        #       )
+        #     ]
+        #   end
+        #
+        # @see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types Standard SQL Data Types
+        #
         class DataType
           ##
-          # @private Create an empty StandardSql::DataType object.
-          def initialize
-            @gapi_json = nil
+          # Creates a new, immutable StandardSql::DataType object.
+          #
+          # @overload initialize(type_kind, array_element_type, struct_type)
+          #   @param [String] type_kind The top level type of this field. Required. Can be [any standard SQL data
+          #     type](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types) (e.g., `INT64`, `DATE`,
+          #     `ARRAY`).
+          #   @param [DataType, String] array_element_type The type of the array's elements, if {#type_kind} is `ARRAY`.
+          #     See {#array?}. Optional.
+          #   @param [StructType] struct_type The fields of the struct, in order, if {#type_kind} is `STRUCT`. See
+          #     {#struct?}. Optional.
+          #
+          def initialize **kwargs
+            # Convert client object kwargs to a gapi object
+            if kwargs[:array_element_type]
+              kwargs[:array_element_type] = self.class.gapi_from_string_or_data_type kwargs[:array_element_type]
+            end
+            kwargs[:struct_type] = kwargs[:struct_type].to_gapi if kwargs[:struct_type]
+
+            @gapi = Google::Apis::BigqueryV2::StandardSqlDataType.new(**kwargs)
           end
 
           ##
-          # The top level type of this field.
+          # The top level type of this field. Required. Can be any standard SQL data type (e.g., `INT64`, `DATE`,
+          # `ARRAY`).
           #
-          # Can be any standard SQL data type (e.g., "INT64", "DATE", "ARRAY").
+          # @see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types Standard SQL Data Types
           #
-          # @see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types
-          #   Standard SQL Data Types
-          #
-          # @return [String]
+          # @return [String] The upper case type.
           #
           def type_kind
-            @gapi_json[:typeKind]
+            @gapi.type_kind
           end
 
           ##
-          # The type of a fields when DataType is an Array. (See #array?)
+          # The type of the array's elements, if {#type_kind} is `ARRAY`. See {#array?}. Optional.
           #
           # @return [DataType, nil]
           #
           def array_element_type
-            return if @gapi_json[:arrayElementType].nil?
-
-            DataType.from_gapi_json @gapi_json[:arrayElementType]
+            return if @gapi.array_element_type.nil?
+            DataType.from_gapi @gapi.array_element_type
           end
 
           ##
-          # The fields of the struct. (See #struct?)
+          # The fields of the struct, in order, if {#type_kind} is `STRUCT`. See {#struct?}. Optional.
           #
           # @return [StructType, nil]
           #
           def struct_type
-            return if @gapi_json[:structType].nil?
-
-            StructType.from_gapi_json @gapi_json[:structType]
+            return if @gapi.struct_type.nil?
+            StructType.from_gapi @gapi.struct_type
           end
 
           ##
@@ -136,6 +273,17 @@ module Google
             type_kind == "NUMERIC".freeze
           end
 
+          ##
+          # Checks if the {#type_kind} of the field is `BIGNUMERIC`.
+          #
+          # @return [Boolean] `true` when `BIGNUMERIC`, `false` otherwise.
+          #
+          # @!group Helpers
+          #
+          def bignumeric?
+            type_kind == "BIGNUMERIC".freeze
+          end
+
           ##
           # Checks if the {#type_kind} of the field is `BOOL`.
           #
@@ -247,41 +395,109 @@ module Google
           end
 
           ##
-          # @private New StandardSql::DataType from a JSON object.
-          def self.from_gapi_json gapi_json
-            new.tap do |dt|
-              dt.instance_variable_set :@gapi_json, gapi_json
+          # @private New Google::Apis::BigqueryV2::StandardSqlDataType object.
+          def to_gapi
+            @gapi
+          end
+
+          ##
+          # @private New StandardSql::DataType from a Google::Apis::BigqueryV2::StandardSqlDataType object.
+          def self.from_gapi gapi
+            new.tap do |f|
+              f.instance_variable_set :@gapi, gapi
+            end
+          end
+
+          ##
+          # @private New Google::Apis::BigqueryV2::StandardSqlDataType from a String or StandardSql::DataType object.
+          def self.gapi_from_string_or_data_type data_type
+            return if data_type.nil?
+            case data_type
+            when StandardSql::DataType
+              data_type.to_gapi
+            when Hash
+              data_type
+            when String, Symbol
+              Google::Apis::BigqueryV2::StandardSqlDataType.new type_kind: data_type.to_s.upcase
+            else
+              raise ArgumentError, "Unable to convert #{data_type} to Google::Apis::BigqueryV2::StandardSqlDataType"
             end
           end
         end
 
         ##
-        # The type of a `STRUCT` field or a column.
+        # The fields of a `STRUCT` type. See {DataType#struct_type}. See {Routine} and {Argument}.
+        #
+        # @example
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #   routine = dataset.create_routine "my_routine" do |r|
+        #     r.routine_type = "SCALAR_FUNCTION"
+        #     r.language = :SQL
+        #     r.body = "(SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem)"
+        #     r.arguments = [
+        #       Google::Cloud::Bigquery::Argument.new(
+        #         name: "arr",
+        #         argument_kind: "FIXED_TYPE",
+        #         data_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #           type_kind: "ARRAY",
+        #           array_element_type: Google::Cloud::Bigquery::StandardSql::DataType.new(
+        #             type_kind: "STRUCT",
+        #             struct_type: Google::Cloud::Bigquery::StandardSql::StructType.new(
+        #               fields: [
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "name",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "STRING")
+        #                 ),
+        #                 Google::Cloud::Bigquery::StandardSql::Field.new(
+        #                   name: "val",
+        #                   type: Google::Cloud::Bigquery::StandardSql::DataType.new(type_kind: "INT64")
+        #                 )
+        #               ]
+        #             )
+        #           )
+        #         )
+        #       )
+        #     ]
+        #   end
+        #
         class StructType
           ##
-          # @private Create an empty StandardSql::DataType object.
-          def initialize
-            @gapi_json = nil
+          # Creates a new, immutable StandardSql::StructType object.
+          #
+          # @overload initialize(fields)
+          #   @param [Array<Field>] fields The fields of the struct. Required.
+          #
+          def initialize **kwargs
+            # Convert each field client object to gapi object, if fields given (self.from_gapi does not pass kwargs)
+            kwargs[:fields] = kwargs[:fields]&.map(&:to_gapi) if kwargs[:fields]
+            @gapi = Google::Apis::BigqueryV2::StandardSqlStructType.new(**kwargs)
           end
 
           ##
-          # The top level type of this field.
+          # The fields of the struct.
           #
-          # Can be any standard SQL data type (e.g., "INT64", "DATE", "ARRAY").
-          #
-          # @return [Array<Field>]
+          # @return [Array<Field>] A frozen array of fields.
           #
           def fields
-            Array(@gapi_json[:fields]).map do |field_gapi_json|
-              Field.from_gapi_json field_gapi_json
-            end
+            Array(@gapi.fields).map do |field_gapi|
+              Field.from_gapi field_gapi
+            end.freeze
           end
 
           ##
-          # @private New StandardSql::StructType from a JSON object.
-          def self.from_gapi_json gapi_json
-            new.tap do |st|
-              st.instance_variable_set :@gapi_json, gapi_json
+          # @private New Google::Apis::BigqueryV2::StandardSqlStructType object.
+          def to_gapi
+            @gapi
+          end
+
+          ##
+          # @private New StandardSql::StructType from a Google::Apis::BigqueryV2::StandardSqlStructType object.
+          def self.from_gapi gapi
+            new.tap do |f|
+              f.instance_variable_set :@gapi, gapi
             end
           end
         end

data/lib/google/cloud/bigquery/table/async_inserter.rb

@@ -64,16 +64,21 @@ module Google
         class AsyncInserter
           include MonitorMixin
 
-          attr_reader :max_bytes, :max_rows, :interval, :threads
+          attr_reader :max_bytes
+          attr_reader :max_rows
+          attr_reader :interval
+          attr_reader :threads
           ##
           # @private Implementation accessors
           attr_reader :table, :batch
 
           ##
           # @private
-          def initialize table, skip_invalid: nil, ignore_unknown: nil,
-                         max_bytes: 10000000, max_rows: 500, interval: 10,
-                         threads: 4, &block
+          def initialize table, skip_invalid: nil, ignore_unknown: nil, max_bytes: 10_000_000, max_rows: 500,
+                         interval: 10, threads: 4, &block
+            # init MonitorMixin
+            super()
+
             @table = table
             @skip_invalid = skip_invalid
             @ignore_unknown = ignore_unknown
@@ -86,12 +91,9 @@ module Google
 
             @batch = nil
 
-            @thread_pool = Concurrent::FixedThreadPool.new @threads
+            @thread_pool = Concurrent::ThreadPoolExecutor.new max_threads: @threads
 
             @cond = new_cond
-
-            # init MonitorMixin
-            super()
           end
 
           ##
@@ -99,14 +101,47 @@ module Google
           # collected in batches and inserted together.
           # See {Google::Cloud::Bigquery::Table#insert_async}.
           #
-          # @param [Hash, Array<Hash>] rows A hash object or array of hash
-          #   objects containing the data.
-          # @param [Array<String>] insert_ids A unique ID for each row. BigQuery
-          #   uses this property to detect duplicate insertion requests on a
-          #   best-effort basis. For more information, see [data
-          #   consistency](https://cloud.google.com/bigquery/streaming-data-into-bigquery#dataconsistency).
-          #   Optional. If not provided, the client library will assign a UUID
-          #   to each row before the request is sent.
+          # Simple Ruby types are generally accepted per JSON rules, along with the following support for BigQuery's
+          # more complex types:
+          #
+          # | BigQuery     | Ruby                                 | Notes                                              |
+          # |--------------|--------------------------------------|----------------------------------------------------|
+          # | `NUMERIC`    | `BigDecimal`                         | `BigDecimal` values will be rounded to scale 9.    |
+          # | `BIGNUMERIC` | `String`                             | Pass as `String` to avoid rounding to scale 9.     |
+          # | `DATETIME`   | `DateTime`                           | `DATETIME` does not support time zone.             |
+          # | `DATE`       | `Date`                               |                                                    |
+          # | `GEOGRAPHY`  | `String`                             |                                                    |
+          # | `TIMESTAMP`  | `Time`                               |                                                    |
+          # | `TIME`       | `Google::Cloud::BigQuery::Time`      |                                                    |
+          # | `BYTES`      | `File`, `IO`, `StringIO`, or similar |                                                    |
+          # | `ARRAY`      | `Array`                              | Nested arrays, `nil` values are not supported.     |
+          # | `STRUCT`     | `Hash`                               | Hash keys may be strings or symbols.               |
+          #
+          # Because BigQuery's streaming API is designed for high insertion
+          # rates, modifications to the underlying table metadata are eventually
+          # consistent when interacting with the streaming system. In most cases
+          # metadata changes are propagated within minutes, but during this
+          # period API responses may reflect the inconsistent state of the
+          # table.
+          #
+          # @see https://cloud.google.com/bigquery/streaming-data-into-bigquery
+          #   Streaming Data Into BigQuery
+          #
+          # @see https://cloud.google.com/bigquery/troubleshooting-errors#metadata-errors-for-streaming-inserts
+          #   BigQuery Troubleshooting: Metadata errors for streaming inserts
+          #
+          # @param [Hash, Array<Hash>] rows A hash object or array of hash objects
+          #   containing the data. Required. `BigDecimal` values will be rounded to
+          #   scale 9 to conform with the BigQuery `NUMERIC` data type. To avoid
+          #   rounding `BIGNUMERIC` type values with scale greater than 9, use `String`
+          #   instead of `BigDecimal`.
+          # @param [Array<String|Symbol>, Symbol] insert_ids A unique ID for each row. BigQuery uses this property to
+          #   detect duplicate insertion requests on a best-effort basis. For more information, see [data
+          #   consistency](https://cloud.google.com/bigquery/streaming-data-into-bigquery#dataconsistency). Optional. If
+          #   not provided, the client library will assign a UUID to each row before the request is sent.
+          #
+          #  The value `:skip` can be provided to skip the generation of IDs for all rows, or to skip the generation of
+          #  an ID for a specific row in the array.
           #
           def insert rows, insert_ids: nil
             return nil if rows.nil?
@@ -122,8 +157,7 @@ module Google
                   unless @batch.try_insert row, insert_id
                     push_batch_request!
 
-                    @batch = Batch.new max_bytes: @max_bytes,
-                                       max_rows:  @max_rows
+                    @batch = Batch.new max_bytes: @max_bytes, max_rows: @max_rows
                     @batch.insert row, insert_id
                   end
                 end
@@ -213,10 +247,14 @@ module Google
 
           def validate_insert_args rows, insert_ids
             rows = [rows] if rows.is_a? Hash
+            raise ArgumentError, "No rows provided" if rows.empty?
+
+            insert_ids = Array.new(rows.count) { :skip } if insert_ids == :skip
             insert_ids = Array insert_ids
-            if insert_ids.count > 0 && insert_ids.count != rows.count
+            if insert_ids.count.positive? && insert_ids.count != rows.count
               raise ArgumentError, "insert_ids must be the same size as rows"
             end
+
             [rows, insert_ids]
           end
 
@@ -249,22 +287,19 @@ module Google
             json_rows = @batch.json_rows
             insert_ids = @batch.insert_ids
             Concurrent::Future.new executor: @thread_pool do
-              begin
-                raise ArgumentError, "No rows provided" if json_rows.empty?
-                options = { skip_invalid:   @skip_invalid,
-                            ignore_unknown: @ignore_unknown,
-                            insert_ids:     insert_ids }
-                insert_resp = @table.service.insert_tabledata_json_rows(
-                  @table.dataset_id, @table.table_id, json_rows, options
-                )
-                result = Result.new(
-                  InsertResponse.from_gapi(orig_rows, insert_resp)
-                )
-              rescue StandardError => e
-                result = Result.new nil, e
-              ensure
-                @callback.call result if @callback
-              end
+              raise ArgumentError, "No rows provided" if json_rows.empty?
+              insert_resp = @table.service.insert_tabledata_json_rows @table.dataset_id,
+                                                                      @table.table_id,
+                                                                      json_rows,
+                                                                      skip_invalid: @skip_invalid,
+                                                                      ignore_unknown: @ignore_unknown,
+                                                                      insert_ids: insert_ids
+
+              result = Result.new InsertResponse.from_gapi(orig_rows, insert_resp)
+            rescue StandardError => e
+              result = Result.new nil, e
+            ensure
+              @callback&.call result
             end.execute
 
             @batch = nil
@@ -274,9 +309,13 @@ module Google
           ##
           # @private
           class Batch
-            attr_reader :max_bytes, :max_rows, :rows, :json_rows, :insert_ids
+            attr_reader :max_bytes
+            attr_reader :max_rows
+            attr_reader :rows
+            attr_reader :json_rows
+            attr_reader :insert_ids
 
-            def initialize max_bytes: 10000000, max_rows: 500
+            def initialize max_bytes: 10_000_000, max_rows: 500
               @max_bytes = max_bytes
               @max_rows = max_rows
               @rows = []
@@ -292,8 +331,7 @@ module Google
               insert_id ||= SecureRandom.uuid
               json_row = to_json_row row
 
-              insert_rows_bytes \
-                row, json_row, insert_id, addl_bytes_for(json_row, insert_id)
+              insert_rows_bytes row, json_row, insert_id, addl_bytes_for(json_row, insert_id)
             end
 
             def try_insert row, insert_id
@@ -326,8 +364,13 @@ module Google
             end
 
             def addl_bytes_for json_row, insert_id
-              # "{\"insertId\":\"\",\"json\":},".bytesize #=> 24
-              24 + json_row.to_json.bytesize + insert_id.bytesize
+              if insert_id == :skip
+                # "{\"json\":},".bytesize #=> 10
+                10 + json_row.to_json.bytesize
+              else
+                # "{\"insertId\":\"\",\"json\":},".bytesize #=> 24
+                24 + json_row.to_json.bytesize + insert_id.bytesize
+              end
             end
           end
 
@@ -379,7 +422,8 @@ module Google
               @error = error
             end
 
-            attr_reader :insert_response, :error
+            attr_reader :insert_response
+            attr_reader :error
 
             ##
             # Checks if an error is present, meaning that the insert operation

data/lib/google/cloud/bigquery/table/list.rb

@@ -78,8 +78,7 @@ module Google
           def next
             return nil unless next?
             ensure_service!
-            options = { token: token, max: @max }
-            gapi = @service.list_tables @dataset_id, options
+            gapi = @service.list_tables @dataset_id, token: token, max: @max
             self.class.from_gapi gapi, @service, @dataset_id, @max
           end
 
@@ -131,17 +130,15 @@ module Google
           #     puts table.name
           #   end
           #
-          def all request_limit: nil
+          def all request_limit: nil, &block
             request_limit = request_limit.to_i if request_limit
-            unless block_given?
-              return enum_for :all, request_limit: request_limit
-            end
+            return enum_for :all, request_limit: request_limit unless block_given?
             results = self
             loop do
-              results.each { |r| yield r }
+              results.each(&block)
               if request_limit
                 request_limit -= 1
-                break if request_limit < 0
+                break if request_limit.negative?
               end
               break unless results.next?
               results = results.next
@@ -151,9 +148,7 @@ module Google
           ##
           # @private New Table::List from a response object.
           def self.from_gapi gapi_list, service, dataset_id = nil, max = nil
-            tables = List.new(Array(gapi_list.tables).map do |gapi_object|
-              Table.from_gapi gapi_object, service
-            end)
+            tables = List.new(Array(gapi_list.tables).map { |gapi_object| Table.from_gapi gapi_object, service })
             tables.instance_variable_set :@token,      gapi_list.next_page_token
             tables.instance_variable_set :@etag,       gapi_list.etag
             tables.instance_variable_set :@total,      gapi_list.total_items