创建和使用表

本文档介绍如何在 BigQuery 中创建和使用表。创建表后，您可执行以下操作：

• 控制对表数据的访问
• 获取有关表的信息
• 列出数据集中的表
• 获取表元数据

要详细了解如何管理表，包括更新表属性、复制表和删除表，请参阅管理表。

表限制

BigQuery 表受到以下限制：

• 表名称在数据集范围内必须是唯一的。
• Console 和传统版 BigQuery 网页界面仅支持一次复制一个表。
• 复制表时，目标数据集必须与要复制的表位于同一位置。例如，您无法将表从存储在欧盟的数据集复制到存储在美国的数据集。
• 使用 CLI 或 API 将多个源表复制到一个目标表时，所有源表必须具有相同的架构。
• 只能使用 Console、传统版 BigQuery 网页界面、命令行工具或 API 一次删除一个表。
• 导出表数据时，唯一支持的目标是 Cloud Storage。

• 当数据集中表的数量接近 50000 个或更多时，枚举这些表时速度会变慢。无论您是使用 API 调用，还是使用传统版 BigQuery 网页界面，枚举性能都会受到影响。目前，GCP Console 中的 BigQuery 网页界面最多允许每个数据集显示 50000 个表。

  要提升传统版 BigQuery 网页界面的性能，您可以使用 ?minimal 参数将每个项目显示的表数限制为 30000 个。您可以按以下格式向传统版 BigQuery 网页界面网址添加参数： https://bigquery.cloud.google.com/queries/[PROJECT_NAME]?minimal。

创建表

您可以通过以下方法在 BigQuery 中创建表：

• 手动使用 GCP Console、经典版 BigQuery 网页界面或命令行工具的 bq mk 命令创建
• 通过调用 tables.insert API 方法以编程方式创建
• 根据查询结果创建
• 通过定义引用外部数据源的表
• 在加载数据时

在 BigQuery 中创建表时，每个数据集的表名称必须是唯一的。表名称可：

• 包含最多 1024 个字符
• 包含字母（大写或小写）、数字和下划线

所需权限

要创建表，您必须拥有数据集级层的 WRITER 访问权限，或分配有具备 bigquery.tables.create 权限的项目级层 IAM 角色。以下预定义的项目级层 IAM 角色具有 bigquery.tables.create 权限：

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

此外，由于 bigquery.user 角色具有 bigquery.datasets.create 权限，因此分配有 bigquery.user 角色的用户可在用户创建的任何数据集中创建表。当分配有 bigquery.user 角色的用户创建数据集时，该用户即被授予对该数据集的 OWNER 访问权限。 凭借对数据集的 OWNER 访问权限，用户可以完全掌控该数据集。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅访问权限控制。要详细了解数据集级层角色，请参阅数据集的初始角色。

创建具有架构定义的空表

创建具有架构定义的空表时，您可执行以下操作：

• 使用 GCP Console 或经典版 BigQuery 网页界面输入架构
• 使用命令行工具以内联方式提供架构
• 使用命令行工具提交 JSON 架构文件
• 调用 API 的 tables.insert 方法时，在表资源中提供架构。

如需详细了解如何指定表架构，请参阅指定架构。

创建表后，您可以向表加载数据，或通过写入查询结果来填充表。

要创建具有架构定义的空表，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。
   转到 BigQuery 网页界面

2. 在导航面板的资源部分中，展开您的项目并选择数据集。

3. 在窗口右侧的详细信息面板中，点击创建表。加载数据的过程与创建空表的过程相同。

   

4. 在创建表页面的来源部分，选择空白表。

5. 在创建表页面的目标位置部分，执行以下操作：

   • 在数据集名称部分，选择适当的数据集。

     

   • 在表名称字段中，输入您要在 BigQuery 中创建的表的名称。

   • 验证表类型是否设置为原生表。

6. 在架构部分中，输入架构定义。

   • 通过以下方式，手动输入架构信息：

     • 启用以文本形式修改，并以 JSON 数组格式输入表架构。

       注意：您可以输入以下命令来查看 JSON 格式的现有表架构：bq show --format=prettyjson [DATASET].[TABLE]。

     • 使用添加字段手动输入架构。

7. 在高级选项部分保留默认值。

8. 在高级选项部分中选择适用项，然后点击创建表。如需了解可用选项，请参阅 JSON 选项。

9. 点击创建表。

注意：使用此界面创建空表时，不能添加标签、说明或到期时间。要添加这些可选属性，您可以使用 CLI 或 API 创建表。使用 BigQuery 网页界面创建表后，可以添加到期时间、说明和标签。

传统版界面

1. 在导航窗格中，点击您的数据集名称旁边的向下箭头图标 ，然后点击创建新表。

2. 在创建表页面上的源数据部分中，点击创建空表。

3. 在创建表页面的目标表部分，执行以下操作：

   • 对于，选择相应的数据集，然后在表名称字段中输入要创建的表的名称。
   • 验证表类型是否设置为原生表。

4. 在架构部分，手动输入架构定义。

   • 您可通过以下方式手动输入架构信息：

     • 点击以文本形式修改，并以 JSON 数组格式输入表架构：

       

       注意：您可以输入以下命令来查看 JSON 格式的现有表架构：bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE]。

     • 使用 Add Field 输入架构：

       

5. 在选项部分保留默认值。

6. 点击创建表。

注意：使用此界面创建空表时，不能添加标签、说明或到期时间。要添加这些可选属性，您可以使用 CLI 或 API 创建表。使用 BigQuery 网页界面创建表后，可以添加到期时间、说明和标签。

命令行

结合使用 mk 命令和 --table 或 -t 标志。您可以内嵌方式或通过 JSON 架构文件提供表的架构信息。可选参数包括 --expiration、--description、--time_partitioning_type、--destination_kms_key 和 --label。如果要在默认项目以外的某个项目中创建表，请按以下格式将项目 ID 添加到数据集中：[PROJECT_ID]:[DATASET]。

此处未演示 --time_partitioning_type 和 --destination_kms_key。如需详细了解 --time_partitioning_type，请参阅按提取时间分区的表或分区表。如需详细了解 --destination_kms_key，请参阅客户管理的加密密钥。

要在具有架构定义的现有数据集中创建空表，请输入以下项：

bq mk --table --expiration [INTEGER] --description [DESCRIPTION] --label [KEY:VALUE, KEY:VALUE] [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]

其中：

• [INTEGER] 是表的默认生命周期（以秒为单位）。最小值为 3600 秒（1 小时）。到期时间计算结果为当前时间加上该整数值。如果在创建表时设置该表的到期时间，则系统会忽略数据集的默认表到期时间设置。
• [DESCRIPTION] 是表的说明（用引号引起来）。
• [KEY:VALUE] 是代表标签的键值对。可使用逗号分隔列表输入多个标签。
• [PROJECT_ID] 是项目 ID。
• [DATASET] 是您项目中的数据集。
• [TABLE] 是您要创建的表的名称。
• [SCHEMA] 是采用 [FIELD]:[DATA_TYPE],[FIELD]:[DATA_TYPE] 格式的内嵌架构定义或指向本地计算机上的 JSON 架构文件的路径。

使用命令行指定架构时，您不能添加 RECORD (STRUCT) 类型和列说明，也不能指定列的模式。所有模式均默认为 NULLABLE。要添加说明、模式和 RECORD 类型，请改为提供 JSON 架构文件。

示例：

输入以下命令，使用内嵌架构定义创建表。该命令会在默认项目的 mydataset 中创建一个名为 mytable 的表。表到期时间设为 3600 秒（1 小时），说明设为 This is my table，标签设为 organization:development。该命令使用 -t 快捷键，而非 --table。该架构以内嵌方式指定为 qtr:STRING,sales:FLOAT,year:STRING。

bq mk -t --expiration 3600 --description "This is my table" --label organization:development mydataset.mytable qtr:STRING,sales:FLOAT,year:STRING

输入以下命令以使用 JSON 架构文件创建表。该命令会在默认项目的 mydataset 中创建一个名为 mytable 的表。表到期时间设为 3600 秒（1 小时），说明设为 This is my table，标签设为 organization:development。指向架构文件的路径为 /tmp/myschema.json。

bq mk --table --expiration 3600 --description "This is my table" --label organization:development mydataset.mytable /tmp/myschema.json

输入以下命令，使用 JSON 架构文件创建表。该命令会在 myotherproject 的 mydataset 中创建一个名为 mytable 的表。表到期时间设为 3600 秒（1 小时），说明设为 This is my table，标签设为 organization:development。指向架构文件的路径为 /tmp/myschema.json。

bq mk --table --expiration 3600 --description "This is my table" --label organization:development myotherproject:mydataset.mytable /tmp/myschema.json

创建表后，您可以更新表的到期时间、说明和标签，也可以修改架构定义。

API

使用已定义的表资源调用 tables.insert 方法。

C#

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 C# 设置说明进行操作。如需了解详情，请参阅 BigQuery C# API 参考文档。

在 GitHub 上查看 反馈

using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

sampleSchema := bigquery.Schema{
	{Name: "full_name", Type: bigquery.StringFieldType},
	{Name: "age", Type: bigquery.IntegerFieldType},
}

metaData := &bigquery.TableMetadata{
	Schema:         sampleSchema,
	ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
}
tableRef := client.Dataset(datasetID).Table(tableID)
if err := tableRef.Create(ctx, metaData); err != nil {
	return err
}

Java

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field field = Field.of(fieldName, LegacySQLTypeName.STRING);
// Table schema definition
Schema schema = Schema.of(field);
TableDefinition tableDefinition = StandardTableDefinition.of(schema);
TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();
Table table = bigquery.create(tableInfo);

Node.js

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const datasetId = "my_new_dataset";
  // const tableId = "my_new_table";
  // const schema = "Name:string, Age:integer, Weight:float, IsMagic:boolean";

  // Create a client
  const bigqueryClient = new BigQuery();

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigqueryClient
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}
createTable();

PHP

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 PHP 设置说明进行操作。如需了解详情，请参阅 BigQuery PHP API 参考文档。

在 GitHub 上查看 反馈

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

from google.cloud import bigquery

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

# TODO(developer): Construct a BigQuery client object.
# client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create
# table_id = "your-project.your_dataset.your_table_name"

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # API request
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 Ruby 设置说明进行操作。如需了解详情，请参阅 BigQuery Ruby API 参考文档。

在 GitHub 上查看 反馈

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

基于查询结果创建表

要基于查询结果创建表，请将结果写入一个目标表。

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。
   转到 BigQuery 网页界面

2. 在导航面板的资源部分中，展开您的项目并选择数据集。

3. 如果查询编辑器隐藏，请点击窗口右上角的显示编辑器。

4. 在查询编辑器文本区域中输入有效的 SQL 查询。

5. 点击编辑器下方的更多，然后选择查询设置。

   

6. 勾选该方框，为查询结果设置目标表。

   

7. 在目标位置部分，选择要在其中创建表的相应项目名称和数据集名称，然后选择表名称。

8. 在目标表的写入设置部分，选择以下选项之一：

   • 只写入空白表 - 仅在表为空时才将查询结果写入表。
   • 附加到表 - 将查询结果附加到现有表。
   • 覆盖表 - 使用查询结果覆盖名称相同的现有表。

9. （可选）在处理位置部分，点击自动选择并选择数据的位置。

10. 点击运行查询。这会创建一个查询作业，并将查询结果写入您指定的表中。

或者，如果在运行查询之前忘记指定目标表，您可以将临时表复制到永久表，只需点击编辑器下方的保存视图按钮即可。

经典版界面

选项 1：使用 DDL 语句

通过数据定义语言 (DDL) 语句，您可以使用标准 SQL 查询语法创建和修改表。

如需了解详情，请参阅 CREATE TABLE 语句页面和 CREATE TABLE 示例：从现有表创建新表。

选项 2：使用传统版网页界面

1. 转到经典版 BigQuery 网页界面。
   转到经典版 BigQuery 网页界面

2. 点击撰写查询按钮。

3. 在新建查询文本区域中输入有效的 SQL 查询。

4. 点击显示选项。

5. 在目标表 部分，点击选择表。

6. 在选择目标表对话框中，执行以下操作：

   1. 对于项目，选择要在哪个项目中创建目标表。

   2. 对于数据集，选择要用于存储该表的数据集。

   3. 在表 ID 字段中，输入表名称。该名称在目标数据集中必须是唯一的。表名称最长可达 1024 个字符，并且只能包含 a-z、A-Z、0-9 或 _（下划线字符）。

   4. 点击确定。

7. 在目标表部分的写入首选项 中，选择以下某个选项：

   • 只写入空白表 - 仅在表为空时才将查询结果写入表。
   • 附加到表 - 将查询结果附加到现有表。
   • 覆盖表 - 使用查询结果覆盖名称相同的现有表。

8. （可选）在处理位置部分，点击未指定并选择数据的位置。

9. 点击运行查询。这会创建一个查询作业，并将查询结果写入您指定的表中。

或者，如果在运行查询之前忘记指定目标表，您可以将临时表复制到永久表，只需点击结果窗口中的保存为表按钮即可。

CLI

输入 bq query 命令并指定 --destination_table 标志，基于查询结果创建一个永久表。指定 use_legacy_sql=false 标志以使用标准 SQL 语法。要将查询结果写入默认项目之外的某个表中，请按此格式将项目 ID 添加到数据集名称中：[PROJECT_ID]:[DATASET]。

提供 --location 标志并将值设置为您的位置。

要控制现有目标表的写入处置方式，请指定下述可选标志之一：

• --append_table - 如果目标表已存在，则系统会将查询结果附加到该表。

• --replace - 如果目标表已存在，则系统会用查询结果覆盖该表。

  bq --location=[LOCATION] query --destination_table [PROJECT_ID]:[DATASET].[TABLE] --use_legacy_sql=false '[QUERY]'
  

其中：

• [LOCATION] 是用于处理查询的位置的名称。--location 是可选标志。例如，如果您在东京区域使用 BigQuery，则可以将该标志的值设置为 asia-northeast1。您可以使用 .bigqueryrc 文件设置默认位置值。
• [PROJECT_ID] 是项目 ID。
• [DATASET] 是数据集名称，该数据集包含您要向其中写入查询结果的表。
• [TABLE] 是您要向其中写入查询结果的表的名称。
• [QUERY] 是使用标准 SQL 语法的查询。

如果未指定“写入处置方式”标志，则默认行为是仅在表为空时写入结果。如果表已存在且非空，则系统返回以下错误：BigQuery error in query operation: Error processing job '[PROJECT_ID]:bqjob_123abc456789_00000e1234f_1': Already Exists: Table [PROJECT_ID]:[DATASET].[TABLE]。

示例：

注意：以下示例使用了 --location=US 标志，因为您查询的是公共数据集。BigQuery 公共数据集存储在 US 多区域位置。由于公开数据集存储在 US，因此不能将公开数据查询结果写入另一区域的表中，也不能将公开数据集中的表与另一区域中的表连接。

输入以下命令，将查询结果写入 mydataset 中名为 mytable 的目标表。该数据集位于默认项目中。由于命令中未指定“写入处置方式”标志，因此该表必须为新表或空表。否则，系统会返回 Already exists 错误。该查询从美国名称数据公开数据集中检索数据。

bq --location=US query --destination_table mydataset.mytable --use_legacy_sql=false 'SELECT name,number FROM `bigquery-public-data.usa_names.usa_1910_current` WHERE gender = "M" ORDER BY number DESC'

输入以下命令，使用查询结果覆盖 mydataset 中名为 mytable 的目标表。该数据集位于默认项目中。该命令使用 --replace 标志覆盖目标表。

bq --location=US query --destination_table mydataset.mytable --replace --use_legacy_sql=false 'SELECT name,number FROM `bigquery-public-data.usa_names.usa_1910_current` WHERE gender = "M" ORDER BY number DESC'

输入以下命令，将查询结果附加到 mydataset 中名为 mytable 的目标表。该数据集在 myotherproject 中，不在默认项目中。该命令使用 --append 标志将查询结果附加到目标表。

bq --location=US query --destination_table myotherproject:mydataset.mytable --append --use_legacy_sql=false 'SELECT name,number FROM `bigquery-public-data.usa_names.usa_1910_current` WHERE gender = "M" ORDER BY number DESC'

API

要将查询结果保存到永久表中，请调用 jobs.insert 方法，配置一项 query 作业，并为 configuration.query.destinationTable 属性添加一个值。要控制现有目标表的写入处置方式，请配置 configuration.query.writeDisposition 属性。

在作业资源的 jobReference 部分的 location 属性中，指定您的位置。

Go

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

bigquery/snippets/snippet.go

在 GitHub 上查看 反馈

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")

q := client.Query("SELECT 17 as my_col")
q.Location = "US" // Location must match the dataset(s) referenced in query.
q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
job, err := q.Run(ctx)
if err != nil {
	return err
}
status, err := job.Wait(ctx)
if err != nil {
	return err
}
if err := status.Err(); err != nil {
	return err
}
it, err := job.Read(ctx)
for {
	var row []bigquery.Value
	err := it.Next(&row)
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Println(row)
}

Java

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

要将查询结果保存到永久表中，请在 QueryJobConfiguration 中将目标表设置为所需的 TableId。

在 GitHub 上查看

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
// String destinationDataset = 'my_destination_dataset';
// String destinationTable = 'my_destination_table';
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    // Note that setUseLegacySql is set to false by default
    QueryJobConfiguration.newBuilder(query)
        // Save the results of the query to a permanent table.
        .setDestinationTable(TableId.of(destinationDataset, destinationTable))
        .build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Python

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

要将查询结果保存到永久表中，请创建 QueryJobConfig 并将目标设置为所需的 TableReference。将作业配置传递给查询方法。

在 GitHub 上查看

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'your_dataset_id'

job_config = bigquery.QueryJobConfig()
# Set the destination table
table_ref = client.dataset(dataset_id).table('your_table_id')
job_config.destination = table_ref
sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(
    sql,
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config)  # API request - starts the query

query_job.result()  # Waits for the query to finish
print('Query results loaded to table {}'.format(table_ref.path))

创建引用外部数据源的表

外部数据源（也称为“联合数据源”）是可供直接查询的数据源，即使数据未存储在 BigQuery 中也是如此。您不用加载或流式传输数据，只需创建一个引用外部数据源的表即可。

BigQuery 支持直接查询以下各项中的数据：

• Cloud Bigtable
• Cloud Storage
• Google 云端硬盘

您可以在支持的外部数据源中查询数据，方法是创建一个临时或永久表，该表引用外部数据源中存储的数据。要详细了解如何使用外部数据源，请参阅：

• 查询 Cloud Bigtable 数据
• 查询 Cloud Storage 数据
• 查询 Google 云端硬盘数据

在加载数据时创建表

将数据加载到 BigQuery 时，可以将数据加载到新的表或分区中，也可以覆盖或附加到现有的表或分区。无需在加载数据前创建空表。您可以同时创建新表和加载数据。

将数据加载到 BigQuery 时，可以提供表或分区架构；对于支持的数据格式，可以使用架构自动检测。

要详细了解如何加载数据，请参阅将数据加载到 BigQuery 简介。

控制表的访问权限

您不能直接向表分配访问权限控制。但可以通过在数据集级层或项目级层配置访问权限控制来控制表的访问权限。

数据集级层的访问权限控制指定用户、组和服务帐号可以对该特定数据集中的表执行的操作。如果仅分配数据集级层的权限，则还必须分配一个提供项目访问权限的初始或预定义项目级层角色，例如 bigquery.user。

您可以分配预定义的项目级层 IAM 角色（这些角色可授予对项目中所有数据集内的所有表数据的权限），而不是授予对各个数据集的访问权限。

您还可以创建 IAM 自定义角色。如果创建自定义角色，则您授予的权限取决于您希望用户、群组或服务帐号能够执行哪些表操作。

如需详细了解角色和权限，请参阅：

• IAM 文档中的了解角色
• BigQuery 访问权限控制
• 分配对数据集的访问权限控制。

要了解如何使用表数据，请参阅管理表数据。

使用表

获取表的相关信息

您可以通过以下方式获取关于表的信息或元数据：

• 使用 GCP Console 或经典版 BigQuery 网页界面
• 使用 bq show CLI 命令
• 调用 tables.get API 方法。
• 查询 INFORMATION_SCHEMA 视图（测试版）

所需权限

要获取有关表的信息，您必须分配有数据集的 READER 角色，或者必须分配有包括 bigquery.tables.get 权限的项目级层 IAM 角色。如果您拥有项目级层 bigquery.tables.get 权限，则可获取项目中所有表的相关信息。除了 bigquery.jobUser 和 bigquery.user 之外，其他所有预定义的项目级层 IAM 角色都包含 bigquery.tables.get 权限。

此外，分配有 bigquery.user 角色的用户具有 bigquery.datasets.create 权限。这样一来，分配有 bigquery.user 角色的用户就可以获取该用户创建的任何数据集内的表的相关信息。在分配有 bigquery.user 角色的用户创建数据集后，该用户将获得对该数据集的 OWNER 访问权限。凭借对数据集的 OWNER 访问权限，用户可以完全掌控该数据集以及其中的所有表。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅访问权限控制。要详细了解数据集级层角色，请参阅数据集的初始角色。

获取表信息

要获取表的相关信息，请执行以下操作：

Console

1. 在导航面板的资源部分中，展开您的项目并选择数据集。点击数据集名称，将其展开。数据集中的表和视图即会显示。

2. 点击表名称。

3. 在编辑器下方，点击详细信息。此页面会显示表说明和表信息。

4. 点击架构标签页，查看表的架构定义。

经典版界面

1. 在导航窗格中，点击数据集左侧的向下箭头图标 展开数据集，或双击数据集名称。数据集中的表和视图即会显示。

2. 点击表名称。

3. 点击 Details。Table Details 页面会显示表说明和表信息。

   

4. 点击架构标签页，查看表的架构定义。

CLI

发出 bq show 命令可显示所有表信息。使用 --schema 标志可仅显示表的架构信息。--format 标志可用于控制输出。

如果您要获取默认项目以外的某个项目中的表的相关信息，请按以下格式将相应项目 ID 添加到数据集：[PROJECT_ID]:[DATASET]。

bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE]

其中：

• [PROJECT_ID] 是项目 ID。
• [DATASET] 是数据集的名称。
• [TABLE] 是表的名称。

示例：

输入以下命令可显示 mydataset 中有关 mytable 的所有信息。mydataset 在默认项目中。

bq show --format=prettyjson mydataset.mytable

输入以下命令可显示 mydataset 中有关 mytable 的所有信息。mydataset 在 myotherproject 中，不在默认项目中。

bq show --format=prettyjson myotherproject:mydataset.mytable

输入以下命令可仅显示有关 mydataset 中的 mytable 的架构信息。mydataset 在 myotherproject 中，不在默认项目中。

bq show --schema --format=prettyjson myotherproject:mydataset.mytable

API

调用 tables.get 方法并提供所有相关参数。

Go

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
if err != nil {
	return err
}
// Print basic information about the table.
fmt.Printf("Schema has %d top-level fields\n", len(meta.Schema))
fmt.Printf("Description: %s\n", meta.Description)
fmt.Printf("Row in managed storage: %d\n", meta.NumRows)

Java

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

TableId tableId = TableId.of(projectId, datasetName, tableName);
Table table = bigquery.getTable(tableId);

PHP

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 PHP 设置说明进行操作。如需了解详情，请参阅 BigQuery PHP API 参考文档。

在 GitHub 上查看 反馈

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

from google.cloud import bigquery

# TODO(developer): Construct a BigQuery client object.
# client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)

print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)

# View table properties
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

使用 INFORMATION_SCHEMA 获取表信息（测试版）

INFORMATION_SCHEMA 是一系列视图，用户可以利用它们访问关于数据集、表和视图的元数据。

您可以查询 INFORMATION_SCHEMA.TABLES 和 INFORMATION_SCHEMA.TABLE_OPTIONS 视图，检索关于项目中的表和视图的元数据。您还可以查询 INFORMATION_SCHEMA.COLUMNS 和 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图以检索关于表中的列（字段）的元数据。

TABLES 和 TABLE_OPTIONS 视图还包含关于视图的概要信息。如需了解详情，请改为查询 INFORMATION_SCHEMA.VIEWS 视图。

TABLES 视图

查询 INFORMATION_SCHEMA.TABLES 视图时，查询为数据集中的每个表或视图生成一行结果。

针对 INFORMATION_SCHEMA.TABLES 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表或视图的数据集。

INFORMATION_SCHEMA.TABLES 视图具有以下架构：

列名	数据类型	值
TABLE_CATALOG	STRING	包含数据集的项目的名称
TABLE_SCHEMA	STRING	包含表或视图的数据集的名称（也称为 datasetId）
TABLE_NAME	STRING	表或视图的名称（也称为 tableId）
TABLE_TYPE	STRING	表类型： BASE TABLE：一个 BigQuery 表 VIEW：一个 BigQuery 视图 EXTERNAL：一个引用外部数据源的表
IS_INSERTABLE_INTO	STRING	YES 或 NO，具体取决于表是否支持 DML INSERT 语句
IS_TYPED	STRING	值始终为 NO
CREATION_TIME	TIMESTAMP	表的创建时间

示例

示例 1：

以下示例从 INFORMATION_SCHEMA.TABLES 视图中检索所有列，is_typed 除外，该列留待将来使用。返回的元数据包括默认项目 myproject 的数据集 mydataset 中的所有表。

mydataset 包含以下表：

• mytable1：标准 BigQuery 表
• myview1：BigQuery 视图

针对 INFORMATION_SCHEMA.TABLES 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

要对默认项目以外的项目运行查询，请按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW] 例如，`myproject`.mydataset.INFORMATION_SCHEMA.TABLES。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    * EXCEPT(is_typed)
   FROM
    mydataset.INFORMATION_SCHEMA.TABLES
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES'

结果应如下所示：

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 |
  | myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

示例 2：

以下示例从 INFORMATION_SCHEMA.TABLES 视图中检索类型为 BASE TABLE 的所有表。不包括 is_typed 列。返回的元数据包括默认项目 myproject 的数据集 mydataset 中的所有表。

针对 INFORMATION_SCHEMA.TABLES 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

要对默认项目以外的项目运行查询，请按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW] 例如，`myproject`.mydataset.INFORMATION_SCHEMA.TABLES。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    * EXCEPT(is_typed)
   FROM
    mydataset.INFORMATION_SCHEMA.TABLES
   WHERE
    table_type="BASE TABLE"
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES
WHERE table_type="BASE TABLE"'

结果应如下所示：

  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  | myproject      | mydataset     | mytable1       | BASE TABLE | NO                 | 2018-10-31 22:40:05 |
  +----------------+---------------+----------------+------------+--------------------+---------------------+
  

TABLE_OPTIONS 视图

查询 INFORMATION_SCHEMA.TABLE_OPTIONS 视图时，查询为数据集中的每个表或视图生成一行结果。

针对 INFORMATION_SCHEMA.TABLE_OPTIONS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表或视图的数据集。

INFORMATION_SCHEMA.TABLE_OPTIONS 视图具有以下架构：

列名	数据类型	值
TABLE_CATALOG	STRING	包含数据集的项目的名称
TABLE_SCHEMA	STRING	包含表或视图的数据集的名称（也称为 datasetId）
TABLE_NAME	STRING	表或视图的名称（也称为 tableId）
OPTION_NAME	STRING	选项表中的一个名称值
OPTION_TYPE	STRING	选项表中的一个数据类型值
OPTION_VALUE	STRING	选项表中的一个值选项

选项表

OPTION_NAME	OPTION_TYPE	OPTION_VALUE
partition_expiration_days	FLOAT64	分区表中所有分区的默认生命周期（以天为单位）
expiration_timestamp	FLOAT64	表的默认生命周期（以天为单位）
kms_key_name	STRING	用于加密表的 Cloud KMS 密钥的名称
friendly_name	STRING	表的描述性名称
description	STRING	表的说明
labels	ARRAY<STRUCT<STRING, STRING>>	一组 STRUCT，表示表上的标签

示例

示例 1：

以下示例通过查询 INFORMATION_SCHEMATA.TABLE_OPTIONS 视图来检索默认项目 (myproject) 中数据集 mydataset 中的所有表的默认表到期时间。

针对 INFORMATION_SCHEMA.TABLE_OPTIONS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

要对默认项目以外的项目运行查询，请按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW] 例如，`myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    *
   FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
   WHERE
    option_name="expiration_timestamp"
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
WHERE option_name="expiration_timestamp"'

结果应如下所示：

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

注意：没有到期时间的表会从查询结果中排除。

示例 2：

以下示例检索 mydataset 中包含测试数据的所有表的元数据。该查询使用 description 选项中的值查找在说明的任何位置包含“test”的表。mydataset 位于默认项目 myproject 中。

要对默认项目以外的项目运行查询，请按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW] 例如，`myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    *
   FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
   WHERE
    option_name="description" AND option_value LIKE "%test%"
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
WHERE option_name="description" AND option_value LIKE "%test%"'

结果应如下所示：

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

COLUMNS 视图

查询 INFORMATION_SCHEMA.COLUMNS 视图时，查询为表中的每一列（字段）生成一行结果。

针对 INFORMATION_SCHEMA.COLUMNS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

INFORMATION_SCHEMA.COLUMNS 视图具有以下架构：

列名	数据类型	值
TABLE_CATALOG	STRING	包含数据集的项目的名称
TABLE_SCHEMA	STRING	包含表的数据集的名称（也称为 datasetId）
TABLE_NAME	STRING	表或视图的名称（也称为 tableId）
COLUMN_NAME	STRING	列的名称
ORDINAL_POSITION	INT64	表中从 1 开始计数的列的偏移量；如果列为伪列（例如 _PARTITIONTIME 或 _PARTITIONDATE），则值为 NULL
IS_NULLABLE	STRING	YES 或 NO，具体取决于列的模式是否允许 NULL 值
DATA_TYPE	STRING	列的标准 SQL 数据类型
IS_GENERATED	STRING	值始终为 NEVER
GENERATION_EXPRESSION	STRING	值始终为 NULL
IS_STORED	STRING	值始终为 NULL
IS_HIDDEN	STRING	YES 或 NO，具体取决于列是否为伪列，例如 _PARTITIONTIME 或 _PARTITIONDATE
IS_UPDATABLE	STRING	值始终为 NULL
IS_SYSTEM_DEFINED	STRING	YES 或 NO，具体取决于列是否为伪列，例如 _PARTITIONTIME 或 _PARTITIONDATE
IS_PARTITIONING_COLUMN	STRING	YES 或 NO，具体取决于列是否为分区列
CLUSTERING_ORDINAL_POSITION	STRING	表的聚簇列中列的偏移量，从 1 开始计数；如果表不是聚簇表，则值为 NULL

示例

以下示例从 census_bureau_usa 数据集中 population_by_zip_2010 表的 INFORMATION_SCHEMA.COLUMNS 视图中检索元数据。此数据集是 BigQuery 公共数据集计划的一部分。

由于此表属于 bigquery-public-data 项目，因此您应按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW] 例如，`bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES。

以下列会从查询结果中排除，因为它们当前保留供将来使用：

• IS_GENERATED
• GENERATION_EXPRESSION
• IS_STORED
• IS_UPDATABLE

针对 INFORMATION_SCHEMA.COLUMNS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
   FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
   WHERE
    table_name="population_by_zip_2010"
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
WHERE table_name="population_by_zip_2010"'

结果应如下所示。为确保可读性，table_catalog 和 table_schema 会从结果中排除：

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
  

COLUMN_FIELD_PATHS 视图

查询 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图时，查询结果中包含嵌套在 RECORD（或 STRUCT）列中的每一列对应的一行结果。

针对 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图具有以下架构：

列名	数据类型	值
TABLE_CATALOG	STRING	包含数据集的项目的名称
TABLE_SCHEMA	STRING	包含表的数据集的名称（也称为 datasetId）
TABLE_NAME	STRING	表或视图的名称（也称为 tableId）
COLUMN_NAME	STRING	列的名称
FIELD_PATH	STRING	嵌套在 `RECORD`（或 `STRUCT`）列中的列的路径
DATA_TYPE	STRING	列的标准 SQL 数据类型
DESCRIPTION	STRING	列的说明

示例

以下示例从 github_repos 数据集中 commits 表的 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图中检索元数据。此数据集是 BigQuery 公共数据集计划的一部分。

由于此表属于 bigquery-public-data 项目，因此您应按以下格式为数据集添加相应的项目 ID：`[PROJECT_ID]`.[DATASET].INFORMATION_SCHEMA.[VIEW]；例如，`bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS。

commits 表包含以下嵌套列以及嵌套和重复列：

• author：嵌套 RECORD 列
• committer：嵌套 RECORD 列
• trailer：嵌套和重复 RECORD 列
• difference：嵌套和重复 RECORD 列

查询将检索有关 author 和 difference 列的元数据。

针对 INFORMATION_SCHEMA.COLUMN_FIELD_PATHS 视图的查询必须具有数据集限定符。提交查询的用户必须能够访问包含这些表的数据集。

要运行查询，请执行以下操作：

Console

1. 在 GCP Console 中打开 BigQuery 网页界面。

   转到 BigQuery 网页界面

2. 在查询编辑器框中输入以下标准 SQL 查询。 INFORMATION_SCHEMA 需要标准 SQL 语法。标准 SQL 是 GCP Console 中的默认语法。

   SELECT
    *
   FROM
    `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
   WHERE
    table_name="commits"
    AND column_name="author"
    OR column_name="difference"
   

   注意：INFORMATION_SCHEMA 视图名称区分大小写。

3. 点击运行。

命令行

使用 query 命令并使用 --nouse_legacy_sql 或 --use_legacy_sql=false 标志指定标准 SQL 语法。INFORMATION_SCHEMA 查询需要标准 SQL 语法。

要运行查询，请输入以下命令：

bq query --nouse_legacy_sql \
'SELECT * FROM `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE table_name="commits" AND column_name="author" OR column_name="difference"'

结果应如下所示。为确保可读性，table_catalog 和 table_schema 会从结果中排除。

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  

列出数据集中的表

您可以通过以下方式列出数据集中的表：

• 使用 GCP Console 或经典版 BigQuery 网页界面
• 使用 bq ls CLI 命令
• 调用 tables.list API 方法。

所需权限

要列出某个数据集中的表，您必须分配有数据集的 READER 角色，或者必须分配有包括 bigquery.tables.list 权限的项目级层 IAM 角色。如果您拥有项目级层的 bigquery.tables.list 权限，则可列出项目所含任何数据集中的表。除了 bigquery.jobUser 之外，其他所有预定义的项目级层 IAM 角色都具有 bigquery.tables.list 权限。

如需详细了解 BigQuery 中的 IAM 角色和权限，请参阅访问权限控制。要详细了解数据集级层角色，请参阅数据集的初始角色。

列出表

要列出数据集中的表，请执行以下操作：

Console

1. 在网页界面的导航窗格中，点击数据集左侧的向下箭头图标 展开数据集，或点击数据集名称。数据集中的表和视图即会显示。

2. 滚动列表，查看数据集中的表。表和视图由不同的图标进行标识。

传统版界面

1. 在网页界面的导航窗格中，点击数据集左侧的向下箭头图标 展开数据集，或双击数据集名称。数据集中的表和视图即会显示。

2. 滚动列表，查看数据集中的表。表和视图由不同的图标进行标识。

   

命令行

发出 bq ls 命令。--format 标志可用于控制输出。如果要在默认项目以外的项目中列出表，请按以下格式将项目 ID 添加到数据集：[PROJECT_ID]:[DATASET]。

bq ls --format=pretty [PROJECT_ID]:[DATASET]

其中：

• [PROJECT_ID] 是项目 ID。
• [DATASET] 是数据集的名称。

运行该命令时，Type 字段会显示 TABLE 或 VIEW。例如：

+-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

示例：

输入以下命令可列出默认项目中数据集 mydataset 中的表。

bq ls --format=pretty mydataset

输入以下命令可列出 myotherproject 的数据集 mydataset 中的表。

bq ls --format=pretty myotherproject:mydataset

API

要使用 API 列出表，请调用 tables.list 方法。

C#

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 C# 设置说明进行操作。如需了解详情，请参阅 BigQuery C# API 参考文档。

在 GitHub 上查看 反馈

using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Go

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 BigQuery Go API 参考文档。

在 GitHub 上查看 反馈

ts := client.Dataset(datasetID).Tables(ctx)
for {
	t, err := ts.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "Table: %q\n", t.TableID)
}

Java

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 BigQuery Java API 参考文档。

在 GitHub 上查看 反馈

DatasetId datasetId = DatasetId.of(projectId, datasetName);
Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
for (Table table : tables.iterateAll()) {
  // do something with the table
}

Node.js

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 Node.js 设置说明进行操作。如需了解详情，请参阅 BigQuery Node.js API 参考文档。

在 GitHub 上查看 反馈

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const datasetId = "my_dataset";

// Create a client
const bigqueryClient = new BigQuery();

async function listTables() {
  // Lists tables in "my_dataset".

  // List all tables in the dataset
  const [tables] = await bigqueryClient.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}
listTables();

PHP

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 PHP 设置说明进行操作。如需了解详情，请参阅 BigQuery PHP API 参考文档。

在 GitHub 上查看 反馈

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

试用此示例之前，请按照《BigQuery 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 BigQuery Python API 参考文档。

在 GitHub 上查看 反馈

from google.cloud import bigquery

# TODO(developer): Construct a BigQuery client object.
# client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

在尝试此示例之前，请先按照 BigQuery 快速入门：使用客户端库中的 Ruby 设置说明进行操作。如需了解详情，请参阅 BigQuery Ruby API 参考文档。

在 GitHub 上查看 反馈

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

后续步骤

• 如需详细了解数据集，请参阅数据集简介。
• 如需详细了解如何处理表数据，请参阅管理表数据。
• 如需详细了解如何指定表架构，请参阅指定架构。
• 如需详细了解如何修改表架构，请参阅修改表架构。
• 如需详细了解如何管理表，请参阅管理表。
• 要查看 INFORMATION_SCHEMA 的概览，请转到 BigQuery INFORMATION_SCHEMA 简介。