Api-roll 42: 2016-11-08

generated/googleapis/lib/bigquery/v2.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.bigquery.v2;
 
 import 'dart:core' as core;
 import 'dart:collection' as collection;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
@@ skipping 194 matching lines @@
    * Lists all datasets in the specified project to which you have been granted
    * the READER dataset role.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the datasets to be listed
    *
    * [all] - Whether to list all datasets, including hidden ones
    *
    * [filter] - An expression for filtering the results of the request by label.
-   * The syntax is "labels.[:]". Multiple filters can be ANDed together by
-   * connecting with a space. Example: "labels.department:receiving
-   * labels.active". See
-   * https://cloud.google.com/bigquery/docs/labeling-datasets#filtering_datasets_using_labels
-   * for details.
+   * The syntax is "labels.<name>[:<value>]". Multiple filters can be ANDed
+   * together by connecting with a space. Example: "labels.department:receiving
+   * labels.active". See Filtering datasets using labels for details.
    *
    * [maxResults] - The maximum number of results to return
    *
    * [pageToken] - Page token, returned by a previous call, to request the next
    * page of results
    *
    * Completes with a [DatasetList].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
@@ skipping 176 matching lines @@
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
 
-    _url = 'project/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/cancel';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/cancel';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new JobCancelResponse.fromJson(data));
   }
@@ skipping 1252 matching lines @@
    * projectId:datasetId. The dataset name without the project name is given in
    * the datasetId field. When creating a new dataset, leave this field blank,
    * and instead specify the datasetId field.
    */
   core.String id;
   /** [Output-only] The resource type. */
   core.String kind;
   /**
    * [Experimental] The labels associated with this dataset. You can use these
    * to organize and group your datasets. You can set this property when
-   * inserting or updating a dataset. Label keys and values can be no longer
-   * than 63 characters, can only contain letters, numeric characters,
-   * underscores and dashes. International characters are allowed. Label values
-   * are optional. Label keys must start with a letter and must be unique within
-   * a dataset. Both keys and values are additionally constrained to be <= 128
-   * bytes in size.
+   * inserting or updating a dataset. See Labeling Datasets for more
+   * information.
    */
   core.Map<core.String, core.String> labels;
   /**
    * [Output-only] The date when this dataset or any of its tables was last
    * modified, in milliseconds since the epoch.
    */
   core.String lastModifiedTime;
   /**
    * [Experimental] The geographic location where the dataset should reside.
    * Possible values include EU and US. The default value is US.
@@ skipping 882 matching lines @@
   JobConfigurationTableCopy copy;
   /**
    * [Optional] If set, don't actually run this job. A valid query will return a
    * mostly empty response with some processing statistics, while an invalid
    * query will return the same error it would if it wasn't a dry run. Behavior
    * of non-query jobs is undefined.
    */
   core.bool dryRun;
   /** [Pick one] Configures an extract job. */
   JobConfigurationExtract extract;
+  /**
+   * [Experimental] The labels associated with this 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 letters, numeric characters, underscores
+   * and dashes. International characters are allowed. Label values are
+   * optional. Label keys must start with a letter and must be unique within a
+   * dataset. Both keys and values are additionally constrained to be <= 128
+   * bytes in size.
+   */
+  core.Map<core.String, core.String> labels;
   /** [Pick one] Configures a load job. */
   JobConfigurationLoad load;
   /** [Pick one] Configures a query job. */
   JobConfigurationQuery query;
 
   JobConfiguration();
 
   JobConfiguration.fromJson(core.Map _json) {
     if (_json.containsKey("copy")) {
       copy = new JobConfigurationTableCopy.fromJson(_json["copy"]);
     }
     if (_json.containsKey("dryRun")) {
       dryRun = _json["dryRun"];
     }
     if (_json.containsKey("extract")) {
       extract = new JobConfigurationExtract.fromJson(_json["extract"]);
     }
+    if (_json.containsKey("labels")) {
+      labels = _json["labels"];
+    }
     if (_json.containsKey("load")) {
       load = new JobConfigurationLoad.fromJson(_json["load"]);
     }
     if (_json.containsKey("query")) {
       query = new JobConfigurationQuery.fromJson(_json["query"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (copy != null) {
       _json["copy"] = (copy).toJson();
     }
     if (dryRun != null) {
       _json["dryRun"] = dryRun;
     }
     if (extract != null) {
       _json["extract"] = (extract).toJson();
     }
+    if (labels != null) {
+      _json["labels"] = labels;
+    }
     if (load != null) {
       _json["load"] = (load).toJson();
     }
     if (query != null) {
       _json["query"] = (query).toJson();
     }
     return _json;
   }
 }
 
@@ skipping 402 matching lines @@
   core.String parameterMode;
   /** [Deprecated] This property is deprecated. */
   core.bool preserveNulls;
   /**
    * [Optional] Specifies a priority for the query. Possible values include
    * INTERACTIVE and BATCH. The default value is INTERACTIVE.
    */
   core.String priority;
   /** [Required] BigQuery SQL query to execute. */
   core.String query;
-  /** [Experimental] Query parameters for Standard SQL queries. */
+  /** Query parameters for standard SQL queries. */
   core.List<QueryParameter> queryParameters;
   /**
-   * [Experimental] Allows the schema of the desitination table to be updated as
+   * [Experimental] Allows the schema of the destination table to be updated as
    * a side effect of the query job. Schema update options are supported in two
    * cases: when writeDisposition is WRITE_APPEND; when writeDisposition is
    * WRITE_TRUNCATE and the destination table is a partition of a table,
    * specified by partition decorators. For normal tables, WRITE_TRUNCATE will
    * always overwrite the schema. One or more of the following values are
    * specified: ALLOW_FIELD_ADDITION: allow adding a nullable field to the
    * schema. ALLOW_FIELD_RELAXATION: allow relaxing a required field in the
    * original schema to nullable.
    */
   core.List<core.String> schemaUpdateOptions;
   /**
    * [Optional] If querying an external data source outside of BigQuery,
    * describes the data format, location and other properties of the data
    * source. By defining these properties, the data source can then be queried
    * as if it were a standard BigQuery table.
    */
   core.Map<core.String, ExternalDataConfiguration> tableDefinitions;
   /**
-   * [Experimental] Specifies whether to use BigQuery's legacy SQL dialect for
-   * this query. The default value is true. If set to false, the query will use
-   * BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/
-   * When useLegacySql is set to false, the values of allowLargeResults and
+   * Specifies whether to use BigQuery's legacy SQL dialect for this query. The
+   * default value is true. If set to false, the query will use BigQuery's
+   * standard SQL: https://cloud.google.com/bigquery/sql-reference/ When
+   * useLegacySql is set to false, the values of allowLargeResults and
    * flattenResults are ignored; query will be run as if allowLargeResults is
    * true and flattenResults is false.
    */
   core.bool useLegacySql;
   /**
    * [Optional] 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. Moreover, the query cache is only available when a
    * query does not have a destination table specified. The default value is
    * true.
@@ skipping 959 matching lines @@
   }
 }
 
 class QueryParameterValue {
   /** [Optional] The array values, if this is an array type. */
   core.List<QueryParameterValue> arrayValues;
   /**
    * [Optional] The struct field values, in order of the struct type's
    * declaration.
    */
-  core.List<QueryParameterValue> structValues;
+  core.Map<core.String, QueryParameterValue> structValues;
   /** [Optional] The value of this value, if a simple scalar type. */
   core.String value;
 
   QueryParameterValue();
 
   QueryParameterValue.fromJson(core.Map _json) {
     if (_json.containsKey("arrayValues")) {
       arrayValues = _json["arrayValues"].map((value) => new QueryParameterValue.fromJson(value)).toList();
     }
     if (_json.containsKey("structValues")) {
-      structValues = _json["structValues"].map((value) => new QueryParameterValue.fromJson(value)).toList();
+      structValues = commons.mapMap(_json["structValues"], (item) => new QueryParameterValue.fromJson(item));
     }
     if (_json.containsKey("value")) {
       value = _json["value"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (arrayValues != null) {
       _json["arrayValues"] = arrayValues.map((value) => (value).toJson()).toList();
     }
     if (structValues != null) {
-      _json["structValues"] = structValues.map((value) => (value).toJson()).toList();
+      _json["structValues"] = commons.mapMap(structValues, (item) => (item).toJson());
     }
     if (value != null) {
       _json["value"] = value;
     }
     return _json;
   }
 }
 
 class QueryRequest {
   /**
@@ skipping 38 matching lines @@
    * [Optional] How long to wait for the query to complete, in milliseconds,
    * before the request times out and returns. Note that this is only a timeout
    * for the request, not the query. If the query takes longer to run than the
    * timeout value, the call returns without any results and with the
    * 'jobComplete' flag set to false. You can call GetQueryResults() to wait for
    * the query to complete and read the results. The default value is 10000
    * milliseconds (10 seconds).
    */
   core.int timeoutMs;
   /**
-   * [Experimental] Specifies whether to use BigQuery's legacy SQL dialect for
-   * this query. The default value is true. If set to false, the query will use
-   * BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/
-   * When useLegacySql is set to false, the values of allowLargeResults and
+   * Specifies whether to use BigQuery's legacy SQL dialect for this query. The
+   * default value is true. If set to false, the query will use BigQuery's
+   * standard SQL: https://cloud.google.com/bigquery/sql-reference/ When
+   * useLegacySql is set to false, the values of allowLargeResults and
    * flattenResults are ignored; query will be run as if allowLargeResults is
    * true and flattenResults is false.
    */
   core.bool useLegacySql;
   /**
    * [Optional] 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.
    */
   core.bool useQueryCache;
@@ skipping 725 matching lines @@
    */
   core.String mode;
   /**
    * [Required] The field name. The name must contain only letters (a-z, A-Z),
    * numbers (0-9), or underscores (_), and must start with a letter or
    * underscore. The maximum length is 128 characters.
    */
   core.String name;
   /**
    * [Required] The field data type. Possible values include STRING, BYTES,
-   * INTEGER, FLOAT, BOOLEAN, TIMESTAMP or RECORD (where RECORD indicates that
-   * the field contains a nested schema).
+   * INTEGER, FLOAT, BOOLEAN, TIMESTAMP, DATE, TIME, DATETIME, or RECORD (where
+   * RECORD indicates that the field contains a nested schema).
    */
   core.String type;
 
   TableFieldSchema();
 
   TableFieldSchema.fromJson(core.Map _json) {
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("fields")) {
@@ skipping 291 matching lines @@
       _json["resourceUri"] = resourceUri;
     }
     return _json;
   }
 }
 
 class ViewDefinition {
   /** [Required] A query that BigQuery executes when the view is referenced. */
   core.String query;
   /**
-   * [Experimental] Specifies whether to use BigQuery's legacy SQL for this
-   * view. The default value is true. If set to false, the view will use
-   * BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/
-   * Queries and views that reference this view must use the same flag value.
+   * Specifies whether to use BigQuery's legacy SQL for this view. The default
+   * value is true. If set to false, the view will use BigQuery's standard SQL:
+   * https://cloud.google.com/bigquery/sql-reference/ Queries and views that
+   * reference this view must use the same flag value.
    */
   core.bool useLegacySql;
   /**
    * [Experimental] Describes user-defined function resources used in the query.
    */
   core.List<UserDefinedFunctionResource> userDefinedFunctionResources;
 
   ViewDefinition();
 
   ViewDefinition.fromJson(core.Map _json) {
@@ skipping 15 matching lines @@
     }
     if (useLegacySql != null) {
       _json["useLegacySql"] = useLegacySql;
     }
     if (userDefinedFunctionResources != null) {
       _json["userDefinedFunctionResources"] = userDefinedFunctionResources.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }