google-cloud-bigquery 1.1.0 → 1.2.0

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

@@ -108,6 +108,9 @@ module Google
         # See [Data Types](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types)
         # for an overview of each BigQuery data type, including allowed values.
         #
+        # The geographic location for the job ("US", "EU", etc.) can be set via
+        # {QueryJob::Updater#location=} in a block passed to this method.
+        #
         # @param [String] query A query string, following the BigQuery [query
         #   syntax](https://cloud.google.com/bigquery/query-reference), of the
         #   query to execute. Example: "SELECT count(f1) FROM
@@ -178,11 +181,6 @@ module Google
         #   Flattens all nested and repeated fields in the query results. The
         #   default value is `true`. `large_results` parameter must be `true` if
         #   this is set to `false`.
-        # @param [Integer] maximum_billing_tier Limits the billing tier for this
-        #   job. Queries that have resource usage beyond this tier will fail
-        #   (without incurring a charge). Optional. If unspecified, this will be
-        #   set to your project default. For more information, see [High-Compute
-        #   queries](https://cloud.google.com/bigquery/pricing#high-compute).
         # @param [Integer] maximum_bytes_billed Limits the bytes billed for this
         #   job. Queries that will have bytes billed beyond this limit will fail
         #   (without incurring a charge). Optional. If unspecified, this will be
@@ -219,6 +217,11 @@ module Google
         #   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).
+        # @param [Integer] maximum_billing_tier Deprecated: Change the billing
+        #   tier to allow high-compute queries.
+        # @yield [job] a job configuration object
+        # @yieldparam [Google::Cloud::Bigquery::QueryJob::Updater] job a job
+        #   configuration object for setting query options.
         #
         # @return [Google::Cloud::Bigquery::QueryJob]
         #
@@ -243,7 +246,7 @@ module Google
         #   bigquery = Google::Cloud::Bigquery.new
         #
         #   job = bigquery.query_job "SELECT name FROM " \
-        #                            "[my_project:my_dataset.my_table]",
+        #                            " [my_project:my_dataset.my_table]",
         #                            legacy_sql: true
         #
         #   job.wait_until_done!
@@ -287,7 +290,7 @@ module Google
         #     end
         #   end
         #
-        # @example Query using external data source:
+        # @example Query using external data source, set destination:
         #   require "google/cloud/bigquery"
         #
         #   bigquery = Google::Cloud::Bigquery.new
@@ -298,8 +301,11 @@ module Google
         #     csv.skip_leading_rows = 1
         #   end
         #
-        #   job = bigquery.query_job "SELECT * FROM my_ext_table",
-        #                            external: { my_ext_table: csv_table }
+        #   job = bigquery.query_job "SELECT * FROM my_ext_table" do |query|
+        #     query.external = { my_ext_table: csv_table }
+        #     dataset = bigquery.dataset "my_dataset", skip_lookup: true
+        #     query.table = dataset.table "my_table", skip_lookup: true
+        #   end
         #
         #   job.wait_until_done!
         #   if !job.failed?
@@ -319,13 +325,18 @@ module Google
           options = { priority: priority, cache: cache, table: table,
                       create: create, write: write,
                       large_results: large_results, flatten: flatten,
-                      dataset: dataset, project: project,
+                      dataset: dataset, project: (project || self.project),
                       legacy_sql: legacy_sql, standard_sql: standard_sql,
                       maximum_billing_tier: maximum_billing_tier,
                       maximum_bytes_billed: maximum_bytes_billed,
-                      params: params, external: external, labels: labels,
-                      job_id: job_id, prefix: prefix, udfs: udfs }
-          gapi = service.query_job query, options
+                      external: external, job_id: job_id, prefix: prefix,
+                      labels: labels, udfs: udfs, params: params }
+
+          updater = QueryJob::Updater.from_options service, query, options
+
+          yield updater if block_given?
+
+          gapi = service.query_job updater.to_gapi
           Job.from_gapi gapi, service
         end
 
@@ -355,6 +366,9 @@ module Google
         # See [Data Types](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types)
         # for an overview of each BigQuery data type, including allowed values.
         #
+        # The geographic location for the job ("US", "EU", etc.) can be set via
+        # {QueryJob::Updater#location=} in a block passed to this method.
+        #
         # @see https://cloud.google.com/bigquery/querying-data Querying Data
         #
         # @param [String] query A query string, following the BigQuery [query
@@ -409,6 +423,9 @@ module Google
         #   When set to false, the values of `large_results` and `flatten` are
         #   ignored; the query will be run as if `large_results` is true and
         #   `flatten` is false. Optional. The default value is false.
+        # @yield [job] a job configuration object
+        # @yieldparam [Google::Cloud::Bigquery::QueryJob::Updater] job a job
+        #   configuration object for setting additional options for the query.
         #
         # @return [Google::Cloud::Bigquery::Data]
         #
@@ -475,7 +492,7 @@ module Google
         #     puts row[:name]
         #   end
         #
-        # @example Query using external data source:
+        # @example Query using external data source, set destination:
         #   require "google/cloud/bigquery"
         #
         #   bigquery = Google::Cloud::Bigquery.new
@@ -486,8 +503,11 @@ module Google
         #     csv.skip_leading_rows = 1
         #   end
         #
-        #   data = bigquery.query "SELECT * FROM my_ext_table",
-        #                         external: { my_ext_table: csv_table }
+        #   data = bigquery.query "SELECT * FROM my_ext_table" do |query|
+        #     query.external = { my_ext_table: csv_table }
+        #     dataset = bigquery.dataset "my_dataset", skip_lookup: true
+        #     query.table = dataset.table "my_table", skip_lookup: true
+        #   end
         #
         #   data.each do |row|
         #     puts row[:name]
@@ -496,11 +516,16 @@ module Google
         def query query, params: nil, external: nil, max: nil, cache: true,
                   dataset: nil, project: nil, standard_sql: nil, legacy_sql: nil
           ensure_service!
