高级指南：使用 BigQuery 分析变异

本页面介绍了使用 BigQuery 分析变异的高级方法。

本教程中的数据来自 Illumina Platinum Genomes 项目。 数据被加载到使用 BigQuery 变异架构的 BigQuery 表中。该表的名称为 platinum_genomes_deepvariant_variants_20180823。

如果您的变异数据位于使用 BigQuery 变异架构的 BigQuery 表中，则可以直接将本教程中的查询应用于您的数据。如需了解如何将变量数据加载到 BigQuery 的信息，请参阅有关使用转换流水线的文档。

目标

本教程介绍如何执行以下操作：

  • 获取基因组数据概述。
  • 了解非变异段如何表示。
  • 了解变异调用的表示方式。
  • 了解变异调用质量过滤器的表示方式。
  • 聚合分级列。
  • 压缩查询。
  • 计算不同的行。
  • 将行分组。
  • 编写用户定义的函数。

本教程还介绍了如何查找以下信息：

  • 表中的行数
  • 变异调用的数量
  • 单个样本的变异调用
  • 样本数
  • 每条染色体的变异
  • 单个样本的高品质变异

费用

在本文档中，您将使用 Google Cloud 的以下收费组件：

  • BigQuery

您可使用价格计算器根据您的预计使用情况来估算费用。 Google Cloud 新用户可能有资格申请免费试用。

须知事项

  1. 登录您的 Google Cloud 账号。如果您是 Google Cloud 新手，请创建一个账号来评估我们的产品在实际场景中的表现。新客户还可获享 $300 赠金，用于运行、测试和部署工作负载。

  2. 在 Google Cloud Console 中的项目选择器页面上，选择或创建一个 Google Cloud 项目。

    转到“项目选择器”

  3. 确保您的 Google Cloud 项目已启用结算功能。

  4. 在 Google Cloud Console 中的项目选择器页面上，选择或创建一个 Google Cloud 项目。

    转到“项目选择器”

  5. 确保您的 Google Cloud 项目已启用结算功能。

  6. 您需要熟悉 BigQuery 变体模式。

查看表的架构和数据

访问该表并查看架构

Illumina Platinum Genomes platinum_genomes_deepvariant_variants_20180823 表是公共资源。

表中的变异和无变异片段

Illumina Platinum Genomes 数据使用 gVCF 格式，这意味着表中有些行包含非变体。这些非变异也称为“参考调用”。

在表中，无变异片段通常以下列方式表示：

  • 零长度的 alternate_bases 值
  • 使用文本字符串 <NON_REF> 作为 alternate_bases.alt 值
  • 使用文本字符串 <*> 作为 alternate_bases.alt 值

无变异片段的表示方式通常取决于生成源数据的变异检出程序。platinum_genomes_deepvariant_variants_20180823 表中的变异已使用 DeepVariant 检出，后者使用 <*> 表示法。

下表显示了一些行，这些行包含表示非变体段的值。这些细分会显示以下信息：

  • 染色体 1 上的 10 碱基的参考块
  • 参考块从位置 1000 开始
  • 位置 1000 处的参考碱基是 A
  • 未显示块的其他位置处的参考碱基

在下表中，alternate_bases REPEATED RECORD 列未包含任何值，表示这是一个长度为 0 的 ARRAY。

reference_name start_position end_position reference_bases alternate_bases.alt
1 1000 1010 A

在下表中，alternate_bases REPEATED RECORD 列的长度为 1，它包含文本字符串 <*>。

reference_name start_position end_position reference_bases alternate_bases.alt
1 1000 1010 A <*>

本指南中使用的查询使用上表中的表示法。

如需了解表示基因组中无变异位置的详情，请参阅 VCF 规范。

查看表数据

如需查看 platinum_genomes_deepvariant_variants_20180823 表中的数据，请完成以下步骤：

  1. 在 Google Cloud 控制台的 BigQuery 页面中查看表。

    转到 BigQuery 页面

    此时会显示有关该表的信息。该表包含 19.6 GB 的数据，拥有超过 1.05 亿行。

  2. 单击预览以查看表中的某些行。

查询表格

查看表架构及某些行后，开始发出查询并分析数据。在继续操作之前，请确保您熟悉 BigQuery 使用的标准 SQL 查询语法。

计算表中的总行数

要查看表中的行数，请执行以下操作：

  1. 在 Google Cloud 控制台中转到 BigQuery 页面。

    转到 BigQuery 页面

  2. 点击编写查询。

  3. 将下述查询复制粘贴到新查询文本区域中：

     #standardSQL
 SELECT
   COUNT(1) AS number_of_rows
 FROM
   `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823`

  4. 点击运行查询。查询将返回以下结果：

    行 number_of_rows
    1 105923159

计算表中的变异调用数

表中的每一行都在基因组中有个位置，该基因组位置有变异或非变异段之分。

每行还包含一个 call 列，即变异检出的 ARRAY。每个 call 列都包含 name 和其他值，例如基因型、质量列、read 深度以及通常能在 VCF 文件中找到的其他值。

要计算变异检出的数量，请查询 ARRAY 列中的元素数。您可以通过接下来的几种方式执行此操作。每个查询返回值 182104652，这意味着数据集中每行平均有 1.7 个变异检出。

对 call 数组的长度求和

通过添加每个 call 数组的长度，计算所有样本中的变异检出总数：

#standardSQL
SELECT
  SUM(ARRAY_LENGTH(call)) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823`

查询将返回以下结果：

行 number_of_calls
1 182104652

使用 JOIN 联接每一行

通过在 call 列的每一行上使用 JOIN 来计算所有样本中的变体调用总数。该查询使用英文逗号 (,) 运算符，它是 JOIN 的简写表示法。联接到 call 列会对 call 列执行隐式 UNNEST 操作。

#standardSQL
SELECT
  COUNT(call) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call

查询将返回以下结果：

行 number_of_calls
1 182104652

对 call 列中的 name 进行计数

计算所有样本中变异检出总数的第三种方法是对 call 列中的 name 值进行计数。每个 call 列都必须仅有一个 name 值，因此您可以运行以下查询：

#standardSQL
SELECT
  COUNT(call.name) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call call

查询将返回以下结果：

行 number_of_calls
1 182104652

计算变异和非变异段

要计算表中变异和非变异段的数量，请先运行查询以过滤掉非变异段：

#standardSQL
SELECT
  COUNT(1) AS number_of_real_variants
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call call
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.alternate_bases) AS alt
          WHERE
            alt.alt NOT IN ("<NON_REF>", "<*>"))

查询将返回以下结果：

行 number_of_real_variants
1 38549388

如计算变异检出数量中所示，表中的变异检出总数为 182104652，该结果表明，表中的大多数行都是无变异片段。

如表中有关变异和无变异的部分所示，至少有三种方法可以将一个变异行分类为无变异片段。在上面的查询中，WHERE 子句包含 alternate_bases 列的值为实际变异的行，也就是说并非特殊标记值，比如 <*> 或 <NON_REF>。

对于表中的每一行，系统会对该行的 alternate_bases 列发出子查询，为不是 <NON_REF> 或 <*> 的 alternate_bases 值返回 1 值。子查询返回的行数是变异片段的数量。

以下查询显示如何计算非变异段的数量：

#standardSQL
SELECT
  COUNT(1) AS number_of_non_variants
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call call
WHERE
  NOT EXISTS (SELECT 1
                FROM UNNEST(v.alternate_bases) AS alt
              WHERE
                alt.alt NOT IN ("<NON_REF>", "<*>"))

查询将返回以下结果：

行 number_of_non_variants
1 143555264

将实际变异 (38549388) 的数量与非变异段 (143555264) 的数量相加即变异调用的总数。

计算每个样本调用的变异数量

检查表中的顶级行后，您可以开始查询子行。这些行包括诸如进行过变异检出的各个样本之类的数据。

表中的每个变异都有零个或多个 call.name 值。一个特定的 call.name 值可以出现在多行中。

要计算每个检出集出现的行数，请运行以下查询：

#standardSQL
SELECT
  call.name AS call_name,
  COUNT(call.name) AS call_count_for_call_set
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
GROUP BY
  call_name
ORDER BY
  call_name

运行查询将返回六行。每个 call_name 对应一名进行过基因测序的人类个体：

行 call_name call_count_for_call_set
1 NA12877 31592135
2 NA12878 28012646
3 NA12889 31028550
4 NA12890 30636087
5 NA12891 33487348
6 NA12892 27347886

人类通常并没有 call_count_for_call_set 的值中显示的 3000 万种变异。因此请过滤掉无变异片段，仅计算变异行：

#standardSQL
SELECT
  call.name AS call_name,
  COUNT(call.name) AS call_count_for_call_set
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.alternate_bases) AS alt
          WHERE
            alt.alt NOT IN ("<NON_REF>", "<*>"))
GROUP BY
  call_name
ORDER BY
  call_name

查询将返回以下结果：

行 call_name call_count_for_call_set
1 NA12877 6284275
2 NA12878 6397315
3 NA12889 6407532
4 NA12890 6448600
5 NA12891 6516669
6 NA12892 6494997

变异的数量现在接近 600 万，这更接近人类常见的变异数量。请继续阅读下一部分，了解按基因型过滤真实变异。

通过基因型过滤出真实变异

表中的变异包含未检出项，以 -1 的 genotype 值表示。这些变异不被视为人类个体的真实变异，因此您必须将其过滤掉。真实变异只能包含基因型大于零的调用。如果调用仅包含无调用 (-1) 或引用 (0) 的基因型，则它们不是真实变异。

要按基因型过滤变异，请运行以下查询：

#standardSQL
SELECT
  call.name AS call_name,
  COUNT(call.name) AS call_count_for_call_set
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
WHERE
  EXISTS (SELECT 1 FROM UNNEST(call.genotype) AS gt WHERE gt > 0)
  AND NOT EXISTS (SELECT 1 FROM UNNEST(call.genotype) AS gt WHERE gt < 0)
GROUP BY
  call_name
ORDER BY
  call_name

查询将返回以下结果：

行 call_name call_count_for_call_set
1 NA12877 4486610
2 NA12878 4502017
3 NA12889 4422706
4 NA12890 4528725
5 NA12891 4424094
6 NA12892 4495753

计算表中的样本

在计算每个样本检出的变异数量时，每个查询返回六行，且每行均包含 call_name 值。如需查询并获取行数的值，请运行以下查询：

#standardSQL
SELECT
  COUNT(DISTINCT call.name) AS number_of_callsets
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v,  v.call

查询将返回以下结果：

行 number_of_callsets
1 6

计算每条染色体的变异数

要计算每条染色体的变异数，请运行以下查询。查询执行以下操作：

  • 计算至少有一个变异调用且至少有一个基因型大于 0 的所有行。
  • 按染色体对变异行进行分组并对每个组进行计数。
#standardSQL
SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  reference_name
ORDER BY
  CASE
    WHEN SAFE_CAST(REGEXP_REPLACE(reference_name, '^chr', '') AS INT64) < 10
      THEN CONCAT('0', REGEXP_REPLACE(reference_name, '^chr', ''))
      ELSE REGEXP_REPLACE(reference_name, '^chr', '')
  END

运行该查询会返回染色体的名称 (reference_name) 以及每条染色体的变异行数：

行 reference_name number_of_variant_rows
1 chr1 615000
2 chr2 646401
3 chr3 542315
4 chr4 578600
5 chr5 496202
... … …

计算每个样本的高质量变异

使用多个 FILTER 值查询检出

VCF 规范描述了可用于标记不同质量的变异检出的 FILTER 列。

以下查询显示如何查看数据集的每变异检出 FILTER 值：

#standardSQL
SELECT
  call_filter,
  COUNT(call_filter) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v,
  v.call,
  UNNEST(call.FILTER) AS call_filter
GROUP BY
  call_filter
ORDER BY
  number_of_calls

查询将返回以下结果：

行 call_filter number_of_calls
1 RefCall 11681534
2 PASS 26867854

PASS 值表示对应的变异检出为高质量。

FILTER 高质量变异检出

在分析变异时，您可能希望过滤掉较低质量的变异。 如果 FILTER 列包含值 PASS，则该列可能不包含任何其他值。您可以通过运行以下查询来验证这一点。该查询还省略了在 FILTER 下不包含 PASS 值的检出。

#standardSQL
SELECT
  reference_name,
  start_position,
  end_position,
  reference_bases,
  call.name AS call_name,
  (SELECT STRING_AGG(call_filter) FROM UNNEST(call.FILTER) AS call_filter) AS filters,
  ARRAY_LENGTH(call.FILTER) AS filter_count
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
WHERE
  EXISTS (SELECT 1 FROM UNNEST(call.FILTER) AS call_filter WHERE call_filter = 'PASS')
  AND ARRAY_LENGTH(call.FILTER) > 1
ORDER BY
  filter_count DESC, reference_name, start_position, end_position, reference_bases, call_name
LIMIT
  10

正如所料，运行该查询返回的结果为零。

计算每个样本的所有高质量检出数量

以下查询显示如何计算每个调用集的所有调用（变异和非变异），并省略使用非 PASS 过滤器的调用：

#standardSQL
SELECT
  call.name AS call_name,
  COUNT(1) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
WHERE
  NOT EXISTS (SELECT 1 FROM UNNEST(call.FILTER) AS call_filter WHERE call_filter != 'PASS')
GROUP BY
  call_name
ORDER BY
  call_name

查询将返回以下结果：

行 call_name number_of_calls
1 NA12877 29795946
2 NA12878 26118774
3 NA12889 29044992
4 NA12890 28717437
5 NA12891 31395995
6 NA12892 25349974

计算每个样本的所有高质量真实变异调用

以下查询显示如何计算每个样本的所有检出（变异和无变异）。它省略了使用非 PASS 过滤器的检出，并且仅包含具有至少一个真实变异的检出，也就是 genotype > 0 的检出：

#standardSQL
SELECT
  call.name AS call_name,
  COUNT(1) AS number_of_calls
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v, v.call
WHERE
  NOT EXISTS (SELECT 1 FROM UNNEST(call.FILTER) AS call_filter WHERE call_filter != 'PASS')
  AND EXISTS (SELECT 1 FROM UNNEST(call.genotype) as gt WHERE gt > 0)
GROUP BY
  call_name
ORDER BY
  call_name

查询将返回以下结果：

行 call_name number_of_calls
1 NA12877 4486610
2 NA12878 4502017
3 NA12889 4422706
4 NA12890 4528725
5 NA12891 4424094
6 NA12892 4495753

最佳做法

压缩查询

随着您的查询变得更加复杂，重要的是要保持简洁，以确保其逻辑正确且易于遵循。

以下示例演示如何从计算每条染色体变体数量的查询开始，并逐步使用 SQL 句法规则和用户定义函数对其进行压缩。

如在计算每条染色体的变异数量部分中所述，该查询具有以下要求：

  • 计算至少有一个变异调用且至少有一个基因型大于 0 的所有行。
  • 按染色体对变异行进行分组并对每个组进行计数。

编写此查询可能很复杂，因为要完成第一个任务，您需要在此行级别上执行查询的上下文的同时，在 ARRAY (call) 内查询 ARRAY (genotype)。将行执行上下文保留在行级别，因为您希望生成每个变体的结果，而不是 call 或 genotype 的结果。

借助 UNNEST 函数，您可以对 ARRAY 列执行查询，就像列是表一样。该函数会为 ARRAY 的每个元素返回一行。它也不会更改查询上下文。在 WHERE 子句的 EXISTS 子查询中使用 UNNEST 函数：

#standardSQL
SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call
          WHERE EXISTS (SELECT 1
                          FROM UNNEST(call.genotype) AS gt
                        WHERE gt > 0))
GROUP BY
  reference_name
ORDER BY
  reference_name

查询将返回与计算每条染色体的变异数的示例相同的结果：

行 reference_name number_of_variant_rows
1 chr1 615000
2 chr10 396773
3 chr11 391260
4 chr12 382841
5 chr13 298044
… … …

您可以通过将 EXISTS 子句更改为 call 列的 JOIN（包含 call.genotype 列）来简化查询。英文逗号运算符是 JOIN 的简写表示法。

#standardSQL
SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  reference_name
ORDER BY
  reference_name

此查询有效且简洁，但它不允许您按染色体的递增数字顺序对输出进行排序 (reference_name)，因为 reference_name 中的值是字符串类型，且每个值都包含前缀“chr”。

要以数字方式对输出进行排序，首先从 reference_name 列中移除“chr”前缀，并为其指定别名 chromosome：

#standardSQL
SELECT
  REGEXP_REPLACE(reference_name, '^chr', '') AS chromosome,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  chromosome
ORDER BY
  chromosome

该查询使用 REGEXP_REPLACE 函数将“chr”前缀字符串替换为空字符串。查询随后会更改 GROUP BY 和 ORDER BY 函数以使用计算出的 chromosome 别名。输出仍按字符串排序：

行 chromosome number_of_variant_rows
1 1 615000
2 10 396773
3 11 391260
4 12 382841
5 13 298044
… … …

要以数字方式对输出进行排序，请将 chromosome 列从字符串转换为整数：

#standardSQL
SELECT
  CAST(REGEXP_REPLACE(reference_name, '^chr', '') AS INT64) AS chromosome,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  chromosome
ORDER BY
  chromosome

查询将返回错误，因为并非所有染色体名称都是数字，例如“X”、“Y”和“M”。使用 CASE 函数在染色体 1 到 9 之前添加“0”并移除“chr”前缀：

#standardSQL
SELECT
  CASE
    WHEN SAFE_CAST(REGEXP_REPLACE(reference_name, '^chr', '') AS INT64) < 10
      THEN CONCAT('0', REGEXP_REPLACE(reference_name, '^chr', ''))
      ELSE REGEXP_REPLACE(reference_name, '^chr', '')
  END AS chromosome,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  chromosome
ORDER BY
  chromosome

此时查询将返回正确的输出：

行 chromosome number_of_variant_rows
1 01 615000
2 02 646401
3 03 542315
4 04 578600
5 05 496202
... … …

该查询使用 SAFE_CAST 函数，它为染色体 X、Y 和 M 返回 NULL，而不是返回错误。

作为输出的最后一项改进，再次显示 reference_name 列，而不是将其设置为 chromosome 别名。为此，请将 CASE 子句移动到 ORDER BY 函数：

#standardSQL
SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  reference_name
ORDER BY
  CASE
    WHEN SAFE_CAST(REGEXP_REPLACE(reference_name, '^chr', '') AS INT64) < 10
      THEN CONCAT('0', REGEXP_REPLACE(reference_name, '^chr', ''))
      ELSE REGEXP_REPLACE(reference_name, '^chr', '')
  END

该最终查询与计算每条染色体的变异数显示的查询相同。

编写用户定义的函数

BigQuery 支持用户定义的函数。您可以通过用户定义的函数使用其他 SQL 表达式或其他编程语言（如 JavaScript）来创建函数。

压缩查询中的示例显示了如何构建复杂查询，但该查询过于复杂。

以下查询演示了如何通过将 CASE 逻辑移动到函数中来使查询更简洁：

#standardSQL
CREATE TEMPORARY FUNCTION SortableChromosome(reference_name STRING)
  RETURNS STRING AS (
  -- Remove the leading "chr" (if any) in the reference_name
  -- If the chromosome is 1 - 9, prepend a "0" since
  -- "2" sorts after "10", but "02" sorts before "10".
  CASE
    WHEN SAFE_CAST(REGEXP_REPLACE(reference_name, '^chr', '') AS INT64) < 10
      THEN CONCAT('0', REGEXP_REPLACE(reference_name, '^chr', ''))
      ELSE REGEXP_REPLACE(reference_name, '^chr', '')
  END
);

SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  reference_name
ORDER BY SortableChromosome(reference_name)

以下查询也演示了如何使查询更简洁，但它使用的是 JavaScript 中定义的函数：

#standardSQL
CREATE TEMPORARY FUNCTION SortableChromosome(reference_name STRING)
  RETURNS STRING LANGUAGE js AS """
  // Remove the leading "chr" (if any) in the reference_name
  var chr = reference_name.replace(/^chr/, '');

  // If the chromosome is 1 - 9, prepend a "0" since
  // "2" sorts after "10", but "02" sorts before "10".
  if (chr.length == 1 && '123456789'.indexOf(chr) >= 0) {
    return '0' + chr;
  }

  return chr;
""";

SELECT
  reference_name,
  COUNT(reference_name) AS number_of_variant_rows
FROM
  `bigquery-public-data.human_genome_variants.platinum_genomes_deepvariant_variants_20180823` v
WHERE
  EXISTS (SELECT 1
            FROM UNNEST(v.call) AS call, UNNEST(call.genotype) AS gt
          WHERE gt > 0)
GROUP BY
  reference_name
ORDER BY SortableChromosome(reference_name)

两个查询都返回正确的结果，它们的逻辑更简洁。

改善查询效果并降低费用

BigQuery 价格基于为查询处理的字节数。当处理的数据量减少时，查询效果会变好。BigQuery 界面提供有关自查询启动以来过了多少秒以及查询处理的字节数等数据。如需了解优化查询的详情，请参阅 BigQuery 查询计划说明。

此页面中的一些示例（如计算表中的变体调用数）演示了编写查询的多种方法。要确定哪种查询方法最适合您，请检查不同查询的持续时间，并查看它们处理的数据字节数。

清理

完成本教程后，您可以清理您创建的资源，让它们停止使用配额，以免产生费用。以下部分介绍如何删除或关闭这些资源。

若要避免产生费用，最简单的方法是删除您为本教程创建的项目。

如需删除项目，请执行以下操作：

  1. 在 Google Cloud 控制台中，进入管理资源页面。

    转到“管理资源”

  2. 在项目列表中，选择要删除的项目，然后点击删除。
  3. 在对话框中输入项目 ID，然后点击关闭以删除项目。

后续步骤