google-cloud-bigquery 1.18.0 → 1.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a73d3045289c56feffa2def6b2f46764fa271e617629253b01e43bd689017f43
-  data.tar.gz: ac4730e78ce2a9734bcfc9c8adc5bc87576e2cbd9171e59c970cf54972c7c93f
+  metadata.gz: 66fb05be59bdce437c28d89670548abba36c23a00df0bbe175983156f7ef4677
+  data.tar.gz: 73fdc5465df51fe3e3a2f554fa6540d5ffeb0890146eee2b97e60669abb2a020
 SHA512:
-  metadata.gz: 3b792a52259418fd31e3507723702b3d5934289e34bdc326b844f85b5495b57d6af208ccf4043f70c3ec3e5492691e03aa7ffadc92c223035b2a82dc2730b5ae
-  data.tar.gz: 83eaa86026274ea0d0da3ee86770e0f10883510520fc35f3058bb37b5df09eb4f31f13db4fd5908f2056999128204bc4ab75606d4e4bffc1acd30dff7e334506
+  metadata.gz: 3c0857826bc2c7394e9d9fa8ffe4eee947bbd5ed57f9ad636e34718e0b266c7091e4ddd2734619874b7624d1b939e62f7f43a74f6fe944d33b057966dafea188
+  data.tar.gz: 685a245183d53e26bfc133f6475b949b00ffc33e25eb00dfa1a52e557525bc9e6e61522d435c2398058c188005f535e5b49f79d28e29b8d8d47cb995c5561bea

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Release History
 
+### 1.21.1 / 2020-05-28
+
+#### Documentation
+
+* Fix a few broken links
+
+### 1.21.0 / 2020-03-31
+
+#### Features
+
+* Add Job#parent_job_id and Job#script_statistics
+  * Add parent_job to Project#jobs
+  * Add Job#num_child_jobs
+  * Add Job#parent_job_id
+  * Add Job#script_statistics
+
+### 1.20.0 / 2020-03-11
+
+#### Features
+
+* Add Range Partitioning
+  * Add range partitioning methods to Table and Table::Updater
+  * Add range partitioning methods to LoadJob
+  * Add range partitioning methods to QueryJob
+
+### 1.19.0 / 2020-02-11
+
+#### Features
+
+* Add Routine
+  * Add Dataset#create_routine
+  * Add Argument
+  * Update StandardSql classes to expose public initializer
+  * Add Data#ddl_target_routine and QueryJob#ddl_target_routine
+* Allow row inserts to skip insert_id generation
+  * Streaming inserts using an insert_id are not able to be inserted as fast as inserts without an insert_id
+  * Add the ability for users to skip insert_id generation in order to speed up the inserts
+  * The default behavior continues to generate insert_id values for each row inserted
+  * Add yield documentation for Dataset#insert
+
+### 1.18.1 / 2019-12-18
+
+#### Bug Fixes
+
+* Fix MonitorMixin usage on Ruby 2.7
+  * Ruby 2.7 will error if new_cond is called before super().
+  * Make the call to super() be the first call in initialize
+
 ### 1.18.0 / 2019-11-06
 
 #### Features

data/TROUBLESHOOTING.md

@@ -24,14 +24,8 @@ improved, *please* create a new issue on GitHub so we can talk about it.
 
   - [New issue][gh-ruby]
 
-Or, you can ask questions on the [Google Cloud Platform Slack][slack-ruby]. You
-can use the "ruby" channel for general Ruby questions, or use the
-"google-cloud-ruby" channel if you have questions about this gem in particular.
-
 [so-ruby]: http://stackoverflow.com/questions/tagged/google-cloud-platform+ruby+bigquery
 
-[gh-search-ruby]: https://github.com/googlecloudplatform/google-cloud-ruby/issues?q=label%3A%22api%3A+bigquery%22
-
-[gh-ruby]: https://github.com/googlecloudplatform/google-cloud-ruby/issues/new
+[gh-search-ruby]: https://github.com/googleapis/google-cloud-ruby/issues?q=label%3A%22api%3A+bigquery%22
 
-[slack-ruby]: https://gcp-slack.appspot.com/
+[gh-ruby]: https://github.com/googleapis/google-cloud-ruby/issues/new

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

@@ -0,0 +1,197 @@
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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/bigquery/standard_sql"
+
+module Google
+  module Cloud
+    module Bigquery
+      ##
+      # # Argument
+      #
+      # Input/output argument of a function or a stored procedure. See {Routine}.
+      #
+      # @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 Argument
+        ##
+        # Creates a new, immutable Argument object.
+        #
+        # @overload initialize(data_type, kind, mode, name)
+        #   @param [StandardSql::DataType, String] data_type The data type of the argument. Required unless
+        #     {#argument_kind} is `ANY_TYPE`.
+        #   @param [String] argument_kind The kind of argument. Optional. Defaults to `FIXED_TYPE`.
+        #
+        #     * `FIXED_TYPE` - The argument is a variable with fully specified type, which can be a struct or an array,
+        #       but not a table.
+        #     * `ANY_TYPE` - The argument is any type, including struct or array, but not a table.
+        #
+        #     To be added: `FIXED_TABLE`, `ANY_TABLE`.
+        #   @param [String] mode Specifies whether the argument is input or output. Optional. Can be set for procedures
+        #     only.
+        #
+        #     * IN - The argument is input-only.
+        #     * OUT - The argument is output-only.
+        #     * INOUT - The argument is both an input and an output.
+        #   @param [String] name The name of the argument. Optional. Can be absent for a function return argument.
+        #
+        def initialize **kwargs
+          kwargs[:data_type] = StandardSql::DataType.gapi_from_string_or_data_type kwargs[:data_type]
+          @gapi = Google::Apis::BigqueryV2::Argument.new(**kwargs)
+        end
+
+        ##
+        # The data type of the argument. Required unless {#argument_kind} is `ANY_TYPE`.
+        #
+        # @return [StandardSql::DataType] The data type.
+        #
+        def data_type
+          StandardSql::DataType.from_gapi @gapi.data_type
+        end
+
+        ##
+        # The kind of argument. Optional. Defaults to `FIXED_TYPE`.
+        #
+        # * `FIXED_TYPE` - The argument is a variable with fully specified type, which can be a struct or an array, but
+        #   not a table.
+        # * `ANY_TYPE` - The argument is any type, including struct or array, but not a table.
+        #
+        # To be added: `FIXED_TABLE`, `ANY_TABLE`.
+        #
+        # @return [String] The upper case kind of argument.
+        #
+        def argument_kind
+          @gapi.argument_kind
+        end
+
+        ##
+        # Checks if the value of {#argument_kind} is `FIXED_TYPE`. The default is `true`.
+        #
+        # @return [Boolean] `true` when `FIXED_TYPE`, `false` otherwise.
+        #
+        def fixed_type?
+          return true if @gapi.argument_kind.nil?
+          @gapi.argument_kind == "FIXED_TYPE"
+        end
+
+        ##
+        # Checks if the value of {#argument_kind} is `ANY_TYPE`. The default is `false`.
+        #
+        # @return [Boolean] `true` when `ANY_TYPE`, `false` otherwise.
+        #
+        def any_type?
+          @gapi.argument_kind == "ANY_TYPE"
+        end
+
+        ##
+        # Specifies whether the argument is input or output. Optional. Can be set for procedures only.
+        #
+        # * IN - The argument is input-only.
+        # * OUT - The argument is output-only.
+        # * INOUT - The argument is both an input and an output.
+        #
+        # @return [String] The upper case input/output mode of the argument.
+        #
+        def mode
+          @gapi.mode
+        end
+
+        ##
+        # Checks if the value of {#mode} is `IN`. Can be set for procedures only. The default is `false`.
+        #
+        # @return [Boolean] `true` when `IN`, `false` otherwise.
+        #
+        def in?
+          @gapi.mode == "IN"
+        end
+
+        ##
+        # Checks if the value of {#mode} is `OUT`. Can be set for procedures only. The default is `false`.
+        #
+        # @return [Boolean] `true` when `OUT`, `false` otherwise.
+        #
+        def out?
+          @gapi.mode == "OUT"
+        end
+
+        ##
+        # Checks if the value of {#mode} is `INOUT`. Can be set for procedures only. The default is `false`.
+        #
+        # @return [Boolean] `true` when `INOUT`, `false` otherwise.
+        #
+        def inout?
+          @gapi.mode == "INOUT"
+        end
+
+        ##
+        #
+        # The name of the argument. Optional. Can be absent for a function return argument.
+        #
+        # @return [String] The name of the argument.
+        #
+        def name
+          @gapi.name
+        end
+
+        ##
+        # @private
+        def to_gapi
+          @gapi
+        end
+
+        ##
+        # @private New Argument from a Google API Client object.
+        def self.from_gapi gapi
+          new.tap do |a|
+            a.instance_variable_set :@gapi, gapi
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -152,7 +152,7 @@ module Google
           #
           # @return [Google::Cloud::Bigquery::CopyJob::Updater] A job
           #   configuration object for setting copy options.
-          def self.from_options service, source, target, options = {}
+          def self.from_options service, source, target, options
             job_ref = service.job_ref_from options[:job_id], options[:prefix]
             copy_cfg = Google::Apis::BigqueryV2::JobConfigurationTableCopy.new(
               source_table:      source,
@@ -284,6 +284,23 @@ module Google
             @gapi.configuration.update! labels: value
           end
 
+          def cancel
+            raise "not implemented in #{self.class}"
+          end
+
+          def rerun!
+            raise "not implemented in #{self.class}"
+          end
+
+          def reload!
+            raise "not implemented in #{self.class}"
+          end
+          alias refresh! reload!
+
+          def wait_until_done!
+            raise "not implemented in #{self.class}"
+          end
+
           ##
           # @private Returns the Google API client library version of this job.
           #

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

@@ -316,6 +316,21 @@ module Google
           job_gapi&.statistics&.query&.ddl_operation_performed
         end
 
+        ##
+        # The DDL target routine, in reference state. (See {Routine#reference?}.)
+        # Present only for `CREATE/DROP FUNCTION/PROCEDURE` queries. (See
+        # {#statement_type}.)
+        #
+        # @return [Google::Cloud::Bigquery::Routine, nil] The DDL target routine, in
+        #   reference state.
+        #
+        def ddl_target_routine
+          ensure_service!
+          routine = job_gapi&.statistics&.query&.ddl_target_routine
+          return nil if routine.nil?
+          Google::Cloud::Bigquery::Routine.new_reference_from_gapi routine, service
+        end
+
         ##
         # The DDL target table, in reference state. (See {Table#reference?}.)
         # Present only for `CREATE/DROP TABLE/VIEW` queries. (See

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

@@ -18,6 +18,7 @@ require "google/cloud/errors"
 require "google/cloud/bigquery/service"
 require "google/cloud/bigquery/table"
 require "google/cloud/bigquery/model"
+require "google/cloud/bigquery/routine"
 require "google/cloud/bigquery/external"
 require "google/cloud/bigquery/dataset/list"
 require "google/cloud/bigquery/dataset/access"
@@ -554,6 +555,40 @@ module Google
         #     end
         #   end
         #
+        # @example With time partitioning and clustering.
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   table = dataset.create_table "my_table" do |t|
+        #     t.schema do |schema|
+        #       schema.timestamp "dob", mode: :required
+        #       schema.string "first_name", mode: :required
+        #       schema.string "last_name", mode: :required
+        #     end
+        #     t.time_partitioning_type  = "DAY"
+        #     t.time_partitioning_field = "dob"
+        #     t.clustering_fields = ["last_name", "first_name"]
+        #   end
+        #
+        # @example With range partitioning.
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   table = dataset.create_table "my_table" do |t|
+        #     t.schema do |schema|
+        #       schema.integer "my_table_id", mode: :required
+        #       schema.string "my_table_data", mode: :required
+        #     end
+        #     t.range_partitioning_field = "my_table_id"
+        #     t.range_partitioning_start = 0
+        #     t.range_partitioning_interval = 10
+        #     t.range_partitioning_end = 100
+        #   end
+        #
         # @!group Table
         #
         def create_table table_id, name: nil, description: nil
@@ -601,12 +636,20 @@ module Google
         #   SQL](https://cloud.google.com/bigquery/docs/reference/legacy-sql)
         #   dialect. Optional. The default value is false.
         # @param [Array<String>, String] udfs User-defined function resources
-        #   used in the query. May be either a code resource to load from a
-        #   Google Cloud Storage URI (`gs://bucket/path`), or an inline resource
+        #   used in a legacy SQL query. May be either a code resource to load from
+        #   a Google Cloud Storage URI (`gs://bucket/path`), or an inline resource
         #   that contains code for a user-defined function (UDF). Providing an
         #   inline code resource is equivalent to providing a URI for a file
-        #   containing the same code. See [User-Defined
-        #   Functions](https://cloud.google.com/bigquery/docs/reference/standard-sql/user-defined-functions).
+        #   containing the same code.
+        #
+        #   This parameter is used for defining User Defined Function (UDF)
+        #   resources only when using legacy SQL. Users of standard SQL should
+        #   leverage either DDL (e.g. `CREATE [TEMPORARY] FUNCTION ...`) or the
+        #   Routines API to define UDF resources.
+        #
+        #   For additional information on migrating, see: [Migrating to
+        #   standard SQL - Differences in user-defined JavaScript
+        #   functions](https://cloud.google.com/bigquery/docs/reference/standard-sql/migrating-from-legacy-sql#differences_in_user-defined_javascript_functions)
         #
         # @return [Google::Cloud::Bigquery::Table] A new table object.
         #
@@ -731,8 +774,7 @@ module Google
         #
         def tables token: nil, max: nil
           ensure_service!
-          options = { token: token, max: max }
-          gapi = service.list_tables dataset_id, options
+          gapi = service.list_tables dataset_id, token: token, max: max
           Table::List.from_gapi gapi, service, dataset_id, max
         end
 
@@ -817,6 +859,174 @@ module Google
           Model::List.from_gapi gapi, service, dataset_id, max
         end
 
+        ##
+        # Creates a new routine. The following attributes may be set in the yielded block:
+        # {Routine::Updater#routine_type=}, {Routine::Updater#language=}, {Routine::Updater#arguments=},
+        # {Routine::Updater#return_type=}, {Routine::Updater#imported_libraries=}, {Routine::Updater#body=}, and
+        # {Routine::Updater#description=}.
+        #
+        # @param [String] routine_id The ID of the routine. The ID must contain only
+        #   letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length
+        #   is 256 characters.
+        # @yield [routine] A block for setting properties on the routine.
+        # @yieldparam [Google::Cloud::Bigquery::Routine::Updater] routine An updater to set additional properties on the
+        #   routine.
+        #
+        # @return [Google::Cloud::Bigquery::Routine] A new routine object.
+        #
+        # @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.arguments = [
+        #       Google::Cloud::Bigquery::Argument.new(name: "x", data_type: "INT64")
+        #     ]
+        #     r.body = "x * 3"
+        #     r.description = "My routine description"
+        #   end
+        #
+        #   puts routine.routine_id
+        #
+        # @example Extended 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
+        #
+        # @!group Routine
+        #
+        def create_routine routine_id
+          ensure_service!
+          new_tb = Google::Apis::BigqueryV2::Routine.new(
+            routine_reference: Google::Apis::BigqueryV2::RoutineReference.new(
+              project_id: project_id, dataset_id: dataset_id, routine_id: routine_id
+            )
+          )
+          updater = Routine::Updater.new new_tb
+
+          yield updater if block_given?
+
+          gapi = service.insert_routine dataset_id, updater.to_gapi
+          Routine.from_gapi gapi, service
+        end
+
+        ##
+        # Retrieves an existing routine by ID.
+        #
+        # @param [String] routine_id The ID of a routine.
+        # @param [Boolean] skip_lookup Optionally create just a local reference
+        #   object without verifying that the resource exists on the BigQuery
+        #   service. Calls made on this object will raise errors if the resource
+        #   does not exist. Default is `false`. Optional.
+        #
+        # @return [Google::Cloud::Bigquery::Routine, nil] Returns `nil` if the
+        #   routine does not exist.
+        #
+        # @example
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   routine = dataset.routine "my_routine"
+        #   puts routine.routine_id
+        #
+        # @example Avoid retrieving the routine resource with `skip_lookup`:
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   routine = dataset.routine "my_routine", skip_lookup: true
+        #
+        # @!group Routine
+        #
+        def routine routine_id, skip_lookup: nil
+          ensure_service!
+          return Routine.new_reference project_id, dataset_id, routine_id, service if skip_lookup
+          gapi = service.get_routine dataset_id, routine_id
+          Routine.from_gapi gapi, service
+        rescue Google::Cloud::NotFoundError
+          nil
+        end
+
+        ##
+        # Retrieves the list of routines belonging to the dataset.
+        #
+        # @param [String] token A previously-returned page token representing
+        #   part of the larger set of results to view.
+        # @param [Integer] max Maximum number of routines to return.
+        # @param [String] filter If set, then only the routines matching this filter are returned. The current supported
+        #   form is `routineType:`, with a {Routine#routine_type} enum value. Example: `routineType:SCALAR_FUNCTION`.
+        #
+        # @return [Array<Google::Cloud::Bigquery::Routine>] An array of routines
+        #   (See {Google::Cloud::Bigquery::Routine::List})
+        #
+        # @example
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   routines = dataset.routines
+        #   routines.each do |routine|
+        #     puts routine.routine_id
+        #   end
+        #
+        # @example Retrieve all routines: (See {Routine::List#all})
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   routines = dataset.routines
+        #   routines.all do |routine|
+        #     puts routine.routine_id
+        #   end
+        #
+        # @!group Routine
+        #
+        def routines token: nil, max: nil, filter: nil
+          ensure_service!
+          gapi = service.list_routines dataset_id, token: token, max: max, filter: filter
+          Routine::List.from_gapi gapi, service, dataset_id, max, filter: filter
+        end
+
         ##
         # Queries data by creating a [query
         # job](https://cloud.google.com/bigquery/docs/query-overview#query_jobs).
@@ -969,12 +1179,20 @@ module Google
         #   list must have a different key. See [Requirements for
         #   labels](https://cloud.google.com/bigquery/docs/creating-managing-labels#requirements).
         # @param [Array<String>, String] udfs User-defined function resources
-        #   used in the query. May be either a code resource to load from a
-        #   Google Cloud Storage URI (`gs://bucket/path`), or an inline resource
+        #   used in a legacy SQL query. May be either a code resource to load from
+        #   a Google Cloud Storage URI (`gs://bucket/path`), or an inline resource
         #   that contains code for a user-defined function (UDF). Providing an
         #   inline code resource is equivalent to providing a URI for a file
-        #   containing the same code. See [User-Defined
-        #   Functions](https://cloud.google.com/bigquery/docs/reference/standard-sql/user-defined-functions).
+        #   containing the same code.
+        #
+        #   This parameter is used for defining User Defined Function (UDF)
+        #   resources only when using legacy SQL. Users of standard SQL should
+        #   leverage either DDL (e.g. `CREATE [TEMPORARY] FUNCTION ...`) or the
+        #   Routines API to define UDF resources.
+        #
+        #   For additional information on migrating, see: [Migrating to
+        #   standard SQL - Differences in user-defined JavaScript
+        #   functions](https://cloud.google.com/bigquery/docs/reference/standard-sql/migrating-from-legacy-sql#differences_in_user-defined_javascript_functions)
         # @param [Integer] maximum_billing_tier Deprecated: Change the billing
         #   tier to allow high-compute queries.
         # @yield [job] a job configuration object
@@ -1073,7 +1291,7 @@ module Google
         #
         #   job.wait_until_done!
         #   if !job.failed?
-        #     table_ref = job.ddl_target_table
+        #     table_ref = job.ddl_target_table # Or ddl_target_routine for CREATE/DROP FUNCTION/PROCEDURE
         #   end
         #
         # @example Execute a DML statement:
@@ -1321,7 +1539,7 @@ module Google
         #
         #   data = bigquery.query "CREATE TABLE my_table (x INT64)"
         #
-        #   table_ref = data.ddl_target_table
+        #   table_ref = data.ddl_target_table # Or ddl_target_routine for CREATE/DROP FUNCTION/PROCEDURE
         #
         # @example Execute a DML statement:
         #   require "google/cloud/bigquery"
@@ -1942,7 +2160,7 @@ module Google
         #   dataset = bigquery.dataset "my_dataset", skip_lookup: true
         #   dataset.exists? # true
         #
-        def exists? force: nil
+        def exists? force: false
           return gapi_exists? if force
           # If we have a memoized value, return it
           return @exists unless @exists.nil?
@@ -2052,7 +2270,7 @@ module Google
         end
 
         ##
-        # @private New lazy Dataset object without making an HTTP request.
+        # @private New lazy Dataset object without making an HTTP request, for use with the skip_lookup option.
         def self.new_reference project_id, dataset_id, service
           raise ArgumentError, "dataset_id is required" unless dataset_id
           new.tap do |b|
@@ -2083,12 +2301,13 @@ module Google
         # @param [String] table_id The ID of the destination table.
         # @param [Hash, Array<Hash>] rows A hash object or array of hash objects
         #   containing the data. Required.
-        # @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.
+        # @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.
         # @param [Boolean] skip_invalid Insert all valid rows of a request, even
         #   if invalid rows exist. The default value is `false`, which causes
         #   the entire request to fail if any invalid rows exist.
@@ -2099,6 +2318,12 @@ module Google
         #   a new table with the given `table_id`, if no table is found for
         #   `table_id`. The default value is false.
         #
+        # @yield [table] a block for setting the table
+        # @yieldparam [Google::Cloud::Bigquery::Table::Updater] table An updater
+        #   to set additional properties on the table in the API request to
+        #   create it. Only used when `autocreate` is set and the table does not
+        #   already exist.
+        #
         # @return [Google::Cloud::Bigquery::InsertResponse] An insert response
         #   object.
         #
@@ -2144,32 +2369,19 @@ module Google
         #
         # @!group Data
         #
-        def insert table_id, rows, insert_ids: nil, skip_invalid: nil, ignore_unknown: nil, autocreate: nil
+        def insert table_id, rows, insert_ids: nil, skip_invalid: nil, ignore_unknown: nil, autocreate: nil, &block
           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.positive? && insert_ids.count != rows.count
             raise ArgumentError, "insert_ids must be the same size as rows"
           end
 
           if autocreate
-            begin
-              insert_data table_id, rows,
-                          skip_invalid: skip_invalid, ignore_unknown: ignore_unknown, insert_ids: insert_ids
-            rescue Google::Cloud::NotFoundError
-              sleep rand(1..60)
-              begin
-                create_table table_id do |tbl_updater|
-                  yield tbl_updater if block_given?
-                end
-              # rubocop:disable Lint/HandleExceptions
-              rescue Google::Cloud::AlreadyExistsError
-              end
-              # rubocop:enable Lint/HandleExceptions
-
-              sleep 60
-              insert table_id, rows, skip_invalid: skip_invalid, ignore_unknown: ignore_unknown, autocreate: true,
-                                     insert_ids: insert_ids
-            end
+            insert_data_with_autocreate table_id, rows, skip_invalid: skip_invalid, ignore_unknown: ignore_unknown,
+                                                        insert_ids: insert_ids, &block
           else
             insert_data table_id, rows, skip_invalid: skip_invalid, ignore_unknown: ignore_unknown,
                                         insert_ids: insert_ids
@@ -2239,15 +2451,30 @@ module Google
 
         protected
 
-        def insert_data table_id, rows, skip_invalid: nil, ignore_unknown: nil,
-                        insert_ids: nil
+        def insert_data_with_autocreate table_id, rows, skip_invalid: nil, ignore_unknown: nil, insert_ids: nil
+          insert_data table_id, rows, skip_invalid: skip_invalid, ignore_unknown: ignore_unknown, insert_ids: insert_ids
+        rescue Google::Cloud::NotFoundError
+          sleep rand(1..60)
+          begin
+            create_table table_id do |tbl_updater|
+              yield tbl_updater if block_given?
+            end
+          # rubocop:disable Lint/HandleExceptions
+          rescue Google::Cloud::AlreadyExistsError
+          end
+          # rubocop:enable Lint/HandleExceptions
+
+          sleep 60
+          retry
+        end
+
+        def insert_data table_id, rows, skip_invalid: nil, ignore_unknown: nil, insert_ids: nil
           rows = [rows] if rows.is_a? Hash
           raise ArgumentError, "No rows provided" if rows.empty?
           ensure_service!
-          options = { skip_invalid:   skip_invalid,
-                      ignore_unknown: ignore_unknown,
-                      insert_ids:     insert_ids }
-          gapi = service.insert_tabledata dataset_id, table_id, rows, options
+          gapi = service.insert_tabledata dataset_id, table_id, rows, skip_invalid:   skip_invalid,
+                                                                      ignore_unknown: ignore_unknown,
+                                                                      insert_ids:     insert_ids
           InsertResponse.from_gapi rows, gapi
         end
 
@@ -2444,14 +2671,14 @@ module Google
         end
 
         ##
-        # Yielded to a block to accumulate changes for a patch request.
+        # Yielded to a block to accumulate changes for a create request. See {Project#create_dataset}.
         class Updater < Dataset
           ##
-          # A list of attributes that were updated.
+          # @private A list of attributes that were updated.
           attr_reader :updates
 
           ##
-          # Create an Updater object.
+          # @private Create an Updater object.
           def initialize gapi
             @updates = []
             @gapi = gapi
@@ -2468,8 +2695,109 @@ module Google
             @access
           end
 
+          # rubocop:disable Style/MethodDefParentheses
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def delete(*)
+            raise "not implemented in #{self.class}"
+          end
+
           ##
-          # Make sure any access changes are saved
+          # @raise [RuntimeError] not implemented
+          def create_table(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def create_view(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def table(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def tables(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def model(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def models(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def create_routine(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def routine(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def routines(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def query_job(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def query(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def external(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def load_job(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def load(*)
+            raise "not implemented in #{self.class}"
+          end
+
+          ##
+          # @raise [RuntimeError] not implemented
+          def reload!
+            raise "not implemented in #{self.class}"
+          end
+          alias refresh! reload!
+
+          # rubocop:enable Style/MethodDefParentheses
+
+          ##
+          # @private Make sure any access changes are saved
           def check_for_mutated_access!
             return if @access.nil?
             return unless @access.changed?
@@ -2477,6 +2805,8 @@ module Google
             patch_gapi! :access
           end
 
+          ##
+          # @private
           def to_gapi
             check_for_mutated_access!
             @gapi