-          options = { cache: cache, dataset: dataset, project: project,
+          options = { priority: "INTERACTIVE", cache: cache, dataset: dataset,
+                      project: project || self.project,
                       legacy_sql: legacy_sql, standard_sql: standard_sql,
                       params: params, external: external }
+          updater = QueryJob::Updater.from_options service, query, options
+
+          yield updater if block_given?
 
-          job = query_job query, options
+          gapi = service.query_job updater.to_gapi
+          job = Job.from_gapi gapi, service
           job.wait_until_done!
 
           if job.failed?
@@ -734,6 +759,8 @@ module Google
         # Retrieves an existing job by ID.
         #
         # @param [String] job_id The ID of a job.
+        # @param [String] location The geographic location where the job was
+        #   created. Required except for US and EU.
         #
         # @return [Google::Cloud::Bigquery::Job, nil] Returns `nil` if the job
         #   does not exist.
@@ -745,9 +772,9 @@ module Google
         #
         #   job = bigquery.job "my_job"
         #
-        def job job_id
+        def job job_id, location: nil
           ensure_service!
-          gapi = service.get_job job_id
+          gapi = service.get_job job_id, location: location
           Job.from_gapi gapi, service
         rescue Google::Cloud::NotFoundError
           nil
@@ -941,6 +968,77 @@ module Google
           s
         end
 
+        ##
+        # Creates a new Bigquery::EncryptionConfiguration instance.
+        #
+        # This method does not execute an API call. Use the encryption
+        # configuration to encrypt a table when creating one via
+        # Bigquery::Dataset#create_table, Bigquery::Dataset#load,
+        # Bigquery::Table#copy, or Bigquery::Project#query.
+        #
+        # @param [String] kms_key Name of the Cloud KMS encryption key that
+        #   will be used to protect the destination BigQuery table. The BigQuery
+        #   Service Account associated with your project requires access to this
+        #   encryption key.
+        #
+        # @example Encrypt a new table
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
+        #   encrypt_config = bigquery.encryption kms_key: key_name
+        #
+        #   table = dataset.create_table "my_table" do |updater|
+        #     updater.encryption = encrypt_config
+        #   end
+        #
+        # @example Encrypt a load destination table
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
+        #   encrypt_config = bigquery.encryption kms_key: key_name
+        #   job = dataset.load_job "my_table", "gs://abc/file" do |job|
+        #     job.encryption = encrypt_config
+        #   end
+        #
+        # @example Encrypt a copy destination table
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #   table = dataset.table "my_table"
+        #
+        #   key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
+        #   encrypt_config = bigquery.encryption kms_key: key_name
+        #   job = table.copy_job "my_dataset.new_table" do |job|
+        #     job.encryption = encrypt_config
+        #   end
+        #
+        # @example Encrypt a query destination table
+        #   require "google/cloud/bigquery"
+        #
+        #   bigquery = Google::Cloud::Bigquery.new
+        #   dataset = bigquery.dataset "my_dataset"
+        #
+        #   key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
+        #   encrypt_config = bigquery.encryption kms_key: key_name
+        #   job = bigquery.query_job "SELECT 1;" do |query|
+        #     query.table = dataset.table "my_table", skip_lookup: true
+        #     query.encryption = encrypt_config
+        #   end
+        #
+        # @return [Google::Cloud::Bigquery::EncryptionConfiguration]
+        def encryption kms_key: nil
+          encrypt_config = Bigquery::EncryptionConfiguration.new
+          encrypt_config.kms_key = kms_key unless kms_key.nil?
+          encrypt_config
+        end
+
         ##
         # @private New Project from a Google API Client object, using the
         # same Credentials as this project.

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

@@ -15,6 +15,8 @@
 
 require "google/cloud/bigquery/service"
 require "google/cloud/bigquery/data"
+require "google/cloud/bigquery/encryption_configuration"
+require "google/apis/bigquery_v2"
 
 module Google
   module Cloud
@@ -244,6 +246,19 @@ module Google
           end
         end
 
+        ##
+        # The encryption configuration of the destination table.
+        #
+        # @return [Google::Cloud::BigQuery::EncryptionConfiguration] Custom
+        #   encryption configuration (e.g., Cloud KMS keys).
+        #
+        # @!group Attributes
+        def encryption
+          EncryptionConfiguration.from_gapi(
+            @gapi.configuration.query.destination_encryption_configuration
+          )
+        end
+
         ##
         # Refreshes the job until the job is `DONE`.
         # The delay between refreshes will incrementally increase.
@@ -264,7 +279,8 @@ module Google
 
           ensure_service!
           loop do
-            query_results_gapi = service.job_query_results job_id, max: 0
+            query_results_gapi = service.job_query_results \
+              job_id, location: location, max: 0
             if query_results_gapi.job_complete
               @destination_schema_gapi = query_results_gapi.schema
               break
@@ -313,6 +329,390 @@ module Google
         end
         alias query_results data
 
+        ##
+        # Yielded to a block to accumulate changes for a patch request.
+        class Updater < QueryJob
+          ##
+          # @private Create an Updater object.
+          def initialize service, gapi
+            @service = service
+            @gapi = gapi
+          end
+
+          # rubocop:disable all
+
+          ##
+          # @private Create an Updater from an options hash.
+          #
+          # @return [Google::Cloud::Bigquery::QueryJob::Updater] A job
+          #   configuration object for setting query options.
+          def self.from_options service, query, options
+            job_ref = service.job_ref_from options[:job_id], options[:prefix]
+            dataset_config = service.dataset_ref_from options[:dataset],
+                                                      options[:project]
+            req = Google::Apis::BigqueryV2::Job.new(
+              job_reference: job_ref,
+              configuration: Google::Apis::BigqueryV2::JobConfiguration.new(
+                query: Google::Apis::BigqueryV2::JobConfigurationQuery.new(
+                  query: query,
+                  default_dataset: dataset_config,
+                  maximum_billing_tier: options[:maximum_billing_tier]
+                )
+              )
+            )
+
+            updater = QueryJob::Updater.new service, req
+            updater.params = options[:params] if options[:params]
+            updater.create = options[:create]
+            updater.write = options[:write]
+            updater.table = options[:table]
+            updater.maximum_bytes_billed = options[:maximum_bytes_billed]
+            updater.labels = options[:labels] if options[:labels]
+            updater.legacy_sql = Convert.resolve_legacy_sql(
+              options[:standard_sql], options[:legacy_sql])
+            updater.external = options[:external] if options[:external]
+            updater.priority = options[:priority]
+            updater.cache = options[:cache]
+            updater.large_results = options[:large_results]
+            updater.flatten = options[:flatten]
+            updater.udfs = options[:udfs]
+            updater
+          end
+
+          # rubocop:enable all
+
+          ##
+          # Sets the geographic location where the job should run. Required
+          # except for US and EU.
+          #
+          # @param [String] value  A geographic location, such as "US", "EU" or
+          #   "asia-northeast1". Required except for US and EU.
+          #
+          # @example
+          #   require "google/cloud/bigquery"
+          #
+          #   bigquery = Google::Cloud::Bigquery.new
+          #   dataset = bigquery.dataset "my_dataset"
+          #
+          #   job = bigquery.query_job "SELECT 1;" do |query|
+          #     query.table = dataset.table "my_table", skip_lookup: true
+          #     query.location = "EU"
+          #   end
+          #
+          # @!group Attributes
+          def location= value
+            @gapi.job_reference.location = value
+          end
+
+          ##
+          # Sets the priority of the query.
+          #
+          # @param [String] value Specifies a priority for the query. Possible
+          #   values include `INTERACTIVE` and `BATCH`.
+          #
+          # @!group Attributes
+          def priority= value
+            @gapi.configuration.query.priority = priority_value value
+          end
+
+          ##
+          # Specifies to look in the query cache for results.
+          #
+          # @param [Boolean] value Whether to look for the result in the query
+          #   cache. The query cache is a best-effort cache that will be flushed
+          #   whenever tables in the query are modified. The default value is
+          #   true. For more information, see [query
+          #   caching](https://developers.google.com/bigquery/querying-data).
+          #
+          # @!group Attributes
+          def cache= value
+            @gapi.configuration.query.use_query_cache = value
+          end
+
+          ##
+          # Allow large results for a legacy SQL query.
+          #
+          # @param [Boolean] value This option is specific to Legacy SQL.
+          #   If `true`, allows the query to produce arbitrarily large result
+          #   tables at a slight cost in performance. Requires `table` parameter
+          #   to be set.
+          #
+          # @!group Attributes
+          def large_results= value
+            @gapi.configuration.query.allow_large_results = value
+          end
+
+          ##
+          # Flatten nested and repeated fields in legacy SQL queries.
+          #
+          # @param [Boolean] value This option is specific to Legacy SQL.
+          #   Flattens all nested and repeated fields in the query results. The
+          #   default value is `true`. `large_results` parameter must be `true`
+          #   if this is set to `false`.
+          #
+          # @!group Attributes
+          def flatten= value
+            @gapi.configuration.query.flatten_results = value
+          end
+
+          ##
+          # Sets the default dataset of tables referenced in the query.
+          #
+          # @param [Dataset] value The default dataset to use for unqualified
+          #   table names in the query.
+          #
+          # @!group Attributes
+          def dataset= value
+            @gapi.configuration.query.default_dataset =
+              @service.dataset_ref_from value
+          end
+
+          ##
+          # Sets the query parameters. Standard SQL only.
+          #
+          # @param [Array, Hash] params Used to pass query arguments when the
+          #   `query` string contains either positional (`?`) or named
+          #   (`@myparam`) query parameters. If value passed is an array
+          #   `["foo"]`, the query must use positional query parameters. If
+          #   value passed is a hash `{ myparam: "foo" }`, the query must use
+          #   named query parameters. When set, `legacy_sql` will automatically
+          #   be set to false and `standard_sql` to true.
+          #
+          # @!group Attributes
+          def params= params
+            case params
+            when Array then
+              @gapi.configuration.query.use_legacy_sql = false
+              @gapi.configuration.query.parameter_mode = "POSITIONAL"
+              @gapi.configuration.query.query_parameters = params.map do |param|
+                Convert.to_query_param param
+              end
+            when Hash then
+              @gapi.configuration.query.use_legacy_sql = false
+              @gapi.configuration.query.parameter_mode = "NAMED"
+              @gapi.configuration.query.query_parameters =
+                params.map do |name, param|
+                  Convert.to_query_param(param).tap do |named_param|
+                    named_param.name = String name
+                  end
+                end
+            else
+              raise "Query parameters must be an Array or a Hash."
+            end
+          end
+
+          ##
+          # Sets the create disposition for creating the query results table.
+          #
+          # @param [String] value Specifies whether the job is allowed to
+          # create new tables. The default value is `needed`.
+          #
+          #   The following values are supported:
+          #
+          #   * `needed` - Create the table if it does not exist.
+          #   * `never` - The table must already exist. A 'notFound' error is
+          #     raised if the table does not exist.
+          #
+          # @!group Attributes
+          def create= value
+            @gapi.configuration.query.create_disposition =
+              Convert.create_disposition value
+          end
+
+          ##
+          # Sets the write disposition for when the query results table exists.
+          #
+          # @param [String] value Specifies the action that occurs if the
+          #   destination table already exists. The default value is `empty`.
+          #
+          #   The following values are supported:
+          #
+          #   * `truncate` - BigQuery overwrites the table data.
+          #   * `append` - BigQuery appends the data to the table.
+          #   * `empty` - A 'duplicate' error is returned in the job result if
+          #     the table exists and contains data.
+          #
+          # @!group Attributes
+          def write= value
+            @gapi.configuration.query.write_disposition =
+              Convert.write_disposition value
+          end
+
+          ##
+          # Sets the destination for the query results table.
+          #
+          # @param [Table] value The destination table where the query results
+          #   should be stored. If not present, a new table will be created
+          #   according to the create disposition to store the results.
+          #
+          # @!group Attributes
+          def table= value
+            @gapi.configuration.query.destination_table = table_ref_from value
+          end
+
+          ##
+          # Sets the maximum bytes billed for the query.
+          #
+          # @param [Integer] value Limits the bytes billed for this job.
+          #   Queries that will have bytes billed beyond this limit will fail
+          #   (without incurring a charge). Optional. If unspecified, this will
+          #   be set to your project default.
+          #
+          # @!group Attributes
+          def maximum_bytes_billed= value
+            @gapi.configuration.query.maximum_bytes_billed = value
+          end
+
+          ##
+          # Sets the labels to use for the job.
+          #
+          # @param [Hash] value A hash of user-provided labels associated with
+          #   the job. You can use these to organize and group your jobs. Label
+          #   keys and values can be no longer than 63 characters, can only
+          #   contain lowercase letters, numeric characters, underscores and
+          #   dashes. International characters are allowed. Label values are
+          #   optional. Label keys must start with a letter and each label in
+          #   the list must have a different key.
+          #
+          # @!group Attributes
+          #
+          def labels= value
+            @gapi.configuration.update! labels: value
+          end
+
+          ##
+          # Sets the query syntax to legacy SQL.
+          #
+          # @param [Boolean] value Specifies whether to use BigQuery's [legacy
+          #   SQL](https://cloud.google.com/bigquery/docs/reference/legacy-sql)
+          #   dialect for this query. If set to false, the query will use
+          #   BigQuery's [standard
+          #   SQL](https://cloud.google.com/bigquery/docs/reference/standard-sql/)
+          #   dialect. Optional. The default value is false.
+          #
+          # @!group Attributes
+          #
+          def legacy_sql= value
+            @gapi.configuration.query.use_legacy_sql = value
+          end
+
+          ##
+          # Sets the query syntax to standard SQL.
+          #
+          # @param [Boolean] value Specifies whether to use BigQuery's [standard
+          #   SQL](https://cloud.google.com/bigquery/docs/reference/standard-sql/)
+          #   dialect for this query. If set to true, the query will use
+          #   standard SQL rather than the [legacy
+          #   SQL](https://cloud.google.com/bigquery/docs/reference/legacy-sql)
+          #   dialect. Optional. The default value is true.
+          #
+          # @!group Attributes
+          #
+          def standard_sql= value
+            @gapi.configuration.query.use_legacy_sql = !value
+          end
+
+          ##
+          # Sets definitions for external tables used in the query.
+          #
+          # @param [Hash<String|Symbol, External::DataSource>] value A Hash
+          #   that represents the mapping of the external tables to the table
+          #   names used in the SQL query. The hash keys are the table names,
+          #   and the hash values are the external table objects.
+          #
+          # @!group Attributes
+          #
+          def external= value
+            external_table_pairs = value.map do |name, obj|
+              [String(name), obj.to_gapi]
+            end
+            external_table_hash = Hash[external_table_pairs]
+            @gapi.configuration.query.table_definitions = external_table_hash
+          end
+
+          ##
+          # Sets user defined functions for the query.
+          #
+          # @param [Array<String>, String] value 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 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).
+          #
+          # @!group Attributes
+          def udfs= value
+            @gapi.configuration.query.user_defined_function_resources =
+              udfs_gapi_from value
+          end
+
+          ##
+          # Sets the encryption configuration of the destination table.
+          #
+          # @param [Google::Cloud::BigQuery::EncryptionConfiguration] val
+          #   Custom encryption configuration (e.g., Cloud KMS keys).
+          #
+          # @example
+          #   require "google/cloud/bigquery"
+          #
+          #   bigquery = Google::Cloud::Bigquery.new
+          #   dataset = bigquery.dataset "my_dataset"
+          #
+          #   key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
+          #   encrypt_config = bigquery.encryption kms_key: key_name
+          #   job = bigquery.query_job "SELECT 1;" do |query|
+          #     query.table = dataset.table "my_table", skip_lookup: true
+          #     query.encryption = encrypt_config
+          #   end
+          #
+          # @!group Attributes
+          def encryption= val
+            @gapi.configuration.query.update!(
+              destination_encryption_configuration: val.to_gapi
+            )
+          end
+
+          ##
+          # @private Returns the Google API client library version of this job.
+          #
+          # @return [<Google::Apis::BigqueryV2::Job>] (See
+          #   {Google::Apis::BigqueryV2::Job})
+          def to_gapi
+            @gapi
+          end
+
+          protected
+
+          # Creates a table reference from a table object.
+          def table_ref_from tbl
+            return nil if tbl.nil?
+            Google::Apis::BigqueryV2::TableReference.new(
+              project_id: tbl.project_id,
+              dataset_id: tbl.dataset_id,
+              table_id: tbl.table_id
+            )
+          end
+
+          def priority_value str
+            { "batch" => "BATCH",
+              "interactive" => "INTERACTIVE" }[str.to_s.downcase]
+          end
+
+          def udfs_gapi_from array_or_str
+            Array(array_or_str).map do |uri_or_code|
+              resource =
+                Google::Apis::BigqueryV2::UserDefinedFunctionResource.new
+              if uri_or_code.start_with?("gs://")
+                resource.resource_uri = uri_or_code
+              else
+                resource.inline_code = uri_or_code
+              end
+              resource
+            end
+          end
+        end
+
         ##
         # Represents a stage in the execution plan for the query.
         #
@@ -452,7 +852,8 @@ module Google
         def ensure_schema!
           return unless destination_schema.nil?
 
-          query_results_gapi = service.job_query_results job_id, max: 0
+          query_results_gapi = service.job_query_results \
+            job_id, location: location, max: 0
           # raise "unable to retrieve schema" if query_results_gapi.schema.nil?
           @destination_schema_gapi = query_results_gapi.schema
         end