Api-roll 33: 2016-03-14

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;
+import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
 
 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
     ApiRequestError, DetailedApiRequestError, Media, UploadOptions,
     ResumableUploadOptions, DownloadOptions, PartialDownloadOptions,
     ByteRange;
 
 const core.String USER_AGENT = 'dart-api-client bigquery/v2';
 
 /** A data platform for customers to create, manage, share and query data. */
@@ skipping 1193 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Table.fromJson(data));
   }
 
 }
 
 
 
+class BigtableColumn {
+  /**
+   * [Optional] The encoding of the values when the type is not STRING.
+   * Acceptable encoding values are: TEXT - indicates values are alphanumeric
+   * text strings. BINARY - indicates values are encoded using HBase
+   * Bytes.toBytes family of functions. 'encoding' can also be set at the column
+   * family level. However, the setting at this level takes precedence if
+   * 'encoding' is set at both levels.
+   */
+  core.String encoding;
+  /**
+   * [Optional] If the qualifier is not a valid BigQuery field identifier i.e.
+   * does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided
+   * as the column field name and is used as field name in queries.
+   */
+  core.String fieldName;
+  /**
+   * [Optional] If this is set, only the latest version of value in this column
+   * are exposed. 'onlyReadLatest' can also be set at the column family level.
+   * However, the setting at this level takes precedence if 'onlyReadLatest' is
+   * set at both levels.
+   */
+  core.bool onlyReadLatest;
+  /**
+   * [Required] Qualifier of the column. Columns in the parent column family
+   * that has this exact qualifier are exposed as . field. If the qualifier is
+   * valid UTF-8 string, it can be specified in the qualifier_string field.
+   * Otherwise, a base-64 encoded value must be set to qualifier_encoded. The
+   * column field name is the same as the column qualifier. However, if the
+   * qualifier is not a valid BigQuery field identifier i.e. does not match
+   * [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as field_name.
+   */
+  core.String qualifierEncoded;
+  core.List<core.int> get qualifierEncodedAsBytes {
+    return crypto.CryptoUtils.base64StringToBytes(qualifierEncoded);
+  }
+
+  void set qualifierEncodedAsBytes(core.List<core.int> _bytes) {
+    qualifierEncoded = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+  }
+  core.String qualifierString;
+  /**
+   * [Optional] The type to convert the value in cells of this column. The
+   * values are expected to be encoded using HBase Bytes.toBytes function when
+   * using the BINARY encoding value. Following BigQuery types are allowed
+   * (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Defaut type is BYTES.
+   * 'type' can also be set at the column family level. However, the setting at
+   * this level takes precedence if 'type' is set at both levels.
+   */
+  core.String type;
+
+  BigtableColumn();
+
+  BigtableColumn.fromJson(core.Map _json) {
+    if (_json.containsKey("encoding")) {
+      encoding = _json["encoding"];
+    }
+    if (_json.containsKey("fieldName")) {
+      fieldName = _json["fieldName"];
+    }
+    if (_json.containsKey("onlyReadLatest")) {
+      onlyReadLatest = _json["onlyReadLatest"];
+    }
+    if (_json.containsKey("qualifierEncoded")) {
+      qualifierEncoded = _json["qualifierEncoded"];
+    }
+    if (_json.containsKey("qualifierString")) {
+      qualifierString = _json["qualifierString"];
+    }
+    if (_json.containsKey("type")) {
+      type = _json["type"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (encoding != null) {
+      _json["encoding"] = encoding;
+    }
+    if (fieldName != null) {
+      _json["fieldName"] = fieldName;
+    }
+    if (onlyReadLatest != null) {
+      _json["onlyReadLatest"] = onlyReadLatest;
+    }
+    if (qualifierEncoded != null) {
+      _json["qualifierEncoded"] = qualifierEncoded;
+    }
+    if (qualifierString != null) {
+      _json["qualifierString"] = qualifierString;
+    }
+    if (type != null) {
+      _json["type"] = type;
+    }
+    return _json;
+  }
+}
+
+class BigtableColumnFamily {
+  /**
+   * [Optional] Lists of columns that should be exposed as individual fields as
+   * opposed to a list of (column name, value) pairs. All columns whose
+   * qualifier matches a qualifier in this list can be accessed as .. Other
+   * columns can be accessed as a list through .Column field.
+   */
+  core.List<BigtableColumn> columns;
+  /**
+   * [Optional] The encoding of the values when the type is not STRING.
+   * Acceptable encoding values are: TEXT - indicates values are alphanumeric
+   * text strings. BINARY - indicates values are encoded using HBase
+   * Bytes.toBytes family of functions. This can be overridden for a specific
+   * column by listing that column in 'columns' and specifying an encoding for
+   * it.
+   */
+  core.String encoding;
+  /** Identifier of the column family. */
+  core.String familyId;
+  /**
+   * [Optional] If this is set only the latest version of value are exposed for
+   * all columns in this column family. This can be overridden for a specific
+   * column by listing that column in 'columns' and specifying a different
+   * setting for that column.
+   */
+  core.bool onlyReadLatest;
+  /**
+   * [Optional] The type to convert the value in cells of this column family.
+   * The values are expected to be encoded using HBase Bytes.toBytes function
+   * when using the BINARY encoding value. Following BigQuery types are allowed
+   * (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Defaut type is BYTES.
+   * This can be overridden for a specific column by listing that column in
+   * 'columns' and specifying a type for it.
+   */
+  core.String type;
+
+  BigtableColumnFamily();
+
+  BigtableColumnFamily.fromJson(core.Map _json) {
+    if (_json.containsKey("columns")) {
+      columns = _json["columns"].map((value) => new BigtableColumn.fromJson(value)).toList();
+    }
+    if (_json.containsKey("encoding")) {
+      encoding = _json["encoding"];
+    }
+    if (_json.containsKey("familyId")) {
+      familyId = _json["familyId"];
+    }
+    if (_json.containsKey("onlyReadLatest")) {
+      onlyReadLatest = _json["onlyReadLatest"];
+    }
+    if (_json.containsKey("type")) {
+      type = _json["type"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (columns != null) {
+      _json["columns"] = columns.map((value) => (value).toJson()).toList();
+    }
+    if (encoding != null) {
+      _json["encoding"] = encoding;
+    }
+    if (familyId != null) {
+      _json["familyId"] = familyId;
+    }
+    if (onlyReadLatest != null) {
+      _json["onlyReadLatest"] = onlyReadLatest;
+    }
+    if (type != null) {
+      _json["type"] = type;
+    }
+    return _json;
+  }
+}
+
+class BigtableOptions {
+  /**
+   * [Optional] List of column families to expose in the table schema along with
+   * their types. This list restricts the column families that can be referenced
+   * in queries and specifies their value types. You can use this list to do
+   * type conversions - see the 'type' field for more details. If you leave this
+   * list empty, all column families are present in the table schema and their
+   * values are read as BYTES. During a query only the column families
+   * referenced in that query are read from Bigtable.
+   */
+  core.List<BigtableColumnFamily> columnFamilies;
+  /**
+   * [Optional] If field is true, then the column families that are not
+   * specified in columnFamilies list are not exposed in the table schema.
+   * Otherwise, they are read with BYTES type values. The default value is
+   * false.
+   */
+  core.bool ignoreUnspecifiedColumnFamilies;
+
+  BigtableOptions();
+
+  BigtableOptions.fromJson(core.Map _json) {
+    if (_json.containsKey("columnFamilies")) {
+      columnFamilies = _json["columnFamilies"].map((value) => new BigtableColumnFamily.fromJson(value)).toList();
+    }
+    if (_json.containsKey("ignoreUnspecifiedColumnFamilies")) {
+      ignoreUnspecifiedColumnFamilies = _json["ignoreUnspecifiedColumnFamilies"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (columnFamilies != null) {
+      _json["columnFamilies"] = columnFamilies.map((value) => (value).toJson()).toList();
+    }
+    if (ignoreUnspecifiedColumnFamilies != null) {
+      _json["ignoreUnspecifiedColumnFamilies"] = ignoreUnspecifiedColumnFamilies;
+    }
+    return _json;
+  }
+}
+
 class CsvOptions {
   /**
    * [Optional] Indicates if BigQuery should accept rows that are missing
    * trailing optional columns. If true, BigQuery treats missing trailing
    * columns as null values. If false, records with missing trailing columns are
    * treated as bad records, and if there are too many bad records, an invalid
    * error is returned in the job result. The default value is false.
    */
   core.bool allowJaggedRows;
   /**
@@ skipping 647 matching lines @@
     }
     if (substeps != null) {
       _json["substeps"] = substeps;
     }
     return _json;
   }
 }
 
 class ExternalDataConfiguration {
   /**
+   * [Experimental] Try to detect schema and format options automatically. Any
+   * option specified explicitly will be honored.
+   */
+  core.bool autodetect;
+  /** [Optional] Additional options if sourceFormat is set to BIGTABLE. */
+  BigtableOptions bigtableOptions;
+  /**
    * [Optional] The compression type of the data source. Possible values include
    * GZIP and NONE. The default value is NONE. This setting is ignored for
-   * Google Cloud Datastore backups.
+   * Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.
    */
   core.String compression;
   /** Additional properties to set if sourceFormat is set to CSV. */
   CsvOptions csvOptions;
   /**
    * [Optional] Indicates if BigQuery should allow extra values that are not
    * represented in the table schema. If true, the extra values are ignored. If
    * false, records with extra columns are treated as bad records, and if there
    * are too many bad records, an invalid error is returned in the job result.
    * The default value is false. The sourceFormat property determines what
    * BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values
-   * that don't match any column names Google Cloud Datastore backups: This
-   * setting is ignored.
+   * that don't match any column names Google Cloud Bigtable: This setting is
+   * ignored. Google Cloud Datastore backups: This setting is ignored. Avro:
+   * This setting is ignored.
    */
   core.bool ignoreUnknownValues;
   /**
    * [Optional] The maximum number of bad records that BigQuery can ignore when
    * reading data. If the number of bad records exceeds this value, an invalid
    * error is returned in the job result. The default value is 0, which requires
    * that all records are valid. This setting is ignored for Google Cloud
-   * Datastore backups.
+   * Bigtable, Google Cloud Datastore backups and Avro formats.
    */
   core.int maxBadRecords;
   /**
    * [Optional] The schema for the data. Schema is required for CSV and JSON
-   * formats. Schema is disallowed for Google Cloud Datastore backups.
+   * formats. Schema is disallowed for Google Cloud Bigtable, Cloud Datastore
+   * backups, and Avro formats.
    */
   TableSchema schema;
   /**
    * [Required] The data format. For CSV files, specify "CSV". For
-   * newline-delimited JSON, specify "NEWLINE_DELIMITED_JSON". For Google Cloud
-   * Datastore backups, specify "DATASTORE_BACKUP".
+   * newline-delimited JSON, specify "NEWLINE_DELIMITED_JSON". For Avro files,
+   * specify "AVRO". For Google Cloud Datastore backups, specify
+   * "DATASTORE_BACKUP". [Experimental] For Google Cloud Bigtable, specify
+   * "BIGTABLE". Please note that reading from Google Cloud Bigtable is
+   * experimental and has to be enabled for your project. Please contact Google
+   * Cloud Support to enable this for your project.
    */
   core.String sourceFormat;
   /**
-   * [Required] The fully-qualified URIs that point to your data in Google Cloud
-   * Storage. Each URI can contain one '*' wildcard character and it must come
-   * after the 'bucket' name. Size limits related to load jobs apply to external
-   * data sources, plus an additional limit of 10 GB maximum size across all
-   * URIs. For Google Cloud Datastore backups, exactly one URI can be specified,
-   * and it must end with '.backup_info'. Also, the '*' wildcard character is
-   * not allowed.
+   * [Required] The fully-qualified URIs that point to your data in Google
+   * Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard
+   * character and it must come after the 'bucket' name. Size limits related to
+   * load jobs apply to external data sources, plus an additional limit of 10 GB
+   * maximum size across all URIs. For Google Cloud Bigtable URIs: Exactly one
+   * URI can be specified and it has be a fully specified and valid HTTPS URL
+   * for a Google Cloud Bigtable table. For Google Cloud Datastore backups,
+   * exactly one URI can be specified, and it must end with '.backup_info'.
+   * Also, the '*' wildcard character is not allowed.
    */
   core.List<core.String> sourceUris;
 
   ExternalDataConfiguration();
 
   ExternalDataConfiguration.fromJson(core.Map _json) {
+    if (_json.containsKey("autodetect")) {
+      autodetect = _json["autodetect"];
+    }
+    if (_json.containsKey("bigtableOptions")) {
+      bigtableOptions = new BigtableOptions.fromJson(_json["bigtableOptions"]);
+    }
     if (_json.containsKey("compression")) {
       compression = _json["compression"];
     }
     if (_json.containsKey("csvOptions")) {
       csvOptions = new CsvOptions.fromJson(_json["csvOptions"]);
     }
     if (_json.containsKey("ignoreUnknownValues")) {
       ignoreUnknownValues = _json["ignoreUnknownValues"];
     }
     if (_json.containsKey("maxBadRecords")) {
       maxBadRecords = _json["maxBadRecords"];
     }
     if (_json.containsKey("schema")) {
       schema = new TableSchema.fromJson(_json["schema"]);
     }
     if (_json.containsKey("sourceFormat")) {
       sourceFormat = _json["sourceFormat"];
     }
     if (_json.containsKey("sourceUris")) {
       sourceUris = _json["sourceUris"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (autodetect != null) {
+      _json["autodetect"] = autodetect;
+    }
+    if (bigtableOptions != null) {
+      _json["bigtableOptions"] = (bigtableOptions).toJson();
+    }
     if (compression != null) {
       _json["compression"] = compression;
     }
     if (csvOptions != null) {
       _json["csvOptions"] = (csvOptions).toJson();
     }
     if (ignoreUnknownValues != null) {
       _json["ignoreUnknownValues"] = ignoreUnknownValues;
     }
     if (maxBadRecords != null) {
@@ skipping 689 matching lines @@
   /** [Required] BigQuery SQL query to execute. */
   core.String query;
   /**
    * [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 updated SQL dialect with improved standards compliance. When
+   * using BigQuery's updated SQL, the values of allowLargeResults and
+   * flattenResults are ignored. Queries with useLegacySql set to false 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.
    */
   core.bool useQueryCache;
   /**
    * [Experimental] Describes user-defined function resources used in the query.
    */
@@ skipping 37 matching lines @@
     }
     if (_json.containsKey("priority")) {
       priority = _json["priority"];
     }
     if (_json.containsKey("query")) {
       query = _json["query"];
     }
     if (_json.containsKey("tableDefinitions")) {
       tableDefinitions = commons.mapMap(_json["tableDefinitions"], (item) => new ExternalDataConfiguration.fromJson(item));
     }
+    if (_json.containsKey("useLegacySql")) {
+      useLegacySql = _json["useLegacySql"];
+    }
     if (_json.containsKey("useQueryCache")) {
       useQueryCache = _json["useQueryCache"];
     }
     if (_json.containsKey("userDefinedFunctionResources")) {
       userDefinedFunctionResources = _json["userDefinedFunctionResources"].map((value) => new UserDefinedFunctionResource.fromJson(value)).toList();
     }
     if (_json.containsKey("writeDisposition")) {
       writeDisposition = _json["writeDisposition"];
     }
   }
@@ skipping 23 matching lines @@
     }
     if (priority != null) {
       _json["priority"] = priority;
     }
     if (query != null) {
       _json["query"] = query;
     }
     if (tableDefinitions != null) {
       _json["tableDefinitions"] = commons.mapMap(tableDefinitions, (item) => (item).toJson());
     }
+    if (useLegacySql != null) {
+      _json["useLegacySql"] = useLegacySql;
+    }
     if (useQueryCache != null) {
       _json["useQueryCache"] = useQueryCache;
     }
     if (userDefinedFunctionResources != null) {
       _json["userDefinedFunctionResources"] = userDefinedFunctionResources.map((value) => (value).toJson()).toList();
     }
     if (writeDisposition != null) {
       _json["writeDisposition"] = writeDisposition;
     }
     return _json;
@@ skipping 326 matching lines @@
   core.int billingTier;
   /**
    * [Output-only] Whether the query result was fetched from the query cache.
    */
   core.bool cacheHit;
   /**
    * [Output-only, Experimental] Describes execution plan for the query as a
    * list of stages.
    */
   core.List<ExplainQueryStage> queryPlan;
+  /**
+   * [Output-only, Experimental] Referenced tables for the job. Queries that
+   * reference more than 50 tables will not have a complete list.
+   */
+  core.List<TableReference> referencedTables;
   /** [Output-only] Total bytes billed for the job. */
   core.String totalBytesBilled;
   /** [Output-only] Total bytes processed for the job. */
   core.String totalBytesProcessed;
 
   JobStatistics2();
 
   JobStatistics2.fromJson(core.Map _json) {
     if (_json.containsKey("billingTier")) {
       billingTier = _json["billingTier"];
     }
     if (_json.containsKey("cacheHit")) {
       cacheHit = _json["cacheHit"];
     }
     if (_json.containsKey("queryPlan")) {
       queryPlan = _json["queryPlan"].map((value) => new ExplainQueryStage.fromJson(value)).toList();
     }
+    if (_json.containsKey("referencedTables")) {
+      referencedTables = _json["referencedTables"].map((value) => new TableReference.fromJson(value)).toList();
+    }
     if (_json.containsKey("totalBytesBilled")) {
       totalBytesBilled = _json["totalBytesBilled"];
     }
     if (_json.containsKey("totalBytesProcessed")) {
       totalBytesProcessed = _json["totalBytesProcessed"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (billingTier != null) {
       _json["billingTier"] = billingTier;
     }
     if (cacheHit != null) {
       _json["cacheHit"] = cacheHit;
     }
     if (queryPlan != null) {
       _json["queryPlan"] = queryPlan.map((value) => (value).toJson()).toList();
     }
+    if (referencedTables != null) {
+      _json["referencedTables"] = referencedTables.map((value) => (value).toJson()).toList();
+    }
     if (totalBytesBilled != null) {
       _json["totalBytesBilled"] = totalBytesBilled;
     }
     if (totalBytesProcessed != null) {
       _json["totalBytesProcessed"] = totalBytesProcessed;
     }
     return _json;
   }
 }
 
@@ skipping 320 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 updated SQL dialect with improved standards compliance. When
+   * using BigQuery's updated SQL, the values of allowLargeResults and
+   * flattenResults are ignored. Queries with useLegacySql set to false 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;
 
   QueryRequest();
 
   QueryRequest.fromJson(core.Map _json) {
     if (_json.containsKey("defaultDataset")) {
@@ skipping 10 matching lines @@
     }
     if (_json.containsKey("preserveNulls")) {
       preserveNulls = _json["preserveNulls"];
     }
     if (_json.containsKey("query")) {
       query = _json["query"];
     }
     if (_json.containsKey("timeoutMs")) {
       timeoutMs = _json["timeoutMs"];
     }
+    if (_json.containsKey("useLegacySql")) {
+      useLegacySql = _json["useLegacySql"];
+    }
     if (_json.containsKey("useQueryCache")) {
       useQueryCache = _json["useQueryCache"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (defaultDataset != null) {
       _json["defaultDataset"] = (defaultDataset).toJson();
     }
     if (dryRun != null) {
       _json["dryRun"] = dryRun;
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (maxResults != null) {
       _json["maxResults"] = maxResults;
     }
     if (preserveNulls != null) {
       _json["preserveNulls"] = preserveNulls;
     }
     if (query != null) {
       _json["query"] = query;
     }
     if (timeoutMs != null) {
       _json["timeoutMs"] = timeoutMs;
     }
+    if (useLegacySql != null) {
+      _json["useLegacySql"] = useLegacySql;
+    }
     if (useQueryCache != null) {
       _json["useQueryCache"] = useQueryCache;
     }
     return _json;
   }
 }
 
 class QueryResponse {
   /** Whether the query result was fetched from the query cache. */
   core.bool cacheHit;
@@ skipping 423 matching lines @@
   core.String kind;
   /** The rows to insert. */
   core.List<TableDataInsertAllRequestRows> rows;
   /**
    * [Optional] 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.
    */
   core.bool skipInvalidRows;
   /**
-   * [Optional] If specified, treats the destination table as a base template,
-   * and inserts the rows into an instance table named
+   * [Experimental] If specified, treats the destination table as a base
+   * template, and inserts the rows into an instance table named
    * "{destination}{templateSuffix}". BigQuery will manage creation of the
    * instance table, using the schema of the base template table. See
    * https://cloud.google.com/bigquery/streaming-data-into-bigquery#template-tables
    * for considerations when working with templates tables.
    */
   core.String templateSuffix;
 
   TableDataInsertAllRequest();
 
   TableDataInsertAllRequest.fromJson(core.Map _json) {
@@ skipping 470 matching lines @@
     var _json = new core.Map();
     if (query != null) {
       _json["query"] = query;
     }
     if (userDefinedFunctionResources != null) {
       _json["userDefinedFunctionResources"] = userDefinedFunctionResources.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }