Monitoring Query Language 参考文档

这是 Cloud Monitoring Monitoring Query Language 的参考手册。它涵盖以下主题：

  • Monitoring Query Language 访问的时间序列数据库的底层数据模型。

  • 查询的结构和语义。

  • 对构建查询的每个操作和函数的说明。

数据模型

Cloud Monitoring 使用一个时间序列数据库，其中包含其针对所监控的每个对象（称为受监控的资源）提取的所有测量结果。以下描述了该数据库的逻辑结构。

基本元素是一个时间序列，其数据由对受监控资源的观察情况组成。

数据库中的时间序列按逻辑组织到关系型表中，每个表包含具有共同含义和结构的时间序列。这些表被返回数据、生成图表和计算提醒的查询引用。

该数据库还包含元数据，元数据是与受监控资源关联的缓慢变化的值，由用户配置或由实现受监控资源类型的服务设置。

时间序列

一个时间序列是一系列已命名的点，每个点代表一个测量值和该值所作用的时间。时间序列由三部分组成：类型（指定时间序列的结构）、标识符（唯一命名时间序列）和历史记录（包含时间序列数据）。本部分对这三个部分分别进行说明。

时间序列类型指定时间序列标识符和时间序列历史记录的结构。它由两部分组成：

  • 受监控的资源类型 （在此处列出）命名受监控的特定种类的受监控资源，例如 Compute Engine 实例 (gce_instance) 或 Cloud SQL 数据库 (cloudsql_database)。它有一组标签描述符，用于唯一标识该类型的受监控资源的一个实例。

  • 指标类型（在此处列出）描述可在受监控的资源上进行的特定种类的测量，例如，名为 compute.googleapis.com/instance/disk/read_bytes_count 的指标测量一个 Compute Engine 实例从磁盘读取的字节，名为 cloudsql.googleapis.com/database/disk/bytes_used 的指标测量一个 Cloud SQL 数据库的数据利用率。指标类型指定了测量的值的类型、测量的单位以及时间序列的种类。它可以指定标签描述符，以区分测量同一事物的不同方面的时间序列。例如，command 指明将哪个命令计入 appengine.googleapis.com/memcache/operation_count 指标。

请注意，受监控的资源类型和指标类型分别由 MonitoredResourceDescriptor 和 MetricDescriptor 描述。它们描述了类型。每个都包含一个名为 type 的字段，其中包含受监控的资源或指标类型的名称。

时间序列标识符是时间序列的名称，用于在所有相同类型的时间序列中唯一标识一个时间序列。它由一组值组成，每个值对应于构成时间序列类型的受监控的资源类型和指标类型中指定的每个标签描述符。

  • 受监控的资源类型的标签可唯一标识时间序列测量的受监控资源类型的某个特定实例。例如，gce_instance 受监控的资源具有 project_id、instance_id 和 zone 标签，这些标签唯一标识了一个特定的 Google Compute Engine 虚拟机。

  • 指标类型的每个标签标识时间序列呈现给定指标的哪个特定种类的测量结果。例如，status 表示在 appengine.googleapis.com/memcache/operation_count 指标中计算的命令状态可能有一个值 'HIT' 表示计算命中的时间序列，而 'MISS' 表示计算未命中的时间序列。

时间序列历史记录是点的时间顺序序列，每个点表示在某个时刻或某个时间段内对一个或多个值（例如 CPU 负载或温度和湿度）的同时测量。一个点包含两个元素：

  • 一个点在时间中的范围由结束时间（始终存在）和开始时间（可能存在，也可能不存在）组成。如果开始时间不存在，则点的范围是由结束时间确定的单个时间点。如果提供了开始时间，则其必须早于结束时间，并且点的范围是从开始时间开始到结束时间结束的时间间隔。

    时间序列中任意两个点的范围不能相同。此外，时间序列中点的范围受指标类型指定的时间序列种类的限制，如下所述。

  • 点的值表示同时测量一个或多个值（例如 CPU 负载或温度和湿度），这些值作用于该点的范围指定的时间。指标类型描述每个测量值，并为其指定名称和值类型。如果有多个测量值，则这些值具有特定顺序，并且可以根据这些值的索引按该顺序引用它们。

    存储在时间序列数据库中的典型时间序列的每个点有一个值。时间序列类型中的指标名称是一个 URI，单个值的名称是指标名称中最后一个 / 之后的部分。例如，指标 appengine.googleapis.com/memcache/operation_count 有一个名为 operation_count 的值列。

    一个时间序列（即查询的输出）可能有多个点，其类型、名称和顺序由查询提供。

    如果时间序列值的类型为 Int、Double 或 Distribution，则指标类型还可以为时间序列值指定测量单位。这些单位使用度量单位统一代码 (UCUM) 的子集指定。例如，ms 表示毫秒，By 表示字节。如需了解详情，请参阅度量单位。

一个点中的每个值都有一个特定的值类型，由时间序列类型中的指标类型指定。此外，时间序列标识符中的每个标签都有一个值类型，由时间序列类型的受监控资源或指标类型中的标签描述符指定。值类型如下所示。

  • Int：64 位有符号整数。

  • String：UTF-8 编码的 Unicode 字符串。

  • Bool：布尔值。

  • Double：64 位IEEE 浮点值。

  • Distribution：包含直方图和统计信息的复杂值，用于提供 Double 值的总体（集）摘要描述。此值的各个部分如下所示：

    • 总体中值的数量。
    • 总体中值的总和。
    • 总体中值的方差和。
    • 分桶规范，用于表示直方图中分桶之间的边界。分桶包含介于该分桶的下限和上限之间的值的数量。
    • 一个直方图，提供每个分桶中值的数量。

    这些部分足以额外计算总体的均值、方差、标准差和百分位的估算值。

点值的类型可以是以上任意一种。时间序列标识符标签类型只能是 String、Int 或 Bool。

除了这些类型之外还有另外两种类型，它们用于点的开始和结束时间，或用于描述查询中的时间和时长。

  • Date：以 Unix 纪元为起点计算的特定时间点。它是与时区无关的时间点表示法。点的开始和结束时间属于此类型。

  • Duration：时长。此时间没有特定的度量单位（但最大分辨率为微秒级），但在转换为 Int 或 Double 时将采用特定单位（例如秒）。

每个类型（Date 和 Duration 除外）的值集中都包含一个称为 no-value 的值，表示没有具体的值。在两种情况下会用到这个值：

  • 当没有已知的特定值时，例如当存在导致值无法计算的错误（例如除以 0）时。

  • 如果时间序列类型要求一个标签，但该标签没有已知的值，则 no-value 将为该标签的值。如果在收集指标时不存在已知值，或者查询生成了时间序列且生成标签值的计算未生成值，就可能出现这种情况。请注意，no-value 是一个独特的值，可以将时间序列标识符与给定标签具有实际值的任何其他标识符区分开来。

no-value 与 IEEE NaN 和空字符串值不同。一个点中的任何值都不能为 no-value。

时间序列种类描述时间序列中点的值的含义，并限制每个点的范围。有三个时间序列种类：

  • 采样平均值：采样平均值时间序列中一个点的值是在点的结束时间的测量值。采样平均值数据流中的点没有开始时间，因此其范围是单个时间点。一个点的值可以表示以下各项之一：

    • 对某些变量（例如队列的长度或使用的内存量）进行的采样。

    • 在该点的时间上为真的状态质量，并且在下一个时间点之前将保持为真。

    • 某些数量（平均值、最大值等）的摘要，这些数量作用于时间序列中该点与上一个点之间的时间段。

  • 增量：对于数值（Int 或 Double），每个点都表示某个测量值在点的范围内（即该点的开始时间和结束时间之间）的变化。对于一个 Distribution 值，它是该点的范围内产生的数值的总体。增量时间序列种类的值必须为 Int、Double 或 Distribution 类型。

    对于增量时间序列，任意两个点的范围不能重叠，因此每个点代表测量值（数值）或值的不相交总体（分布）的独立变化。理想情况下，每个点的范围紧随上一个点的范围开始，从而使时间序列是对其覆盖的时间范围的完整描述。

  • 累积：这可以视为范围重叠的增量时间序列。限制条件是，如果两个点的范围重叠，则它们必须具有相同的开始时间。因此，对于某个测量值，每个点表示相对于上一个具有相同开始时间的点的累积增加。

    累积指标是从外部数据源收集时间序列的可靠方式：

    • 每次收集值后，数据源不需要重置计数器或累加器，并且可以很容易地在多个时间段内监控数据源。

    • 如果缺少某些点，累计数量不会丢失；下一个点包含自开始时间起的所有数量，包括来自缺少点的数量。只有时间分辨率会丢失。

    但是，在查询中，累积时间序列不太常见。为了使对查询返回的时间序列的操作更直接，当提取累积时间序列时，它会自动转换为增量时间序列，方法是使每个点的范围从上一个点开始并使其值为自上一个点以来的变化值。这不会改变存在的信息，但会使每个点独立于其他点。（可以被 fetch_cumulative 替换。）

    对于点具有多个值的时间序列，每个值都有一个时间序列种类，该种类只能是采样平均值或增量。如果任何值为增量种类，则总体指标为增量种类（从而每个点都有开始时间和结束时间）。否则，该指标为采样平均值种类（且仅有结束时间）。

表

具有相同时间序列类型（受监控的资源类型和指标类型）的所有时间序列都按逻辑组织到一个关系型表中。表具有表名称，由受监控的资源类型名称后跟指标类型名称组成。

表中包含的每个时间序列中的每个点都对应一行。表包含以下种类的列：

  • 时间序列标识符列，受监控的资源和指标类型指定的每个时间序列标识符标签对应一列。列名称是标签的名称（其键），列类型是标签的值类型。如果受监控的资源标签和指标标签具有相同的名称，则指标标签列的名称前面会附加 metric.。

    一个时间序列由表中每个对应的时间序列标识符列具有相同值的所有行组成。

  • 一个或多个时间列，来自时间序列中点的范围。始终存在一个结束时间列，该列由函数 end() 访问（我们实际上没有为该列指定名称）。如果指标的时间序列种类为增量，则存在一个开始时间列，该列由函数 start() 访问。（时间序列种类为累积的指标也有开始时间列。）这两个列的值类型均为 Date。

  • 值列，每一列表示时间序列点的值中的每个值。每一列都具有该值的给定名称和类型，并且值列的顺序与指标类型指定的顺序相同。如果受监控的资源或指标标签具有与值相同的名称，则指标类型指定的值名称将附加 value. 前缀作为列名。

一个时间序列中的所有点在时间序列标识符列中具有相同的值，这些列唯一标识该时间序列。时间序列列加上结束时间列构成了表的主键，唯一标识了一行，因此也是一个点。

上面介绍了一个存储表，由存储在数据库中的时间序列构成。查询将存储表作为初始输入，并执行连续表操作（过滤、聚合、联接等），这些表操作会输出中间的派生表。

派生表的结构与存储表的结构相同，并存在以下差异：

  • 如果生成派生表的转换保留了所有受监控的资源标签列，则该派生表仍将与受监控的资源类型相关联。否则，它与受监控的资源类型无关。这对于元数据（将在下一部分中介绍）来说非常重要。

  • 派生表由表类型而不是由受监控的资源类型和指标类型描述。表类型与指标类型相同，但标签集包括时间序列标识符的所有列。时间序列标识符列可能与任何实际受监控的资源类型或指标类型指定的列无关，具体取决于实际派生的表。

  • 派生表没有名称。

元数据

受监控的资源类型可以具有元数据类型，每种类型都将一个值与该特定受监控资源类型的每个实例相关联。每个元数据类型都有名称和值类型（String、Int 或 Bool）。

有两个种类的元数据：

  • 系统元数据，由创建和管理受监控资源的服务创建。系统元数据的名称格式为 metadata.system_labels.<key>，其中 <key> 标识一个特定种类的元数据。

  • 用户元数据，当服务允许用户将标签附加到特定受监控的资源时存在。用户元数据的名称格式为 metadata.user_labels.<key>，其中 <key> 是用户已附加到实体的标签的键。例如：metadata.user_labels.my_key。用户元数据的值始终为 String 类型。

与受监控的资源关联的表（存储表或派生表）可以被视为具有其他虚拟值列，每一列对应与受监控的资源类型关联的一个元数据类型。对于表中的每一行，元数据列包含该元数据在该行的结束时间列中的时间时的值。这些额外的元数据列实际上不是表的一部分，但您可以在对表行进行运算的表达式中提供元数据的名称，从而在查询表达式中引用它们。

校准

如果某个时间序列的点的结束时间仅定期发生，则该时间序列是在时间上校准的（或仅称为校准）。如果一个时间序列中每个点的结束时间与校准基准时间之差（在其之前或之后）均为校准时间段的倍数，我们称该“时间序列”是相对于特定的校准基准时间和时间段校准的。例如，如果校准基准时间为 10:03，校准时间段为 5 分钟，那么 9:48、09:53、09:58、10:03、10:08 都将是点的有效结束时间。

如果表的时间序列的时间序列种类为增量，则每个点的开始时间与结束时间之差必须为校准时间段的长度，从而使每个点的时长相等。具有累积开始时间的表无法校准，因为通常不可能将点的开始时间在不同的时间序列之间对齐。

如果组成一个表的所有时间序列都相对于相同的校准时间和时间段校准，则该表相对于该校准时间和时间段校准。

表校准后，不同时间序列中的点会按时间对齐。这样就可以将不同的时间序列组合起来进行运算。例如，如果想要获得一个表示所有受监控资源的某个指标的总和的时间序列，则需要各个时间序列中的点“对齐”，即具有相同的校准。这样，生成的时间序列中的点的值就是各时间序列中相同时间点的值的总和。

语法和语义

词汇元素

查询的文本由一系列“令牌”组成，这些令牌根据以下语法规则描述：

  • 令牌是一个全大写的非终结符号，根据以下语法进行描述。
  • 令牌内部没有空格（base_string 除外）。空格可以是空格、制表符、换行符和备注。备注是以 # 开头并以换行符结尾的任意文本（但不在 base_string 中）。
  • 忽略令牌之间的空格（用于分隔令牌的空格除外）。
  • 如果此语法允许将两个令牌识别为一个令牌（BARE_NAME 除外，它仅在特定上下文中识别），则两个相邻令牌必须用空格分隔。
ID : letter { letter_num_under } .
QUOTED_COLUMN : ( 'c' | 'C' ) base_string .
BARE_NAME : ( '/' | letter_num_under ) { letter_num_under | '.' | '/' | '-' } .
NUMBER : digit { digit } [ fraction | '.' ] [ exponent ] | fraction [exponent] .
STRING : [ 'r' | 'R' ] base_string .
DURATION : digit { digit } ( 's' | 'ms' | 'us' | 'm' | 'h' | 'd' | 'w' ) .
DATE : ( 'd' | 'D' ) base_string .

letter_num_under : letter | digit | '_' .
base_string : '\'' any-but-quote '\'' | '"' any-but-quote-quote '"' .
fraction : '.' digit { digit } .
exponent : ( 'e' | 'E' ) [ '-' | '+' ] digit { digit } .

letter - an ASCII letter
digit  - an ASCII digit
any-but-quote - any Unicode character except the ASCII control codes or `'`.
any-but-quote-quote - any Unicode character except the ASCII control codes or `"'.

标识符 (ID) 用于命名 Monitoring Query Language 中的内置表操作和函数，以及命名表达式中的列和元数据。语法区分 ID 可以作为表操作或函数名称的位置，以及 ID 可以作为列名称的位置，因此没有不可用作列名称的“预留”标识符列。QUOTED_COLUMN 用于提供不会解析为标识符的列名称。示例：c'total cpu'。

NUMBER、STRING、DURATION、DATE 令牌标识字面量值。NUMBER 可以后跟 unit，后者提供该字面量值的 STRING 形式的 度量单位。STRING 可能包含 Unicode 字符。如果它未以 r 或 R 为前缀，则将识别为常规转义序列。DURATION 的后缀表示时间段的命名方式：秒、毫秒、微秒、分钟、小时、天或周。日期中的 base_string 包含一个 2010/06/23-19:32:15-07:00 格式的日期，其中第一个 - 可以是一个空格，时区 (-07:00) 可以舍弃（秒、分钟、或小时也可以舍弃）。

剩下的令牌是标点符号和运算符令牌，在后面的语法中用引号引起（例如 '^' 或 '<='）。这些令牌是 ^、<=、<、==、=、=~、>=、>、||、|、_、-、,、;、::、:、!=、<>、!~、!、//、/、.、(、)、[、]、{、}、*、&&、%、+。

查询结构

一个查询由一系列表操作 (table_op) 组成，这些操作通过竖线运算符 (|) 连接在一起。每个表操作都将表作为输入并生成表作为输出。一个表操作输出的表会传递到下一个表操作中，然后它会使用这些表来生成自己的表输出。

query : table_op { '|' table_op } .
table_op : basic_table_op | grouped_table_op | shortcut_table_op .

basic_table_op : ID [ arg { ',' arg } ] .
arg : table_name | expr | map .

grouped_table_op:  '{' query { ';' query } '}' .

表操作 (table_op) 有三个种类：

  • basic_table_op 以命名要执行的操作种类的 ID 开头（如此处所述）。后面跟着参数 (arg)，参数提供表操作将执行的操作的详细信息。每个种类的 basic_table_op 将零个、一个或多个表作为输入，并输出一个表。

  • grouped_table_op 由查询的有序列表组成。每个查询都会生成一个表，而 grouped_table_op 的结果是这些表的一个有序列表。每个查询的输入为相同的零个或多个作为 grouped_table_op 的输入的输入表。

  • shortcut_table_op 是 basic_table_op 的快捷表示法（如此处所述）。

一个 table_op 输出的表通过竖线运算符 (|) 作为输入传递到下一个 table_op。以下是将竖线运算符左侧的表操作（称为生产方）输出到竖线运算符右侧的表操作（称为使用方）的规则：

  • 没有表输入的表操作不能是使用方。

  • 对于输出单个表的生产方和接受单个表的使用方，生产方输出表是使用方的输入。

  • 对于输出多个表的生产方和接受单个表的使用方，系统会对每个输入表单独应用使用方。使用方表操作为每个输入表输出一个表。

  • 对于输出多个表的生产方和接受多个表的使用方，所有生成的表都输入到使用方。

  • 对于生成单个表的生产方和一个 grouped_table_op 使用方，该单个表是 grouped_table_op 中每个 query 的第一个表操作的输入。

  • grouped_table_op 不能是生成多个表的生产方的使用方。

  • grouped_table_op 中每个 query 中的最后一个 table_op 必须仅生成一个表。

表操作的 'arg' 元素向表操作提供有关如何将其输入表处理为输出表的信息。arg 可以是以下三项之一：

  • 表名称 (table_name)，用于命名表或作为要从 Cloud Monitoring 数据库中提取的表的名称的一部分。

  • 表达式 (expr)，这是一个用于计算值的公式。它可以是静态已知的字面量值，也可以是根据表操作的一个或多个输入表的一行或多行的列值计算的值。

  • 映射 (map)，用于描述如何计算表操作输出表中的列。一个 map 包含一个或多个计算列值的 expr。

表名称

table_name 命名受监控的资源类型、指标类型、组或表。它们用于表操作，这些表操作从时间序列数据库提取表以进一步处理。

table_name : name { '::' name } .
name : string | BARE_NAME | ID .

单个 name 是指一个受监控的资源类型或一个指标类型，例如受监控的资源类型 gce_instance 或 aws_dynamodb_table，或指标类型 loadbalancing.googleapis.com/http/backend_latencies。

还可以使用组名称或受监控的资源类型名称后跟 :: 和组名称来命名受监控的资源类型。前者可在组指定了单个受监控的资源类型时使用，后者可在组未指定单个受监控的资源类型时使用。

存储表名称由受监控的资源类型名称后跟 :: 和指标类型名称构成。例如 gce_instance :: loadbalancing.googleapis.com/http/backend_latencies。

表达式

表达式 (expr) 是用于计算值的公式。它用作表操作的参数，帮助描述表操作将在其一个或多个输入表上执行的转换。expr 可以是字面量表达式，也可以是动态表达式。

如果 expr 是字面量，则它仅由字面量值和参数为字面量值的简单函数调用组成。此类表达式的值在查询应用于任何表之前确定。

如果 expr 是动态的，则可以包含对表列的引用，并用于根据输入表的一行或多行计算值。动态表达式有三种：

  • 值表达式。值表达式会为其应用到的每个输入表行生成一个值。它可能包含对表列的引用，对一个输入行进行计算时，这些引用的计算结果为该行中的相应列值。

  • 聚合表达式。聚合表达式为一组输入表行的生成一个值。它可以分为三部分：

    • 一个或多个值表达式，分别应用于每个输入行，并为每一行生成一个值。这些值表达式是聚合函数的参数。

    • 一个或多个聚合函数，这些函数接受由值表达式生成的输入值的集合，并将其减少为单个结果值。

    • 聚合函数的外部表达式，它使用聚合函数产生的值来生成整个表达式的值。

    例如，在聚合表达式 sum(if(status >= 500, val(), 0)) / sum(val()) 中，各部分如下：

    • 值表达式为 if(status >= 500, val(), 0) 和 val()。这些值将应用于每个输入行以创建两个值集合。

    • 聚合器是两个 sum 函数调用，每个函数调用将作为其参数的值表达式生成的值的集合作为输入。

    • 外部表达式是除法运算符 (/)，它将被应用于每个 sum 聚合函数的最终输出，以生成整个表达式的值。

  • 校准表达式。校准表达式由对校准函数的单个调用组成。校准函数根据输入时间序列生成一个输出值，并由 align 用于生成一个校准表。

每个表达式都由 opnd 元素组成（定义见下文），这些元素由运算符连接。

expr : term { infix_op term } .
term : { prefix_op } opnd .
infix_op : '&&' | '||' | '^'
         | '==' | '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | '=~' | '!~'
         | '+' | '-'
         | '*' | '/' | '//' | '%' .
prefix_op : '+' | '-' | '!' .

运算符根据优先级以常规方式进行运算。下表将运算符分为五组：同一组中的所有运算符具有相同的优先级，优先级更高的组绑定更紧密。优先级相同的运算符按从左到右的顺序应用。每个运算符对应于一个函数（在下表中显示），函数应用于其操作数。

运算符 函数 操作
*
/
//
%		 mul
div
div
rem		 乘
除
整除
整除余数
+
-		 add
sub		 加
减
==   =
!=   <>
<=
>=
>
<
=~
!~		 eq
ne
le
ge
gt
lt
re_full_match
! re_full_match		 相等比较
不等比较
小于或等于比较
大于或等于比较
大于比较
小于比较
正则表达式完全匹配
正则表达式不完全匹配
&& and 逻辑与
|| or 逻辑或

前缀运算符 +、-、! 分别对应于一元函数 pos、neg、not，并在任何中缀运算符之前应用。

因此，a < b && a + b + c / -d == 5 等同于 (a < b) && (((a + b) + (c / (-d))) == 5)，而后者又等同于 and(lt(a, b), eq(add(add(a, b), div(c, neg(d))), 5))。

运算符对操作数 (opnd) 进行运算。

opnd : literal | column_meta_name | '_' | '(' expr ')' | call_chain .

literal : NUMBER [ unit ] | string | DURATION | DATE .
unit : STRING
string : STRING { STRING } .

column_meta_name : id { '.' id } .
id : ID | QUOTED_COLUMN .

每个 opnd 都对应一种特定的值计算方式。

  • literal 是给定字面量令牌的值。

    • NUMBER 字面量可以后跟 unit，后者提供字面量值的度量单位，例如 33 'By' 表示 33 字节。

    • string 由一个或多个连接为一个字符串值的 STRING 令牌组成。因此，'a-' 'b' 与 'a-b' 的值相同。

  • column_meta_name 指定输入表中的列或虚拟元数据列，计算结果为应用表达式的输入行中该列的值。

  • _ 表示默认值。只能作为可选正式参数的实际参数提供。

  • '(' expr ')' 是用英文括号括起表达式，只是 expr 的值。

  • call_chain 是一个或多个链式函数调用：

call_chain : [ ID arg_list ] { '.' call } .
arg_list : '(' [ expr { ',' expr } [ ',' ] ] ')' .
call : ID [ arg_list ] .

call_chain 中的每个 ID 都命名一个应用于零个或多个参数的函数。函数调用的参数可以来自输入表的值列、调用链中较早的 call 的结果或 arg_list 中的 expr 的值。

  • 如果调用链以 ID（且前面没有 .）开头，则被调用函数的参数由以下 arg_list 中的 expr 提供。

    例如，add(error_count, 1) 将函数 add 应用于两个参数：column_meta_name error_count 和 literal 1。这相当于 error_count + 1。

  • 如果 call_chain 以 '.' call 开头，则输入表的值列是被调用函数的第一个参数。如果 call 具有 arg_list，则 arg_list 提供其他参数。

    例如，将 .div 应用于值列为 num 和 den 的表等同于 div(num, den) 或仅 num / den。将表达式 .add(3) 应用于具有单个值列 count 的表等同于 add(count, 3) 或仅 count + 3。

  • 被一个 call（调用链中的第一个调用除外）调用的函数将把调用链中先前调用的函数的输出作为其第一个参数。如果 call 具有 arg_list，则 arg_list 提供其他参数。

    例如，将 .mul(3).div(4) 应用于具有单个值列 error_count 的表相当于 div(.mul(3), 4)，相当于 div(mul(error_count, 3), 4)，相当于 error_count * 3 / 4 或 (error_count * 3) / 4。

请注意，表中的结束时间和开始时间列没有列名称。时间列的值是使用 end 和 start 函数访问的。

地图

map 计算输出行中列的值并为其提供名称。根据 map 的使用位置，它可以是计算输出行的时间序列标识符列的时间序列标识符 map，也可以是计算输出行的值列的值 map。

map : [ modifier ] '[' [ maplet { ',' maplet } ] ']' .
modifier : ID .
maplet : [ column_name ':' ] expr .
column_name : ID | QUOTED_COLUMN .

maplet 中的每个 expr 计算输出列的值，而 column_name 提供列的名称。如果未提供 column_name，则从 expr 构建一个。如果 expr 只是输入列的名称，则 column_name 与之相同。如果应用了函数，则将其添加到名称中。例如，sum(error_count / 3) 的名称将为 error_count_div_sum。

map 计算的输出列（时间序列标识符或值）来自 map 中的 maplet 以及输入表中相应种类的列（时间序列标识符或值）。此操作如何完成取决于 modifier：

  • 无 modifier。输出行的相应列完全由 map 中的 maplet 指定的列构成。列的名称由 ID 或 QUOTED_COLUMN 明确提供，或者由 expr 的格式派生。输出行中列的值是 expr 的值。

    每个 maplet 都必须有一个在输出表的所有列中是唯一的列名称（明确提供或派生）。

    例如，将 [ratio: num/den] 作为值列 map 应用于包含值列 num 和 den 的表将生成包含值列 ratio 的输出表，其中 ratio 列的值是两个输入列的比率。

    将 [zone] 作为时间序列标识符 map 应用于包含时间序列标识符列 project_id、zone 和 instance 的表将生成仅包含 zone 时间序列标识符列的表，其值与 zone 输入表列相同。

  • add。输入行对应种类（时间序列标识符或值）的所有列都包含在输出行中。此外，对于 map 中的每个 maplet，还有一个额外的输出列，其名称和值由 maplet 提供。

    每个 maplet 都必须有一个在输出表的所有列中是唯一的列名称（明确提供或派生）。

    例如，将 add[ratio: num/den] 作为值 map 应用于包含值列 num 和 den 的表将生成包含值列 num、den 和 ratio 的输出表，其中 ratio 列的值是其他两列的比率。

  • update。输入行对应种类（时间序列标识符或值）的列中，列名称不同于 map 中的 maplet 的所有列都包含在输出行中。此外，对于 map 中的每个 maplet，还有一个额外的输出列，其名称和值由 maplet 提供。

    每个 maplet 都必须有一个在输出表的所有列中是唯一的列名称（明确提供或派生）。它可以指定其要替换的输入中相应类型的列。

    例如，以下是一个时间序列标识符 map：

      update[job: re_extract(job, '[^-]*-(.*)', r'\1'),
         kind: re_extract(job, '([^-]*)-.*', r'\1')]

    当应用于包含时间序列标识符列 user、job 和 zone 的表时，将生成包含时间序列标识符列 user、job、zone 和 kind 的输出表。

  • drop。每个 maplet 必须由一个仅包含相应种类的输入列名称的 expr 构成。输出列由相应种类的所有输入列组成，但 maplet 中的 expr 指定的输入列除外。

    每个 maplet 都不能有 column_name，并且 expr 必须只指定输入表中一个相应种类的列。

    例如，将 drop [job, user] 作为时间序列标识符 map 应用于包含时间序列标识符列 user、job 和 zone 的表将生成包含时间序列标识符列 zone 的输出表。

  • ignore。每个 maplet 必须由仅为一个列名称的 expr 组成。如果名称是相应种类的输入列的名称，则该列不会显示在输出列中。如果 maplet 列名称没有指定相应种类的输入表列，则该 maplet 无效。因此，输出列由相应种类的所有输入列组成，但 maplet 中的 expr 指定的输入列除外。

    每个 maplet 都不能有 column_name，并且 expr 必须只是列名称，但不必是输入表中列的名称。如果 maplet 没有指定输入表中的列，则将被忽略。

    例如，将 ignore [job, instance] 作为时间序列标识符 map 应用于包含时间序列标识符列 user、job 和 zone 的表将生成包含时间序列标识符列 user 和 zone 的输出表（忽略了 maplet instance）。

  • rename。每个 maplet 都必须具有明确的 column_name，并且必须有一个只引用输入表中一个相应种类的列的 expr。输出列是输入表中相应种类的所有列，但如果列在 maplet 中被引用，则输出 maplet 中的 column_name 指定的新名称。

    每个 maplet 中的 column_name 在输出表的列名称中必须是唯一的。

    例如，将 rename[numerator : num, denominator : den] 作为值列 map 应用于包含值列 num、den 和 ratio 的输入表将生成包含值列 numerator、denominator 和 ratio 的输出表。

度量单位

每个数值（Int、Double 和 Distribution）都可以附带关联的计量单位，指明该值使用的计量单位。单位由遵循度量单位统一代码 (UCUM) 的子集的字符串表示。例如，一个表示字节数的值的单位为“By”，另一个表示字节传输速率的值的单位为“By/s”。

单位附加到表操作生成的列和表达式的值。它们与列或表达式静态关联，方式与类型相同。任何数字类型的列或表达式都可以具有关联的单位，但这不是必需的。

附加到表中的列的单位来自以下来源：

  • 指标描述符可以为指标的值指定单位，您可以在介绍指标的文档中查看这些单位（例如，此处）。由 fetch 和 metric 表操作生成的表的值列具有由指标描述符指定的单位。

  • 仅为输入表列副本的输出表列具有与输入表列相同的单位。例如，filter 表操作不会更改其输入表的任何列的单位，并将这些单位传递给输出。

  • union 表操作会将多个表合并为一个表，所有表必须具有相同的列。输入表中的每个值列必须要么没有附加单位，要么其单位等效于其他所有输入表的该列所附加的单位（如有）。如果为任何输入表的某个列指定了单位，则在输出表中，该列具有这些单位。如果未为任何输入表的某个列指定单位，则在输出中，该列将没有单位。

  • 对于包含计算输出表列值的 expr 的表操作，输出列的单位为附加到该 expr 的单位，如下所述。

附加到 expr 的单位取决于 expr 的形式：

  • 字面量值本身没有单位。但是，通过在其后添加一个指定单位的字符串，可以为数字（Int 或 Double）字面量提供单位。因此，3 "By" 是值为 3 的 expr，其类型为 Int，单位为字节 (By)。

  • 列引用表达式从输入表中的命名列获取单位（如果命名列有单位）。

  • 函数和运算符从其输入值的单位获取输出值的度量单位。因此，如果 amount 的单位为 By，并且 time 的单位为 s，则 amount / time 的单位为 By/s。接受两个数字参数的函数通常要求两个参数要么都有单位，要么都没有单位。每个函数的文档都说明了该函数对度量单位的处理方式。

    许多函数对单位一致性有要求。例如，add 要求两个操作数具有相同的单位（如果有单位）。每个函数的文档中均对这些要求进行了说明。

  • scale 和 cast_units 函数具有专门针对单位的功能。

    scale 函数会将具有单位的值与一个缩放比例相乘，缩放比例会将该值转换为具有不同单位的值。因此，对于单位为“KiBy”（千字节）的 expr ev，scale(ev, "By") 会将 ev 乘以 1024，并为结果提供单位 By。结果等效于 ev * 1024 'By/KiBy'。

    无论参数的原始单位为何（如有），cast_units 函数都会返回具有指定单位的该参数。因此，cast_units(ev, 'By/s') 会生成 ev 的值，该值保持不变，但单位为 By/s。

MQL 支持的 UCUM 单位子集由遵循以下语法的字符串值提供：

digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
exponent : [ '+' | '-' ] { digit }
simple_unit : [ PREFIX_SYMBOL ] ATOM_SYMBOL
annotatable : '10^' exponent | simple_unit
component : annotatable [ annotation ] | '1'
annotation : “{” ANNOTATION-STRING “}” | annotatable | annotation
unit : component { '.' component } { '/' component }

simple_unit 指定由 ATOM_SYMBOL 提供的单位，该单位以 PREFIX_SYMBOL 提供的缩放比例为前缀（可选）。

ATOM_SYMBOL 提供基本度量单位：

text 含义
s 秒
分钟 分钟（60 秒）
h 小时（60 分钟）
d 天（24 小时）
周 周（7 天）
位 位
提供方： 字节（8 位）
% 10^-2（缩放为 % 的无量纲比值）
m 米
g 克
K 开尔文
C 库仑
Hz 赫兹 (1/s)
J 焦耳 (kg.m.m/s/s)
W 瓦特 (kg.m.m/s/s/s) (J/s)
A 安培 (C/s)
V 伏特 (kg.m.m/s/s/C) (J/C)

PREFIX_SYMBOL 向位于其后的基本单位提供缩放比例：

text 含义 和 WAF
k 千 10^3
M 兆 10^6
G 吉 10^9
T 太 10^12
P 拍 10^15
E 艾 10^18
Z 泽 10^21
是 尧 10^24
m 毫 10^-3
u 微 10^-6
n 纳 10^-9
p 皮 10^-12
f 飞 10^-15
a 阿 10^-18
z 仄 10^-21
y 幺 10^-24
Ki 千比 2^10
Mi 兆比 2^20
Gi 吉比 2^30
Ti 太比 2^40
Pi 拍字节 2^50

无量纲单位可以提供为 1 或 10 的幂（10^ exponent，例如 10^2）。单位 1 是提供给大多数计数器指标的单位。也支持将无量纲比值缩放为百分比 %。因此，10^-2 和 % 是相同的单位。换言之，向百分比添加 3 与向相应的比值添加 .03 是相同的。exponent 的范围是 -128 到 127。

annotation 是可以附加到 annotatable（simple_unit 或 10 的幂）的注释，不会改变单位的含义。未附加到单位的注释会被视为附加到单位 1。因此，{queries}/s 等同于 1/s，其中单位 1 由 {queries} 修饰。

单位字符串可以由多个 component 字符串组成，通过 . 或 / 连接。. 连接符表示单位相乘，而 / 连接符表示单位相除。乘和除均从左到右运算。MQL 支持的 UCUM 单位子集要求所有除法连接符都位于乘法连接符之后。这可避免将加速度单位写为 m/s.s 的问题（m/s/s 才是需要的单位）。请注意，在 UCUM 单位中，m/s.s 与 m.s/s 或 m 相同。

如果两个单位字符串的量纲和比例相同，则它们是等效的，与注释无关。量纲和比例根据传统方式决定：

  • 每个 component 要么为无量纲，要么具有以下某个组合的量纲，包括时间、长度、数据、日期、质量、或电荷。例如，bit 和 By 的量纲均为数据。要确定一个单位字符串的量纲，将每个可注释项转换为其量纲，根据单位字符串进行相乘或相除，并抵消分子和分母中出现的量纲。因此，b.h/s（比特小时/秒）的量纲为数据乘以时间除以时间，时间量纲抵消，余下数据量纲。

  • 每个可注释项都具有相对于其量纲基本单位的比例。例如，h（小时）具有基本单位为 s 的时间量纲，并且缩放比例为 3600（每小时为 3600 秒）。单位字符串的缩放比例是每个 component 的缩放比例相乘和相除以后的组合。

可以通过在数字字面量值后添加所需度量单位的字符串来为其提供单位。因此 3 "m/s" 为值 3 以及单位 m/s，10.8 "km/h" 表示的速度与值 10.8 以及单位 km/h 相同。

使用 scale 函数可以将一个具有单位的值缩放为不同单位但相同量纲的值。例如，MiBy 和 By 的量纲均为数据，缩放比例分别为 8*1024 和 8（相对于数据量纲的基本单位 bit）。通过表达式 scale(x, "By")，单位为 MiBy 的值 x 可以缩放为单位为 By 的值。该表达式将 x 乘以 1024，得到的单位为 By 的值。相当于表达式 x * 1024 "By/MiBy"、size * 1024 "By/MiBy"，生成的表达式的单位为 MiBy.By/MiBy 或仅为 By。

scale 函数检查所请求的单位是否与要缩放的值的单位具有相同量纲。

如果 size 是值单位为“KiBy”的列，则表达式 scale(size, "By") 与 size * 1024 "By/KiBy" 相同，生成的表达式的单位为 MiBy.By/MiBy 或仅为 By。

少数情况下，MQL 会自动调整或提供值单位。

  • 对于需要两个具有等效单位参数的函数 f（add、sub、任意数字比较运算符、if 和 or_else），其中一个参数可以是对 scale 函数的调用（没有第二个单位参数）。如果 f 的另一个参数的单位具有与 scale 函数的参数单位相同的量纲，则 scale 函数的第二个参数将自动设置为 f 另一个参数的单位。这使 f 的两个参数具有相同单位，从而使 f 能够运算。

    例如，+ 运算符要求其参数具有等效单位，因为对两个不同单位的数字进行相加是没有意义的。如果 cache_size 单位为 By，heap_size 单位为 MiBy，则表达式 scale(cache_size) + heap_size 等效于表达式 scale(cache_size, "MiBy") + heap_size

  • 对于任何比较函数，如果一个参数为具有单位的字面量，它与另一个参数具有相同量纲但不同比例，则该字面量会缩放到相同比例。

    例如，如果“cache_size”的单位为 By，表达式 cache_size < 3 "KiBy" 等效于表达式 cache_size < 3072 "By"。请注意，如果 cache_size 类型为 Int，则不同于 cache_size < scale(3 "KiBy", "By")，因为 scale 会将其结果转换为 Double 类型，这可能会降低比较精度。这种情况下的整数缩放会对特定比较结果的溢出进行适当的取整和处理。

  • 对于 mul 的任何参数或 div 的除数，没有单位的字面量将被赋予单位“1”。这考虑了不更改单位的缩放运算（例如，要求计算两倍速率下的情况的运算）。如需更改单位，建议使用 scale，它会自动为转换选择合适的缩放比例。

在计算查询时，单位错误被视为警告，因此查询仍会产生结果。定义提醒时，单位错误被视为实际错误，从而使提醒无法定义。

请务必注意，Duration 和 Date 不是数字类型，并且没有单位。Duration 值 60s 是非数字的时间长度，与 1m 或 60000ms 的时长完全相同。表达式 60s == 60000ms 有效且为 true。

具有时间单位的数值则不同。数字 3 'min' 和 180 's' 是两个具有不同单位的不同数值（3 和 180）。如果不进行缩放，进行比较是无效的。

scale 函数会将 Duration 和 Date 值转换为具有单位的 Double 值。例如，scale(60s, "min")、scale(1m, "min") 和 scale(60000ms, "min") 都将返回单位为 min 的双精度值 1.0。

表操作快捷方式

快捷方式是指定基本表操作的简化方式。

shortcut_table_op : shortcut { ',' arg } .
shortcut : table_name | '(' expr ')' | map | DURATION .

快捷方式表操作有多种形式，每种形式都指定了一种基本表操作：

  • 函数提升快捷方式看起来像是普通的表操作，但表操作以 ID 开头，指定一个函数而不是表操作，后跟的 arg 元素（均为 expr 形式）是函数的参数。

    提升函数的方法是提供一个以该函数为参数的表操作。输入表中的一个或多个值列成为该函数的第一个参数，就好像添加了 . 运算符为前缀。具体的提升如下所示：

    • 一个普通函数成为 value 表运算的参数，计算其输出表的单个值列。

      例如，| add 3 是 value [.add(3)] 的快捷方式，| div 是 | value [.div] 的快捷方式。

    • 一个聚合函数成为 group_by 表操作的第二个参数，其第一个参数为空 map ([ ])。因此，该函数会计算没有时间序列标识符列的输出表（只有一个时间序列的表）的单个值列。

      例如，| min 是 | group_by [], [.min] 的快捷方式。

    • 一个校准函数成为 align 表操作的参数，从而对输入表的时间序列执行指定种类的校准操作。

      例如，| delta 10m 是表操作 | align [.delta(10m)] 的快捷方式。

  • 命名快捷方式以 table_name 开头，可用作 resource、metric 或 fetch 表操作的参数，具体取决于 table_name 命名的是什么。

    例如，| gce_instance 是表操作 | resource gce_instance 的快捷方式，| gce_instance :: compute/instance/cpu/usage_time 是 | fetch gce_instance :: compute/instance/cpu/usage_time 的快捷方式。

  • 过滤快捷方式由括号括起的 expr 组成，后者是 filter 表操作中的谓词。

    例如，| (job == 'search') 是 | filter job == 'search' 的快捷方式。

  • 分组快捷方式以 map 开头，它成为 group_by 表操作的第一个参数。它后面可能跟着一个 arg，这是一个 map，用于描述计算输出表的值列的聚合。

    例如，| [zone] 是 | group_by [zone] 的快捷方式。

  • 数据选取快捷方式以 DURATION 开头，它成为 group_by 表操作的第一个参数。它后面必须跟着一个 arg，这是一个 map，用于描述计算输出表的值列的聚合。

    例如，| 10m, [.sum] 是 | group_by 10m, [.sum] 的快捷方式。

  • 时长快捷方式以 DURATION 开头，后面不跟 arg。它变成一个 for 表操作，为查询操作提供总体范围。

    例如，| 10m 是 | for 10m 的快捷方式。

表操作和函数说明

每个 Monitoring Query Language 表操作和函数说明都以文档签名开头，指示表输入（用于表操作）以及可为表操作或函数提供的参数类型。本部分介绍这些签名的形式。

请注意，这些签名不属于 Monitoring Query Language 本身。它们用于描述 Monitoring Query Language。

表操作签名可以以向表操作描述输入表的类型开头，后跟表操作的名称，后跟描述表操作的有效参数的参数列表。例如，以下是 pick 表操作的签名：

Table   | pick   lit-Int,   [ TSIDSel ], [ Windowed(Num) ]

此表操作以 Table 作为输入（最常见的情况），并有 3 个潜在参数，由 lit-Int、[ TSIDSel ]、[ Windowed(Num) ] 描述。

输入表和 | 是可选的，如果未提供，则表操作不接受输入表。输入表规范为以下之一：

  • Table 表操作的输入是单个表。
  • Table++ 表操作的输入是两个或更多表。
  • Resource 表操作使用由受监控的资源类型指定的表的集合作为输入（包含其类型包括特定受监控资源类型的时间序列的所有表）。
  • ResourceOrTable 允许将 Table 或 Resource 作为输入。

表操作名称后面的参数列表中的每个参数描述符都包含以下部分：

  • 可能被 [ ] 引起，在这种情况下它是可选的。如果实际参数位于所有明确指定的参数之后，则可以将实际参数指定为 _ 或省略。

  • 可能有一个 lit- 前缀，表明参数值必须是我们在计算查询之前已知的常量值。

  • 始终有值类型的名称或一组类型（如下所述），用于描述允许的实际参数类型。

  • 可能有一个指定时间序列种类的后缀，用于限制输入值的时间序列种类。

参数描述符类型名称可以是此处说明的实际类型之一：Bool、Int、Double、Distribution、String、Duration 或 Date。在这种情况下，实际参数必须是同一类型的表达式。

以下说明实际参数必须是分别命名指标、受监控的资源或表的 table_name：

  • MetricName
  • ResourceName
  • TableName

参数描述符可以命名类别，该类别指示实际参数可能是以下某一个类型的表达式：

  • Num：Int 或 Double。
  • Summable：可求和的值类型：Int、Double 或 Distribution。
  • Comparable：可比较的值类型：Int、Double、String、Bool、Duration、Date。
  • ColumnValue：有效的列值类型：Int、Double、String、Bool、Duration 或 Distributio。
  • Windowed(Num)：Num，可能被 within、ago 或 bottom 函数注释。
  • WindowDuration：Duration，可能被 window 或 sliding 注释。
  • BucketSpecification：Distribution 的分桶规范。

表操作可能需要 map 参数，以指定输出行时间序列标识符列或值列。这可以通过以下之一指示：

  • RowToTSID：描述输出表的时间序列标识符列的映射。
  • TSIDSel：指定要保留的时间序列标识符列的映射。map 中的每个 maplet 必须仅由指定一个列（ID 或 column_name）的 expr 组成。例如，[zone, name] 会使输出列仅由输入时间序列标识符列 zone 和 name 组成，所有其他输入列均被舍弃。
  • RowToVal：描述输出表值列的映射。如果将非映射表达式指定为实际参数，则其将提升为包含该表达式的单元素映射。
  • RowSetToVal：按聚合描述输出表值列的映射。如果将非映射表达式指定为实际参数，则其将提升为包含该表达式的单元素映射。
  • DefaultColumns：描述 outer_join 的默认值列的映射。如果将非映射表达式指定为实际参数，则其将提升为包含该表达式的单元素映射。

函数签名以函数名称开头，后跟描述函数有效参数的用括号括起的参数列表，后跟描述函数返回值的返回类型。例如，fraction_less_than 函数的签名如下：

fraction_less_than(Summable,   lit-Num)   → Double

此函数接受由 Summable 和 lit-Num 描述的两个参数，并返回一个 Double 类型的值。对于表操作，参数列表具有上述相同元素。返回类型可以是特定的值类型（表示返回的值属于该类型），或以下类型之一：

  • Num - 如果函数的任何参数为 Double，则为 Double，否则为 Int。
  • ColumnValue - 与函数的第一个实际参数的类型相同。
  • LastArgType - 与函数的最后一个实际参数的类型相同。
  • Windowed() - 与 Windowed 实际参数的类型相同，用 Windowed 类型注释。如果 Windowed 实际参数的类型为 Int，则返回类型为 Windowed(Int)。（请参阅 within、ago 或 bottom 函数。）

函数参数描述符或返回类型可能有一个用于控制参数或结果的时间序列种类的指示符。这些指示符显示为类型的以下后缀之一：

  • .Cumulative、.Delta 或 .Gauge 表明实际参数必须具有给定的时间序列种类。
  • .CumulativeOK 表示实际参数可以是累积类型。
  • .FirstArgKind 表示具有与函数的第一个参数相同的时间序列种类（仅针对返回类型）。

如果参数没有时间序列种类后缀，则该参数的时间序列种类必须是采样平均值或增量。如果返回类型没有时间序列种类后缀，则其时间序列种类将为采样平均值。

函数签名可能还包含以下一条或多条说明：

  • (implicit row input) 表示函数将整行作为隐式输入。例如，hash_tsid 函数生成其输入行的时间序列标识符列的哈希值，但不会将这些列值作为显式参数。
  • (temporal only) 用于聚合函数的签名，表示函数签名仅在进行时间聚合时适用。（但函数的其他签名仍适用。）请注意，这包括在同一表操作中同时进行时间聚合和空间聚合的情况。
  • (sliding temporal only) 用于聚合函数的签名，表示函数签名仅在滑动时间聚合时适用。（但函数的其他签名仍适用。）请注意，这包括在同一表操作中同时进行滑动时间聚合和空间聚合的情况。

表操作

本部分介绍 Monitoring Query Language 中的每个基本表操作。

提取

fetch 表操作的输出是按名称从 Cloud Monitoring 时间序列数据库中检索的一个表。

resource 表操作的输出是名称中具有指定受监控资源类型的所有表。每个 resource 最终都必须跟着一个 metric 表操作，该操作会选择名称中包含该指标的单个表。在执行 metric 表操作之前，也可能进行 filter 表操作来限制生成的表中包含的行。

fetch 从数据库生成一个表。

签名： fetch lit-TableName

fetch 操作从时间序列数据库中提取表，该表的名称是在 TableName 参数中指定的表名称。如果表名称包含未知的受监控资源类型或指标类型名称，则会发生错误。

如果未从给定类型的受监控资源中收集到给定类型的指标，则此表将为空。

如果指标为累积种类，则构成表的时间序列会转换为增量时间序列，其中每个点表示自上一个点以来的值变化。

fetch 操作还可以提取基于特定受监控的资源的所有表，方法是提供受监控的资源的名称并且不提供指标名称。此类 fetch 操作必须后跟 metric操作，后者会选择一个包含特定指标数据的特定表。此 fetch 和后续 metric 之间可能发生的唯一操作是 filter 操作，该操作根据受监控的资源列进行过滤。

如果我们希望提取给定受监控资源的多个指标（如以下示例所示），这种形式的 fetch 会非常有用：

  fetch gce_instance | filter zone = 'asia-east1-a' |
  { metric compute.googleapis.com/instance/cpu/utilization ;
    metric compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div
  gce_instance | (zone = 'asia-east1-a') |
  { compute.googleapis.com/instance/cpu/utilization ;
    compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div

这等同于

  { fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization ;
    fetch gce_instance :: compute.googleapis.com/instance/cpu/reserved_cores
  } | filter zone = 'asia-east1-a' | join | div

metric 从一组表中生成一个特定指标类型的表。

签名：Resource | metric lit-MetricName

metric 表操作接受由未提供指标名称的 fetch 表操作生成的一组表。它会选择一个表来存放由 lit-MetricName 参数指定的指标的数据，并生成该表作为其输出。如果没有给定名称的指标定义，则会发生错误。如果没有包含给定指标名称数据的输入表，则将生成一个空表。

fetch_cumulative 从数据库生成一个具有累积时间序列的表。

签名：fetch_cumulative lit-TableName

fetch_cumulative 表操作与 fetch 表操作相同，但在提取时，累积指标不会自动转换为增量指标。

选择

选择表操作会从输入表中选择行以包含在输出表中。输出表的类型与输入表的类型完全相同。

filter 按谓词过滤输入表中的行。

签名：ResourceOrTable | filter Bool

filter 操作针对由 resource 运算指定的单个输入表或表集合中的每行计算其参数 Bool 表达式。只有一个或多个输入表中该表达式求值为 true 的那些行会保留在一个或多个输出表中。

如果输入是表的集合，则只能在谓词中引用受监控的资源标签（这是所有表共有的）。

top 根据排序值表达式选择最靠前的时间序列。

签名：Table | top lit-Int, [ Windowed(Num) ]

top 表操作为其输入表中的每个时间序列计算一个排序值，并选择其 Int 参数指定的数量的具有最大排序值的时间序列。Windowed 参数表达式计算排序值。

Windowed(Num) 参数应用于时间序列中位于值时间窗口内的行。默认值时间窗口与查询时间窗口相同。如果表达式是聚合表达式（例如 .min），则表示对结束时间戳在值窗口内的所有行的聚合。如果表达式是值表达式（例如 .val(0)/.val(1)），则应用于值窗口中最新的行（如有）。如果一个时间序列在值窗口中没有行，或者 Windowed(Num) 参数没有为一个时间序列生成值，则该时间序列不会包括在输出中。

可以在 Windowed(Num) 参数中使用 within 函数来修改值窗口，方法是提供窗口的开始时间、持续时间和/或结束时间。

示例：

  | top 3

选择时间序列中的最新点值最大的 3 个时间序列。

  | top 7, .max

选择时间序列中在查询窗口内的所有点的最大值值最大的 7 个时间序列。

  | top 3, .min.within(-10h, 1h)

选择 min 缩减器的值最大的 3 个时间序列。该缩减器应用于每个时间序列中落在以下窗口中的行：10 小时前开始且持续时间为 1 小时。

bottom 根据排序值表达式选择最靠后的时间序列。

签名：Table | bottom lit-Int, [ Windowed(Num) ]

bottom 表操作为其输入表中的每个时间序列计算一个 排序值，并选择其 Int 参数指定的数量的具有最小排序值的时间序列。Windowed 参数表达式计算排序值。

Windowed(Num) 参数应用于时间序列中位于值时间窗口内的行。默认值时间窗口与查询时间窗口相同。如果表达式是聚合表达式（例如 .min），则表示对结束时间戳在值窗口内的所有行的聚合。如果表达式是值表达式（例如 .val(0)/.val(1)），则应用于值窗口中最新的行（如有）。如果一个时间序列在值窗口中没有行，或者 Windowed(Num) 参数没有为一个时间序列生成值，则该时间序列不会包括在输出中。

可以在 Windowed(Num) 参数中使用 within 函数来修改值窗口，方法是提供窗口的开始时间、持续时间和/或结束时间。

示例：

  | bottom 3

选择时间序列中的最新点的值最小的 3 个时间序列。

  | bottom 7, .min

选择时间序列中在查询窗口内的所有点的最小值值最小的 7 个时间序列。

  | bottom 3, .max.within(10h)

选择 max 缩减器的值最小的 3 个时间序列。该缩减器应用于每个时间序列中落在以下窗口中的行：10 小时前开始且持续到现在。

top_by 根据排序值表达式在不同组中选择时间序列。

签名：Table | top_by TSIDSel, lit-Int, [ Windowed(Num) ]

top_by 表操作将具有相同时间序列标识符（通过 TSIDSel 参数计算得出）的时间序列归为一组。在指定了相同的 Int 和 Windowed 参数时，按照与 top 相同的方法在每个组中选择时间序列。为每个组中的每个时间序列计算一个排序值，并选择其 Int 参数指定的数量的具有最大排序值的时间序列。Windowed 参数表达式计算排序值。

Windowed(Num) 参数应用于时间序列中位于值时间窗口内的行。默认值时间窗口与查询时间窗口相同。如果表达式是聚合表达式（例如 .min），则表示对结束时间戳在值窗口内的所有行的聚合。如果表达式是值表达式（例如 .val(0)/.val(1)），则应用于值窗口中最新的行（如有）。如果一个时间序列在值窗口中没有行，或者 Windowed(Num) 参数没有为一个时间序列生成值，则该时间序列不会包括在输出中。

可以在 Windowed(Num) 参数中使用 within 函数来修改值窗口，方法是提供窗口的开始时间、持续时间和/或结束时间。

示例：

  | top_by [zone], 1

对于 'zone' 列具有相同值的每组时间序列，此操作选择时间序列中最新点值最大的时间序列。

  | top_by [project_id], 2, .max

对于 'project_id' 列具有相同值的每组时间序列，此操作选择时间序列中在查询窗口内的所有点的最大值值最大的 2 个时间序列。

  | top_by [zone], 1, .min.within(-10h, 1h)

对于 'zone' 列具有相同值的每组时间序列，此操作选择 min 缩减器的值最大的时间序列。该缩减器应用于每个时间序列中落在以下窗口中的行：10 小时前开始且持续时间为 1 小时。

bottom_by 根据排序值表达式在不同组中选择时间序列。

签名：Table | bottom_by TSIDSel, lit-Int, [ Windowed(Num) ]

bottom_by 表操作将具有相同时间序列标识符（通过 TSIDSel 参数计算得出）的时间序列归为一组。在指定了相同的 Int 和 Windowed 参数时，按照与 bottom 相同的方法在每个组中选择时间序列。为每个组中的每个时间序列计算一个排序值，并选择其 Int 参数指定的数量的具有最小排序值的时间序列。Windowed 参数表达式计算排序值。

Windowed(Num) 参数应用于时间序列中位于值时间窗口内的行。默认值时间窗口与查询时间窗口相同。如果表达式是聚合表达式（例如 .min），则表示对结束时间戳在值窗口内的所有行的聚合。如果表达式是值表达式（例如 .val(0)/.val(1)），则应用于值窗口中最新的行（如有）。如果一个时间序列在值窗口中没有行，或者 Windowed(Num) 参数没有为一个时间序列生成值，则该时间序列不会包括在输出中。

可以在 Windowed(Num) 参数中使用 within 函数来修改值窗口，方法是提供窗口的开始时间、持续时间和/或结束时间。

示例：

  | bottom_by [zone], 1

对于 'zone' 列具有相同值的每组时间序列，此操作选择时间序列中最新点值最小的时间序列。

  | bottom_by [project_id], 2, .max

对于 'project_id' 列具有相同值的每组时间序列，此操作选择时间序列中在查询窗口内的所有点的最大值值最小的 2 个时间序列。

  | bottom_by [zone], 1, .min.within(1h)

对于 'zone' 列具有相同值的每组时间序列，此操作选择 min 缩减器的值最小的时间序列。该缩减器应用于每个时间序列中落在以下窗口中的行：10 小时前开始且持续时间为 1 小时。

行修改

map 重写表中每一行的时间序列标识符和值列。

签名：Table | map [ RowToTSID ], [ RowToVal ]

对输入表中的每一行应用两个转换：

  • 如果提供了 RowToTSID 映射，则将其应用于该行的时间序列标识符列，以生成相应输出行的时间序列标识符列。如果未提供 RowToTSID 映射（或以 _ 形式提供），则输出时间序列标识符列与输入相同。

  • 如果提供了 RowToVal 映射，则将其应用于输入行的值列以生成输出行的值列。如果未提供 RowToVal 映射，则输出值列与输入相同。

如果输入中两个不同时间序列的行映射到输出中的同一个时间序列，则会发生动态错误。在这种情况下，系统会丢弃派生自其中一个输入时间序列的行，并提供错误消息。

如果 RowToTSID 映射包含对值列或时间列的引用，则其可能会将单个输入时间序列拆分为多个输出时间序列。因此，当 RowToTSID 映射包含对值列或时间列的引用时，只能将其应用于值列的时间序列种类为采样平均值或增量的表。

value 重写表中每行的值列。

签名：Table | value RowToVal

将 RowToVal 映射应用于输入表中每一行的列，以生成相应输出行的值列。每个输出行都具有与其对应的输入行相同的时间序列标识符和时间列，并且具有由 RowToVal 映射生成的值列。

time_shift 将时间序列在时间上前移。

签名：Table | time_shift lit-Duration

输入表中每一行的一个或多个时间列均增加 Duration 参数提供的数值。这会导致表中的每个时间序列在时间上向前移动。

如果输入表已校准，则移动量必须是校准时间段的偶数倍，以保持输入表的校准。

时间序列校准

align 使用校准函数生成校准表。

签名：Table | align [ Aligner ]

align 表操作使用提供给其 Aligner 参数的校准函数，从其输入表的每个时间序列计算出校准时间序列，从而在其输出表中生成时间序列。

校准基准时间是查询窗口的结束时间，校准时间段根据以下三项之一设置：

  • every 表操作，用于设置此 align 表操作的时间段。

  • 校准器函数要求校准时间段与其窗口宽度相同（请参阅 delta）。

  • 外部图形接口要求特定的校准时间段。

生成校准时间序列的特定方法由提供给 Aligner 参数的校准函数描述。

聚合

聚合表操作将输入表的行分成多组。对于每组输入行，它会为该组计算一个共有的时间序列标识符和时间列，聚合输入行以创建值输出列，并输出具有生成的时间序列标识符、时间和值列的单个行。

聚合有三种

  • 空间聚合。这种形式的聚合会为每个输入行计算新的时间序列 ID 列，并将具有相同新时间序列 ID 列和结束时间的所有行归为一组。此类聚合通常需要校准输入，以便将不同时间序列中的行在时间上对齐，从而将它们归为一组。

  • 时间聚合。这种形式的聚合会计算一组有效的校准输出时间，并为每行计算一个新的结束时间，为其指定最早的校准结束时间（不早于该行的原始结束时间）。具有相同时间序列标识符和结束时间的行将归为一组。

  • 滑动时间聚合。这种形式的聚合与时间聚合类似，不同之处在于一行可能包含在多个组中。它计算一组时间窗口，每个时间窗口的较旧边缘为有效的校准结束时间，并且每个窗口都具有相同的固定宽度。一个行的结束时间是它所在的每个窗口的较旧边缘，并且该行与具有相同时间序列标识符和新结束时间的其他所有行归为一组。当窗口重叠时，一个行可能会被提供多个新的结束时间，因此可能会包含在多个组中。

您可以在一个表操作中将空间聚合与两种时间聚合之一结合。

滑动和非滑动时间聚合之间的一个重要区别是某些聚合器（例如 sum）会为非滑动时间聚合生成具有增量时间序列种类的值，而为动时间聚合生成具有采样平均值种类的值。这是因为，增量时间序列中两个点的时间范围不能重叠，因此无法在增量时间序列输出行的时间列中表示滑动时间聚合的重叠输入窗口。

为行计算新的时间序列标识符时，新的时间序列标识符由 map 参数计算得出。输出行的值列由 map 参数使用计算每个值列的聚合表达式计算得出。

group_by   根据映射的时间序列标识符和时间窗口聚合行。

签名：Table | group_by RowToTSID, [ RowSetToVal ]
          Table | group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
          Table | group_by lit-WindowDuration, [ RowSetToVal ]

group_by 表操作通过映射时间序列标识符列、时间列或同时映射两者来将行分组：

  • 如果提供了 RowToTSID 参数，但未提供 WindowDuration 参数，则计算该映射参数为输入表中的每一行生成的时间序列标识符，并将具有相同的生成时间序列标识符和结束时间的所有列归为一组。

    在这种情况下，group_by 要求将校准表作为输入，以便不同的时间序列具有结束时间相同的点。如果输入表未校准，则将自动插入 align 表操作以提供校准。

  • 如果提供了 WindowDuration 参数，但未提供 RowToTSID 参数，则会为每个时间序列标识符和每个校准时间段输出点生成一组行。一组中的行是具有给定时间序列标识符的所有行，其结束时间位于以输出时间为较晚边缘并以 Duration 为宽度的窗口中。

    如果 Duration 参数具有 sliding 函数调用（例如 sliding(1h)），则窗口可能与校准时间段不同。否则，Duration 参数必须与校准时间段相同。表达式 window() 表示与校准时间段相同的时长。如果明确提供了非滑动 Duration，则在未明确提供时间段的情况下，将强制指定相同的时间段。

  • 如果同时提供了 RowToTSID 和 WindowDuration 参数，则为每行计算一个新的映射时间序列标识符，并为具有相同映射时间序列标识符的所有行创建一个组。该组中行的结束时间位于以输出时间为较晚边缘并以 Duration 为宽度的窗口中。

使用组中各行的共同时间序列标识符以及组的输出点时间的时间戳（提供了 WindowDuration）或组中的行的共同结束时间（未提供 WindowDuration），为每个组生成一个输出行。组中的值列由 RowSetToVal 参数生成。每个聚合表达式都应用于集合中的行，结果为输出行值列。

一些聚合表达式（例如 sum）将生成具有增量或采样平均值时间序列种类的输出值列，具体取决于执行的聚合的种类。这取决于是否在执行滑动或非滑动时间聚合。为此，如果它同时结合了时间和空间聚合，则将其视为时间聚合。

group_by 表操作始终生成校准输出表。如果未提供 WindowDuration 参数，则输入表必须校准，且输出表将具有相同的校准。如果提供了 WindowDuration 参数，则仅在对齐时间点生成输出点，并且输出表是校准的。

请注意，如果 RowToTSID 映射参数的表达式中包含值或时间列，则输入表中的时间序列可能会在输出表中分成多个时间序列。

union_group_by 聚合来自多个表的行。

签名：Table++ | union_group_by RowToTSID, [ RowSetToVal ]
          Table++ | union_group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
          Table++ | union_group_by lit-WindowDuration, [ RowSetToVal ]

union_group_by 函数聚合输入列的方式与 group_by 函数完全相同，不同之处在于它是从多个输入表中接受输入行。

输入到 union_group_by 的所有输入表必须具有相同的列（相同的名称、相同的类型，值列具有相同的时间序列种类）。如果 'union_group_by'（未提供 WindowDuration 参数）的参数要求校准的输入表，则所有输入表必须与同一时间段对齐。

unaligned_group_by   根据映射的时间序列标识符聚合行，但不校准。

签名：Table | unaligned_group_by TSIDSel, [ RowSetToVal ]

unaligned_group_by 表操作与 group_by 表操作相同，但不要求输入表校准。

为输入表中的每一行计算 TSIDSel 生成的时间序列标识符，并将具有相同的时间序列标识符和结束时间的所有行归为一组。该组中的所有行都具有相同的结束时间，并且应该具有相同的开始时间。如果组中的任何两行有不同的开始时间，则发出动态错误并任意选择其中一行，然后将其从组中移除。

为上述每组中的行生成一个输出行。输出行具有由 TSIDSel 映射参数生成的时间序列标识符，并且结束时间和开始时间（如果存在）与组中的输入行相同。将由 RowSetToVal 映射参数生成的值列应用于该组中的所有行。

unaligned_group_by 表操作不要求输入表校准，这可能意味着一个组中不太可能有多行要聚合。但它要求收集到一个输出时间序列中的行（都具有相同的时间序列标识符）的结束时间的密度不能导致每秒出现多行。

联合与联接

join 多个表的自然联接。

签名：Table++ | join

join 表操作接受两个或多个输入表，并通过对输入表的时间序列标识符和结束时间列进行自然内联接，将这些表中的行合并到单个输出表中。

除了要校准之外，输入表还必须全部与同一时间段校准，并且必须全部为增量或采样平均值时间序列种类。

输出表将包含以下元素：

  • 每个输入表中的每个唯一时间序列标识符列对应一个时间序列标识符列。每一列都与输入表中的相应列具有相同的类型。如果两个表具有名称相同但类型不同的时间序列标识符列，则会发生错误。

  • 一个结束时间列。如果任何输入表是增量时间序列种类，则输出表也将是增量时间序列种类，并具有开始时间列。

  • 每个输入表值列的值列对应一个值列。顺序是输入表在生成它们的 grouped_table_op 中的顺序。如果两个不同的输入表具有同名的值列，则会发生错误。

联接操作考虑由每个输入表中的一行构成的每个元组。对于满足以下条件的每个此类元组，将创建一个输出行：

  • 对于出现在任何输入表中的每个时间序列标识符列名称，该列在具有该列的元组中的每一行中都具有相同的值。

  • 元组中的每一行都具有相同的结束时间。

每个此类输出行将具有以下列值：

  • 每个时间序列列都将具有该列的值，与包含该列的元组中的每一行一样。

  • 每个时间列的值将与输入元组中的行相同。

  • 每个值列都与值列中的元组所在行具有相同的值。

outer_join 两个表的自然外联接。

签名：Table++ | outer_join [ DefaultColumns ], [ DefaultColumns ]

outer_join 表操作接受两个输入表，并通过对输入表的时间序列标识符和结束时间列进行自然外联接，将这些表中的行合并到单个输出表中。

必须提供一个或两个 DefaultColumns 参数。每个对应一个输入表，当一个表获得该参数，如果该表中没有匹配另一个表中的一行的行，则将创建行。DefaultColumns 指定所创建行的值列。如果为一个表提供了 DefaultColumns，则该表中的时间序列标识符列必须是其他表的时间序列的子集。如果其他表具有增量时间序列种类，则该表只能具有增量时间序列种类。

除了要校准之外，输入表还必须全部与同一时间段校准，并且必须全部为增量或采样平均值时间序列种类。

与 join 一样，输出表将包含以下元素：

  • 每个输入表中的每个唯一时间序列标识符列对应一个时间序列标识符列。每一列都与输入表中的相应列具有相同的类型。如果两个表具有名称相同但类型不同的时间序列标识符列，则会发生错误。

  • 一个结束时间列。如果任何输入表是增量时间序列种类，则输出表也将是增量时间序列种类，并具有开始时间列。

  • 每个输入表值列的值列对应一个值列。顺序是输入表在生成它们的 grouped_table_op 中的顺序。如果两个不同的输入表具有同名的值列，则会发生错误。

联接操作考虑由每个输入表中的一行构成的对。对于满足以下条件的每个此类对，将创建一个输出行：

  • 对于出现在任一输入表中的每个时间序列标识符列名称，该列在具有该列的对中的每一行中都具有相同的值。

  • 该对中的每一行都具有相同的结束时间。

每个此类输出行将具有以下列值：

  • 每个时间序列列都将具有该列的值，与包含该列的对中的每一行一样。

  • 每个时间列的值将与输入对中的行相同。

  • 每个值列都与值列中的对所在行具有相同的值。

除了上述对之外，如果一个表中的行无法与其他表中的任何行形成对，并且另一个表具有指定的 DefaultColumns，则将使用第一个表和另一个表的默认行。默认行的结构如下：

  • 每个时间序列标识符列和时间列的值都与第一个表行中的相应列相同。

  • 默认行的值列由 DefaultColumns map 构造。该 map 必须为默认表中的每个值列指定一个值。

union 多个表的并集。

签名：Table++ | union

union 表操作接受两个或更多输入表，并生成包含所有输入表中的行的单个输出表。

输入表必须具有相同的列（相同的名称、相同的类型，值列具有相同的时间序列种类）。生成的输出表将与输入表具有相同的列。只有当所有输入表都与一个公共时间段校准时，输出表才会校准。

如果两个或多个不同表的数据流具有相同的时间序列标识符，则会发生动态错误。在这种情况下，系统会任意选择一个包含重复时间序列标识符的数据流，以将其包含在输出中，并丢弃其他的数据流。

时间范围和时间段

校准表中的时间序列时要使用的时间段由 every 命令设置。

查询将生成其所有结果作为结束时间在查询窗口内的点。查询窗口的持续时间由 within 表操作设置，该操作可以指定任何开始时间、结束时间或持续时间。

every   指定校准表输出的时间段。

签名：Table | every lit-Duration

every 表操作需要一个输入表，该表与 Duration 参数提供的输入时间段校准。这通过以下某一种方式进行处理：

  • 如果输入表未校准，则为输入表插入具有适当的校准函数的 align 操作。校准函数的 Duration 参数是指定时间段的默认值。

  • 如果表已校准，但没有特定的必需时间段，则输入到 every 表操作的查询调整为生成该时间段。

  • 如果输入表与特定时间段校准，且该时间段与 Duration 参数指定的时间段不同，则会发生错误。

within   指定查询输出的时间范围。

签名：Table   | within   lit-DateOrDuration,   [ lit-DateOrDuration ]

within 表操作指定查询输出的时间范围。方法是指定以下三个值中的一个或两个：窗口的最早（开始）时间、窗口的最晚（结束）时间或窗口的持续时间）。

如果 within 的两个参数中有一个为正值 Duration，则设置为窗口的宽度。最多只能有一个参数是正值 Duration。

如果第一个参数是 Date，则指定为开始时间。如果第二个参数是 Date，则指定为结束时间。如果这两个值都是 Date 值，则第二个值代表的时间必须晚于第一个值。Date 参数可以作为 Date 字面量提供，也可以与负的 Duration 字面量一起提供。在后一种情况中，时间是在查询发出的时间（现在）之前的指定的 Duration。

如果仅提供了一个参数，则第二个参数默认为查询发出的时间（现在）。在这种情况下，第一个参数必须是正的 Duration 或 Date，且早于查询发出的时间。

graph_period 指定绘制时间序列图表的首选输出期。

签名：Table | graph_period lit-Duration

graph_period 表操作会转换其输入表，以使其适用于以图表的形式呈现。其“时长”参数表示适合图表的点之间的时间段。

如果用户未明确将此操作添加到提供给 Metrics Explorer 的查询中，则此操作会自动插入查询中。在任一事件中，Metrics Explorer 都会设置“时长”参数的值，使其适合图表的实际时间窗口。只有在查询提供给 API 的情况下，明确添加 graph_period 作为查询的一部分才有意义。

graph_period 操作会将其“时长”参数与输入表的句点进行比较，并执行以下操作之一：

  • 如果输入表的时间段小于“时长”参数的一半，则 graph_period 操作会充当时间缩减器，其窗口和输出期由“时长”参数提供。输入表中的每个值列都会根据其类型进行汇总。

    • 对于数字类型的值列，输出表中将放置 3 列，每列均是通过使用 min、mean 和 max 聚合器汇总输入列产生的。输出列名称是分别附加 .min、.mean 和 .max 的输入列名称。

    • 对于布尔类型的值列，输出表中将放置 3 列，每列均是通过使用 min、mean 和 max 聚合器汇总输入列产生的。输出列名称是分别附加 .all_true、.mean 和 .any_true 的输入列名称。

    • 对于分布类型的列，将使用 distribution 聚合来合并落在每个图表时间段窗口的所有分布输入值群体，来创建同名的单个列。

  • 如果输入表的时间段超过“时长”参数的两倍，则对于输入表中的每个点，都会创建输出期所需时间点的副本。

  • 如果输入表的时间段小于“时长”参数的两倍，并且超过“时长”参数的一半，则输入表只会复制到输出。

请注意，如果输入表包含多个值列或具有“字符串”值列，则其行为是未定义的。Metrics Explorer 可能只会显示单个列，如果没有可显示的列，则会出现错误。

window   指定校准操作的窗口。

签名：Table | window lit-Duration

window 表操作需要一个输入表，该表通过一个校准函数校准，该校准函数的窗口 Duration 参数与提供给此 window 表操作的 Duration 参数相同的。这通过以下某一种方式进行处理：

  • 如果输入表未校准，则为输入表插入具有适当的校准函数的 align 操作。校准函数的 Duration 参数由此 window 表操作的 Duration 参数提供。

  • 如果表已校准，但校准它的表操作没有特定的校准窗口，则此 window 参数的 Duration 将用作校准器器窗口参数。

  • 如果输入表已校准，且校准它的表操作指定一个不同于此 window 表操作的 Duration 参数的窗口 Duration 参数，则会发生错误。

提醒

提醒操作用于定义提醒政策。这些操作只能安装提醒，而不能作为查询的一部分。

抽象地说，这些操作提供了创建查询的方法，这些查询可生成具有两个值列的表：一个布尔值，用于指示提醒是否应为触发状态；一个与输入具有相同类型的值，用于提供输入的最新值。

condition 向输入表添加布尔条件列。

签名：Table | condition Bool

condition 表操作向每个输入表行添加一个布尔值列，以创建其输出表。此列的值是应用于行的 Bool 参数的值。

此字段可用于创建提醒查询。输出表中有一个布尔值列，用于表示提醒条件得到满足。提醒工具将使用此信息来确定是否以及何时发出提醒或停止发出提醒。

condition 运算要求输入表校准，并由具有显式校准窗口的查询生成。这由校准操作（例如 | align rate(10m)）的窗口参数或 window 表操作提供。

示例：

  fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | window 5m
  | condition val() < .5

这将生成一个包含两个值列的表。第一列是 Bool 列，如果输入表 usage_time 值列小于 .5，则该列为 true。第二列是输入中 usage_time 值列的副本。

absent_for   创建输入缺失条件。

签名：Table | absent_for lit-Duration

absent_for 表操作会生成一个包含两个值列（即 active 和 signal）的表。如果表输入中缺少数据，则 active 列为 true，否则返回 false。这对于创建条件查询以在输入缺失时发出提醒非常有用。

对于每个输入时间序列，absent_for 都会创建一个具有与输入相同的时间序列标识符的校准输出时间序列。校准时间段可通过以下 every 指定，也可以设为默认时间段。

“时长”参数指定时间限制。如果输入时间序列中存在早于输出点时间的时间限制内的某个点，则输出点的 active 列将为 false。如果没有这样的输入点，active 列将为 true，表示时间限制内缺少输入。

如果输入表具有值列，则 signal 列将包含输入时间序列中最近输入点（无论是否在限制值内）的第一个值列的值。如果输入表没有值列，则输出点中的 signal 列将是一个整数，给出自上次输入点之后的分钟数。

对于每个输出点时间，absent_for 表操作将在某个输入点的该时间之前 24 小时进行回溯。如果在过去 24 小时内没有输入点，则该时间点不会输出任何点。

示例：

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | absent_for 8h

对于来自虚拟机 (gce_instance) 的每个 usage_time 时间序列，absent_for 将生成一个校准时间序列，其输出点将具有一个 active 列，如果在过去 24 小时内没有输入点，但过去 8 小时 (8h) 内没有数据点，则该值为 true。这是一个合适的提醒查询。

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | value [] | absent_for 8h

这类似于前面的示例，但 | value [] 将值列从对 absent_for 操作的输入中移除，因此 signal 列设置为自上次输入点之后的分钟数。

其他

ident   身份表操作：不更改输入表。

签名：Table   | ident

ident 表操作生成一个输入表，该表保持不变。

例如：

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time |
    { ident ; group_by [zone] } |
    join | value [zone_fraction: val(0) / val(1)]

对于给定表中的每一行，计算其值与其所在地区的所有实例中该值的总数的比率。

ratio   计算两个校准的输入表的值列的比率。

签名：Table++ | ratio

ratio 表操作接受两个校准的输入表，分别为分子表输入和分母表输入。两个表输入都应该只有一个数值类型的值列。

分母表的时间序列标识符列必须是分子表的时间序列标识符列的子集。如果两个表具有相同的时间序列标识符列（名称和类型），则在计算比率时将为分子使用默认值零。

filter_ratio   计算输入值列的两个过滤总和的比率。

签名：Table   | filter_ratio   Bool,   [ Bool ]

filter_ratio 表操作接受一个输入表，该表只有一个数值类型的值列。如果输入表未校准，则将自动插入 align 表操作以提供校准。

filter_ratio 操作聚合给定时间戳的所有输入行，计算分子和分母的总和，并生成一个关于每个时间戳上这些和的比率的时间序列。第一个 Bool 参数控制可加入分子总和的输入，第二个 Bool 参数控制可加入分母总和的输入。第二个参数是可选的，如果未指定，则默认为 true。

Bool 参数针对每一行运算，如果为 true，则该行的值列会包括在分子（第一个 Bool）或分母（第二个 Bool）的总和中。

filter_ratio_by   计算输入值列的两个过滤总和的分组比率。

签名：Table   | filter_ratio_by   RowToTSID,   Bool,   [ Bool ]

filter_ratio_by 表操作接受一个输入表，该表只有一个数值类型的值列。如果输入表未校准，则将自动插入 align 表操作以提供校准。

filter_ratio_by 运算将具有由 RowToTSID 参数计算的相同时间序列标识符的行归为一组。对于每一组，它计算分子和分母的总和，并生成一个关于每个时间戳上这些和的比率的时间序列。第一个 Bool 参数控制可加入分子总和的输入，第二个 Bool 参数控制可加入分母总和的输入。第二个参数是可选的，如果未指定，则默认为 true。

Bool 参数针对每一行运算，如果为 true，则该行的值列会包括在分子（第一个 Bool）或分母（第二个 Bool）的总和中。

为每个组计算一个系列序列，其中时间序列标识符由 RowToTSID 参数计算得出。

函数

本部分介绍可在 Monitoring Query Language 的表达式 (expr) 中使用的每个函数。

  • 输入行列
    • val 值列在输入点（行）中的值。
    • end 输入点（行）的结束时间。
    • start 输入点（行）的开始时间。
    • older 时间序列中上一个点（行）的值。
    • adjacent_delta 输入点与上一个点之间的值变化。
    • adjacent_rate 输入点与上一个点（行）之间的变化率。
    • hash_tsid 返回时间序列标识符列的哈希值。
  • 逻辑
    • not 布尔值的逻辑求反。
    • and 两个布尔值的逻辑与。
    • or 两个布尔值的逻辑或。
    • true 布尔值 true。
    • false 布尔值 false。
    • has 如果 set 参数包含特定值，则为 true。
    • has_value 如果参数表达式计算出一个值，则为 true。
    • if 有条件地从两个值中选择的值。
    • or_else 一个值，或者如果不是一个值，则为另一个值。
  • 比较
    • eq 等于。
    • ne 不等于。
    • ge 大于或等于。
    • gt 大于。
    • le 小于或等于。
    • lt 小于。
  • 算术
    • add 两个数字的总和。
    • sub 两个数字之差。
    • mul 两个数字的乘积。
    • div 两个数字的比率。
    • int_div 两个整数相除的商。
    • abs 绝对值。
    • neg 数字的负数。
    • pos 数字输入的身份。
    • rem 两个整数相除的余数。
  • 数学
  • 字符串
  • 正则表达式
    • re_full_match 如果正则表达式与整个字符串值匹配，则为 true。
    • re_partial_match 如果正则表达式与字符串值的某个部分匹配，则为 true。
    • re_extract 提取正则表达式在另一个字符串中匹配的值。
    • re_replace 替换正则表达式在另一个字符串中的第一个匹配。
    • re_global_replace 替换正则表达式在另一个字符串中的所有匹配。
  • 聚合
    • sum 一组数值之和。
    • distribution 一组数值或分布值的分布。
    • count 一组值中值的数量。
    • row_count 遇到的输入行数。
    • count_true 一组布尔值中 true 值的数量。
    • min 一组数值中的最小值。
    • max 一组数值中的最大值。
    • diameter 一组数值中最大值减去最小值。
    • mean 一组数值的平均值。
    • stddev 一组值的标准差。
    • variance 一组数值的方差。
    • covariance 一组值对的协方差。
    • median 一组数值或分布值的中位数。
    • percentile 一组数值或分布值的百分位。
    • fraction_less_than 一组值中小于固定值的值的比例。
    • fraction_true 一组布尔值中 true 值的比例。
    • any_true 一组布尔值的析取。
    • all_true 一组布尔值的结合。
    • pick_any 一组值中任意元素的值（任意选择）。
    • singleton 一组值中只有一个元素的元素的值。
    • unique 一组值（必须全部相同）的公共值。
    • aggregate 一组值中任意类型的默认聚合值。
    • weighted_distribution 一组加权值的分布。
  • 校准
    • rate 计算校准时间点的变化率。
    • delta 计算校准时间点的值变化。
    • any_true_aligner    通过查找窗口中的任何真实值来对齐布尔值时间序列。
    • count_true_aligner    通过计算窗口中的真实值来对齐布尔值时间序列。
    • delta_gauge 计算校准时间点的值变化（采样平均值时间序列）。
    • fraction_true_aligner    对齐布尔值时间序列与窗口中真实值的比例。
    • int_mean_aligner    通过找到窗口中 Int 值的平均值对齐。
    • interpolate 计算校准时间点的内插值。
    • mean_aligner    通过查找窗口中值的平均值对齐。
    • next_older 通过从较早时间移动到较晚时间校准时间点。
    • next_younger 通过从较晚时间移动到较早时间校准时间点。
  • 操纵单位
    • scale 将值缩放到不同的度量单位。
    • cast_units 设置值的度量单位。
  • 定期窗口
    • window 表示与校准时间段相同的窗口。
    • sliding 表示滑动（重叠）而非不相交的窗口。
  • 分布
  • 分桶说明符
    • powers_of 分桶边界指数增加的分桶规范。
    • fixed_width 分桶大小相同的分桶规范。
    • custom 来自分桶边界列表的分桶规范。
    • num_buckets 设置分桶规范中的分桶数量。
    • bounds 设置第一个分桶的下限和最后一个分桶的上限。
    • lower 设置分桶规范中第一个分桶的下限。
  • 其他
    • cast_double 将 Int 值转换为 Double。
    • cast_gauge 将累积或增量时间序列值转换为采样平均值。
    • within 指定排序值计算的窗口。

输入行列

查询中的表达式对输入行的列进行运算。通常通过提供列名称可以访问列。本部分中的函数提供访问列的其他方法。

时间列没有列名，可以通过 start 和 end 函数访问。

您可以使用 val 函数按名称或按位置访问值列。

older 函数提供对时间序列中上一个行中的列的访问权限。

val 值列在输入点（行）中的值。

签名：ImplicitRowInput val([ lit-Int ] ) → InputType (implicit row input)

在访问输入行的值列时，val 函数提供了一种替代使用列名称的方法。其 Int 参数（默认值 0）对有序的值列进行索引（从第一个值列开始为 0），并返回编入索引的值列的值。此值与使用值列名称得到的值相同。

如果 val 函数指示索引为负数，或等于或大于或等于值列数的索引，则为静态错误。

end 输入点（行）的结束时间。

签名：ImplicitRowInput end( ) → Date.Gauge (implicit row input)

end 函数在当前输入行的结束时间列中返回 Date 值。

start 输入点（行）的开始时间。

签名：ImplicitRowInput start( ) → Date.Gauge (implicit row input)

start 函数在当前输入行的开始时间列中返回 Date 值。如果该行没有开始时间（因为它只包含采样平均值数据），则开始时间将返回 no-value。

older 时间序列中上一个点（行）的值。

签名：  older(ColumnValue.CumulativeOK )   →   FirstArgType.FirstArgKind
          older(Date )   →   Date.FirstArgKind

older 的参数必须是列名称或指定列值的函数（val、end、start）。返回的值是同一时间序列中输入行的上一个行的该列的值。如果同一时间序列中没有更早的行，则 older 会返回 no-value。

引用的列可以是值、时间或时间序列标识符列。如果是时间序列标识符列，则 older 将返回与参数表达式相同的值，即使同一时间序列中没有更早的行也是如此。

adjacent_delta 输入点与上一个点之间的值变化。

签名：  ImplicitRowInput   adjacent_delta( )   →   InputType     (implicit row input)

adjacent_delta 函数对具有单个数值（Int 或 Double）或 Distribution 值列的表进行运算。

如果应用于采样平均值时间序列，adjacent_delta 将返回当前输入行中的值列与同一时间序列中上一行的值列之间的差值（如有）。如果同一时间序列中没有更早的行，则 adjacent_delta 会返回 no-value。结果具有采样平均值时间序列种类。

如果应用于增量时间序列，adjacent_delta 将返回值列的值，该值仍具有增量时间序列种类。每个输出点的值、开始时间和结束时间都与生成其的输入点相同。

虽然查询中很少使用累积时间序列，但如果将其应用于累积时间序列，adjacent_delta 将返回以下两个值之一：

  • 如果输入点的开始时间早于上一个点的结束时间，adjacent_delta 将返回输入点的值减去上一个点的值的结果。

  • 如果输入点的开始时间晚于上一个点的结束时间，adjacent_delta 将返回输入点值（相当于在开始时间减去 0）。

生成的时间序列具有增量时间序列种类，并且每个点的开始时间是其原始的开始时间或上一个输入点的结束时间（以较早者为准）。

adjacent_rate 输入点与上一个点（行）之间的变化率。

签名：  ImplicitRowInput   adjacent_rate( )   →   Double.Gauge     (implicit row input)

adjacent_rate 函数对具有单个数值（Int 或 Double）或 Distribution 值列的表进行运算。

如果应用于采样平均值或累积时间序列，adjacent_rate 将返回当前输入行中的值列与同一时间序列中上一行的值列的值的变化率（如有）。计算方式是两行的值的差除以结束时间的差值。如果同一时间序列中没有更早的行，则 adjacent_rate 会返回 no-value。结果具有采样平均值时间序列种类。

如果应用于增量时间序列，adjacent_rate 将返回当前输入行的值列除以该行的开始时间和结束时间之间的差值。

hash_tsid 返回时间序列标识符列的哈希值。

签名：  ImplicitRowInput   hash_tsid([ lit-Int ] )   →   Int     (implicit row input)

hash_tsid 函数返回当前输入行的时间序列标识符字段中的值的哈希值。如果提供了参数，则将其用作哈希的 seed。

逻辑

not 布尔值的逻辑求反。

签名：  not(Bool )   →   Bool

not 函数接受布尔值，如果该参数为 false 则返回 true；如果该参数为 true，则返回 false。如果输入参数为 no-value，则结果为 no-value。

and 两个布尔值的逻辑与。

签名：  and(Bool,   Bool )   →   Bool

如果 and 函数的两个输入都为 true，则返回 true，否则返回 false。如果任一输入为 no-value，则 and 始终返回 no-value。

or 两个布尔值的逻辑或。

签名：  or(Bool,   Bool )   →   Bool

如果 or 函数的两个输入中的任意一个为 true，则返回 true，否则返回 false。如果任一输入为 no-value，则 or 始终返回 no-value。

true 布尔值 true。

签名：  ImplicitRowInput   true( )   →   lit-Bool     (implicit row input)

此函数返回字面量 Bool 值 true。

false 布尔值 false。

签名：  ImplicitRowInput   false( )   →   lit-Bool     (implicit row input)

此函数返回字面量 Bool 值 false。

has 如果 set 参数包含特定值，则为 true。

签名：  has(Set,   lit-ColumnValue )   →   Bool

如果 has 函数的第一个参数 set 将第二个参数作为元素，则返回 true。

has_value 如果参数表达式计算出一个值，则为 true。

签名：  has_value(ColumnValue )   →   Bool

如果 has_value 函数的参数计算结果为一个值，则返回 true；如果计算结果为 no-value，则返回 false。

if 有条件地从两个值中选择的值。

签名：  if(Bool,   ColumnValue.Delta,   ColumnValue.Delta(same) )   →   LastArgType.Delta
          if(Bool,   ColumnValue,   ColumnValue(same) )   →   LastArgType

if 函数返回其第二个或第三个参数，具体取决于第一个参数的值（true 或 false）。

if 计算其第一个 Bool 参数。如果为 no-value，则结果为 no-value。如果第一个参数为 true，则返回第二个参数；如果第一个参数为 false，则返回第三个参数。

第二个或第三个参数可能为 no-value，但只有在 Bool 参数为 no-value 或者返回的参数为 no-value 时，if 的结果才会是 no-value。结果不是 no-value 时，未选择的参数也可能为 no-value。

如果 if 的第二个和第三个参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 if 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

if 的结果具有其第二个参数的单位（可能经过缩放）。

or_else 一个值，或者如果不是一个值，则为另一个值。

签名：  or_else(ColumnValue,   ColumnValue(same) )   →   LastArgType

or_else 函数返回其第一个参数的值，除非返回的值为 no-value，在这种情况下会返回其第二个参数的值。

仅当 or_else 函数的两个参数均为 no-value 时，才会返回 no-value。

如果 or_else 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 or_else 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

or_else 的结果具有第一个参数的单位（可能经过缩放）。

比较

比较运算符比较同一类型的两个值或两个数值（Int 或 *Double）值并返回l Boo 值。与大多数函数不同，比较运算符从不返回 no-value。如果输入是 no-value，则将其视为大于任何其他值的特定值。

eq   等于。

签名： eq(Num,   Num )   →   Bool
          eq(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果相同则返回 true，不同则返回 false。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果两个值均为 no-value，则返回 true，否则返回 false。（这里将 no-value 视为等于自身。）

在比较数字参数时，如果任一参数有单位，则两个参数都必须有单位，并且单位必须等效。结果的类型为 Bool，没有单位。如果 eq 的参数的单位不等效但量纲相同，则其中一个参数可以自动缩放其单位以使两个参数单位等效。

如果 eq 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 eq 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

“eq”结果的类型为 Bool，没有单位。

如匹配 resource.project_id 列中所述，对 resource.project_id 列和字面量字符串之间的比较采用特殊处理方式来处理项目编号和项目名称之间的差异。

ne   不等于。

签名： ne(Num,   Num )   →   Bool
          ne(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果相同则返回 false，不同则返回 true。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果两个值均为 no-value，则返回 false，否则返回 false。（这里将 no-value 视为等于自身。）

如果 ne 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 ne 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

“ne”结果的类型为 Bool，没有单位。

如匹配 resource.project_id 列中所述，对 resource.project_id 列和字面量字符串之间的比较采用特殊处理方式来处理项目编号和项目名称之间的差异。

ge   大于或等于。

签名： ge(Num,   Num )   →   Bool
          ge(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果第一个大于或等于第二个，则返回 true，否则返回 false。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果第一个值为 no-value，则返回 true，否则返回 false。（这里将 no-value 视为大于任何其他值。）

如果 ge 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效。如果单位不等效但量纲相同，则其中一个参数可以自动缩放以具有与另一个参数相同的单位，如此处所述。如果只有一个参数有单位，或者两个参数具有不等效单位并且没有进行缩放，则会引发错误。

“ge”结果的类型为 Bool，没有单位。

gt   大于。

签名： gt(Num,   Num )   →   Bool
          gt(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果第一个大于第二个，则返回 true，否则返回 false。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果第二个值为 no-value，则返回 false，否则返回 true。（这里将 no-value 视为大于任何其他值。）

如果 gt 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 gt 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

“gt”结果的类型为 Bool，没有单位。

le   小于或等于。

签名： le(Num,   Num )   →   Bool
          le(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果第一个小于或等于第二个，则返回 true，否则返回 false。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果第二个值为 no-value，则返回 true，否则返回 false。（这里将 no-value 视为大于任何其他值。）

如果 le 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 le 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

“le”结果的类型为 Bool，没有单位。

lt   小于。

签名： lt(Num,   Num )   →   Bool
          lt(Comparable,   Comparable(same) )   →   Bool

这会将第一个 Comparable 参数与第二个 Comparable 参数进行比较，如果第一个小于第二个，则返回 true，否则返回 false。如果一个参数是 Int，另一个是 Double，则在进行比较之前，Int 参数将转换为 Double 值。

如果任一输入为 no-value，则比较完成并返回 Bool 参数；如果第一个值为 no-value，则返回 false，否则返回 true。（这里将 no-value 视为大于任何其他值。）

如果 lt 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 lt 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

“lt”结果的类型为 Bool，没有单位。

算术

实现算术运算符的函数。

add   两个数字的总和。

签名：  add(Num.Delta,   Num.Delta )   →   Num.Delta
          add(Num,   Num )   →   Num
          add(Duration,   Duration )   →   Duration
          add(Date,   Duration )   →   Date
          add(Duration,   Date )   →   Date

两个 Num 参数的 add 函数返回其参数的总和。如果任一输入为 Double 值，则返回值为 Double，否则为 Int。如果两个输入均为增量时间序列种类，则输出为增量时间序列种类。否则，输出为采样平均值时间序列种类。

两个 Duration 参数的 add 函数返回其总和的时长。

一个 Date 和一个 Duration 参数的 add 函数返回一个日期，该日期是 Date 参数经过 Duration 后的日期。如果 Duration 为负数，则结果将早于输入 Date（过去的日期）。

如果 add 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 add 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

add 的结果具有第一个参数的单位（可能经过缩放）。

sub   两个数字之差。

签名：  sub(Num.Delta,   Num.Delta )   →   Num.Delta
          sub(Num,   Num )   →   Num
          sub(Duration,   Duration )   →   Duration
          sub(Date,   Duration )   →   Date
          sub(Date,   Date )   →   Duration

两个 Num 参数的 sub 函数返回第一个参数减去第二个参数。如果任一输入为 Double 值，则返回值为 Double，否则为 Int。如果两个输入均为增量时间序列种类，则输出为增量时间序列种类。否则，输出为采样平均值时间序列种类。

两个 Duration 参数的 sub 函数返回两个时长之差的时长。

一个 Date 和一个 Duration 参数的 sub 函数返回一个日期，该日期是从 Date 参数往前追溯 Duration 后的日期。如果 Duration 参数为负数，则结果将晚于 Date 参数。

如果 sub 的参数是数字，并且任一参数具有单位，则两个参数都必须具有单位。如果参数有单位，则单位必须等效，或者此处提供的规则必须允许在应用 sub 之前缩放某个参数以使单位等效。如果只有一个参数有单位，或者两个参数都有单位，但无法使其等效，则会引发错误。

sub 的结果具有第一个参数的单位（可能经过缩放）。

mul   两个数字的乘积。

签名：  mul(Num.Delta,   lit-Num )   →   Num.Delta
          mul(lit-Num,   Num.Delta )   →   Num.Delta
          mul(Num,   Num )   →   Num
          mul(Duration,   Num )   →   Duration
          mul(Num,   Duration )   →   Duration

两个 Num 参数的 mul 函数返回两个参数的乘积。如果任一输入为 Double 值，则返回值为 Double，否则为 Int。如果一个输入为增量时间序列种类且另一个输入为字面量，则输出为增量时间序列种类。否则，输出为采样平均值时间序列种类。

一个 Num 和一个 Duration 的 mul 函数将 Duration 乘以 Num，结果为 Duration 类型。

如果任一数字参数有单位，则两个参数都必须有单位，并且单位必须等效。如果参数有单位，结果的单位将是两个参数的单位的乘积。一个例外情况是乘以字面量：字面量可能没有明确提供的度量单位，因此如果另一个参数有度量单位，该字面量将获得单位 1，从而使结果具有另一个参数的单位。

div   两个数字的比率。

签名：  div(Num.Delta,   lit-Num )   →   Double.Delta
          div(Num,   Num )   →   Double
          div(Duration,   Num )   →   Duration
          div(Duration,   Duration )   →   Double
          div(Date,   Duration )   →   Double

div 函数将其第一个 Num 参数除以第二个 Num 参数，将比率作为 Double 值返回。

如果第二个 Num 参数为 0，则不会生成结果。

div 函数将其第一个参数除以第二个参数，将比率作为 Double 值返回。当参数为 Date 或 Duration 时，值表示为 Date 或 Duration 的一个双精度值，且单位反映这些值的完整内部精度。如果结果是日期或时长，则该比率会被视为一个具有相同单位的值，舍入到 Date 或 Duration 可以表示的最接近的值。

如果是 Date 值除以 Duration 值，则结果为 Double 值，该值为从 Unix 纪元 (d'1970/01/01-00:00:00+00:00') 以来的该 Duration 时间段的数量。因此，d'2020/06/01-01:20:03' / 1s 是 d'1970/01/01-00:00:00+00:00' 和 d'2020/06/01-01:20:03' 之间的秒数。

如果第二个参数为 0，则 div 函数不会生成结果。

如果任一数字参数有单位，则两个参数都必须有单位。如果参数有单位，结果的单位将是第一个参数的单位除以第二个单位。一个例外情况是除以字面量：字面量可能没有明确提供的度量单位，因此如果另一个参数有度量单位，该字面量将获得单位 1，从而使结果具有另一个参数的单位。

int_div   两个整数相除的商。

签名：  int_div(Int,   Int )   →   Int
          int_div(Duration,   Int )   →   Duration
          int_div(Duration,   Duration )   →   Int
          int_div(Date,   Duration )   →   Int

int_div 函数将其第一个参数除以第二个参数，将商作为 Int 值返回。当参数为 Date 或 Duration 时，值表示为 Date 或 Duration 的一个整数，且单位反映这些值的完整内部精度。如果结果是日期或时长，则数值商被视为具有相同单位的值。

如果是 Date 值除以 Duration 值，则结果为 Int 值，该值为从 Unix 纪元 (d'1970/01/01-00:00:00+00:00') 以来的该 Duration 时间段的数量。因此，d'2020/06/01-01:20:03' / 1s 是 d'1970/01/01-00:00:00+00:00' 和 d'2020/06/01-01:20:03' 之间的秒数。

如果第二个参数为 0，则 int_div 函数不会生成结果。

如果任一数字参数有单位，则两个参数都必须有单位。如果参数有单位，结果的单位将是第一个参数的单位除以第二个单位。一个例外情况是除以字面量：字面量可能没有明确提供的度量单位，因此如果另一个参数有度量单位，该字面量将获得单位 1，从而使结果具有另一个参数的单位。

abs   绝对值。

签名：  abs(Num )   →   Num

abs 函数接受数字（Int 或 *Double）输入，并返回与输入相同类型和大小的非负值。

abs 的结果具有相同的度量单位。

neg   数字的负数。

签名：  neg(Num )   →   Num
          neg(Duration )   →   Duration

neg 函数返回其参数的负数。

pos   数字输入的身份。

签名：  pos(Num )   →   Num
          pos(Duration )   →   Duration

pos 函数返回其自己的参数。

rem   两个整数相除的余数。

签名：  rem(Int,   Int )   →   Int
          rem(Duration,   Duration )   →   Duration

rem 函数将其第一个 Int 参数除以第二个 Int 参数，将余数作为 Int 值返回。

如果第二个 Num 参数为 0，则不会生成结果。

附加到 Rem 的结果的度量单位与第一个参数的单位相同（如有）。

数学

一些数学函数。

sqrt   平方根。

签名：  sqrt(Num )   →   Double

sqrt 函数以 Double 值的形式返回 Num 参数的平方根。

如果 Num 参数小于 0，则 sqrt 不会生成结果。

sqrt 的结果没有度量单位。

log   自然对数。

签名：  log(Num )   →   Double

log 函数以 Double 值的形式返回 Num 参数的自然对数。

如果 Num 参数小于或等于 0，则 log 不会生成结果。

log 的结果没有度量单位。

exp e 的幂运算。

签名：  exp(Num )   →   Double

exp 以 Double 值形式返回 e（自然对数的底数）的 Num 参数次幂。

exp 函数会在溢出时返回 Double 值无穷大。

exp 的结果没有度量单位。

power 幂运算。

签名：  power(Num,   Num )   →   Double

这将返回第一个 Num 参数的第二个 Num 参数次幂（以 Double 值表示）。如果任一参数为 Int，则在运算之前会转换为 Double。

power 的结果没有度量单位。

int_round   舍入到最接近的整数。

签名：  int_round(Double )   →   Int

int_round 函数接受 Double 值，将其舍入到最接近的整数值，然后将其返回为 Int 值。如果输入不是值，或者结果无法表示为 Int 值，则结果为 no-value。

int_round 的结果与其输入具有相同的度量单位。

int_floor   下限整数。

签名：  int_floor(Double )   →   Int

int_floor 函数接受 Double 值，将其向负无穷大方向舍入到最接近的整数值，并返回为 Int 值。如果输入不是值，或者结果无法表示为 Int 值，则结果为 no-value。

int_floor 的结果与其输入具有相同的度量单位。

int_ceil   上限整数。

签名：  int_ceil(Double )   →   Int

int_ceil 函数接受 Double 值，将其向无穷大方向舍入到最接近的整数值，并返回为 Int 值。如果输入为 no-value，或者结果无法表示为 Int 值，则结果为 no-value。

int_ceil 的结果没有度量单位。

字符串

处理 String 值的函数。

concatenate   字符串连接运算符。

签名：  concatenate(String,   String )   →   String

concatenate 函数返回其两个 String 参数的连接。

string_to_double   将 String 转换为 Double。

签名：  string_to_double(String )   →   Double

string_to_double 函数将其输入 String 参数解析为浮点数，并以 Double 值的形式返回结果。如果字符串不是有效的浮点值，则结果为 no-value。

string_to_double 的结果没有度量单位。

string_to_int64   将 String 转换为 Int。

签名：  string_to_int64(String )   →   Int

string_to_int64 函数将其输入 String 参数解析为整数，并将结果作为 Int 值返回。如果字符串不是有效的整数值或无法表示为 Int 值，则结果为 no-value。

string_to_int64 的结果没有度量单位。

ascii_to_lower   将 ASCII 大写字母字符更改为小写字母。

签名：  ascii_to_lower(String )   →   String

ascii_to_upper 函数接受 String 参数并返回一个相同的 String 值，不同之处在于每个大写 ASCII 字母都已转换为对应的小写 ASCII 字母。所有其他字符保持不变。

ascii_to_upper   将 ASCII 小写字母字符更改为大写字母。

签名：  ascii_to_upper(String )   →   String

ascii_to_upper 函数接受 String 参数并返回一个相同的 String 值，不同之处在于每个小写 ASCII 字母都已转换为对应的大写 ASCII 字母。所有其他字符保持不变。

utf8_normalize  适合用于大小写折叠比较的 Unicode 字符串。

签名：  utf8_normalize(String )   →   String

utf8_normalize 函数接受 String 参数，并返回一个 String 值，假设输入为有效 utf8 编码字符串的情况下，该值适合用于对输入值进行大小折叠比较。

正则表达式

使用 RE2 正则表达式进行匹配、提取和修改的函数。

re_full_match   如果正则表达式与整个字符串值匹配，则为 true。

签名：  re_full_match(String,   lit-String )   →   Bool

re_partial_match 函数接受一个字符串输入和一个字面量字符串正则表达式，如果输入字符串的整个部分与正则表达式匹配，则返回 true。否则返回 false，即使输入字符串参数为 no-value 也是如此。

如匹配 resource.project_id 列中所述，正则表达式上的 resource.project_id 列采用特殊处理方式来处理项目编号和项目名称之间的差异。

re_partial_match   如果正则表达式与字符串值的某个部分匹配，则为 true。

签名：  re_partial_match(String,   lit-String )   →   Bool

re_partial_match 函数接受一个字符串输入和一个字面量字符串正则表达式，如果输入字符串的任何部分与正则表达式匹配，则返回 true。否则返回 false，即使字符串参数为 no-value 也是如此。

re_extract   提取正则表达式在另一个字符串中匹配的值。

签名：  re_extract(String,   [ lit-String ],   [ lit-String ] )   →   String

re_extract 函数接受一个输入 String 参数和两个字面量 String 参数：一个正则表达式和一个替换字符串。将输入字符串与正则表达式匹配，并在替换字符串中替换表达式的捕获组，从而形成结果。捕获组被替换的替换字符串即为结果。

如果未提供正则表达式参数，则默认为 "(.*)"，从而将整个第一个参数字符串包含在一个捕获组中。

如果未提供替换字符串参数，则默认为 R"\1"，从而将第一个替换组作为输出字符串。

如果输入字符串为 no-value，如果正则表达式不匹配，或捕获组的替换无效，则返回 no-value。

re_replace   替换正则表达式在另一个字符串中的第一个匹配。

签名：  re_replace(String,   lit-String,   lit-String )   →   String

re_replace 函数接受一个输入 String 参数和两个字面量 String 参数：一个正则表达式和一个替换值。如果正则表达式与输入字符串的任何部分匹配，则将输入字符串中的第一个匹配替换为更换字符串。

如果输入字符串为 no-value，或者没有匹配，则输入字符串为返回值。

re_global_replace   替换正则表达式在另一个字符串中的所有匹配。

签名：  re_global_replace(String,   lit-String,   lit-String )   →   String

re_global_replace 函数接受一个输入 String 参数和两个字面量 String 参数：一个正则表达式和一个替换值。在输入字符串中，将正则表达式的每个不相交匹配（从左到右）替换为替换字符串，从而形成结果。

如果输入字符串为 no-value，或者没有匹配，则输入字符串为返回值。

聚合

聚合函数将一组输入值合并为一个最终输出值。当多个输入行组合在一起并聚合为一个输出行时使用聚合函数。

聚合函数维护一个内部聚合状态。聚合函数的参数表达式对每一个分组的输入行求值一次，生成的值（如有）传递到聚合函数的内部状态进行累积。对组中的所有行执行此操作后，聚合函数将生成其输出值，用于在单个输出行中创建值列。

例如，将 mean(memory_usage) 应用于具有 memory_usage 列的一组行，为每一行计算参数表达式 memory_usage，并在 mean 聚合函数的内部状态中合并生成的值（如果已生成），可能是对值进行求和以及计数。一旦所有行处理完毕，mean 缩减器便会从其内部状态（总和除以数量）生成一个值。

大多数对数值或分布值进行运算的聚合函数会将其输入的度量单位提供给输出。例外情况如下：

  • count 和 row_count 的输出的单位为 1。

  • variance 的输出为输入的平方。

  • covariance 的输出为两个输入的单位的乘积。

  • fraction_less_than 和 fraction_true 为输出提供单位 10^2.%。

sum   一组数值之和。

签名：  sum(Num )   →   Num.Delta     (temporal only)
          sum(Distribution )   →   Double.Delta     (temporal only)
          sum(Num )   →   Num.Gauge     (sliding temporal only)
          sum(Distribution )   →   Double.Gauge     (sliding temporal only)
          sum(Num )   →   Num.FirstArgKind
          sum(Distribution )   →   Double.FirstArgKind

如果参数表达式是数字（Int 或 *Double），则返回传递给它的值的总和。

如果参数表达式是 Distribution 值，则返回传递给它的所有 Distribution 值中的总体值的总和。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响总和。

对于数字（ Int 或 Double）输入，结果与输入表达式具有相同的类型（Int* 或 Double）。对于 Distribution 输入值，结果类型为 Double。

如果执行的是非滑动时间聚合，或者仅执行空间聚合并且输入时间序列种类为增量，则输出将具有增量时间序列种类，。

附加到 sum 结果的度量单位与输入的单位相同。

distribution   一组数值或分布值的分布。

签名：  distribution(Num,   lit-BucketSpecification )   →   Distribution.Delta     (temporal only)
          distribution(Num,   lit-BucketSpecification )   →   Distribution.Gauge
          distribution(Distribution )   →   Distribution.Delta     (temporal only)
          distribution(Distribution )   →   Distribution.Gauge     (sliding temporal only)
          distribution(Distribution )   →   Distribution.FirstArgKind

如果第一个参数是 Num 值，则输入值将被收集到一个分布结果中，该分布结果的分桶规范由 lit-Bucketer 参数提供。

如果第一个参数是 Distribution 值，则分布将合并到一个分布结果中，该分布结果包括所有输入分布的总体。生成的分布分桶规范由输入分布分桶规范确定。如果分桶规范完全相同，则使用该分桶规范。如果存在不同的分桶规范，则使用新的合并分桶规范。此合并的规范通常不会十分准确。

如果对于某个输入行，第一个参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响百分位。

附加到 distribution 结果的度量单位与输入的单位相同。

count   一组值中值的数量。

签名：  count(ColumnValue )   →   Int.Delta     (temporal only)
          count(ColumnValue )   →   Int.Gauge

返回传递给它的值的数量。如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则不计算在内。

当非滑动时间聚合完成时，输出将具有增量时间序列种类。

附加到 count 结果的度量单位为 1。

row_count   遇到的输入行数。

签名：  ImplicitRowSetInput   row_count( )   →   Int.Delta     (temporal only)
          ImplicitRowSetInput   row_count( )   →   Int.Gauge

row_count 聚合函数返回聚合的行数。与 count 不同，row_count 不接受参数，并且不关心是否可以从行计算出值。

当非滑动时间聚合完成时，输出将具有增量时间序列种类。

附加到 count 结果的度量单位为 1。

count_true   一组布尔值中 true 值的数量。

签名：  count_true(Bool )   →   Int.Delta     (temporal only)
          count_true(Bool )   →   Int

收集输入的布尔值，结果是值为 true 的输入值的数量。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

当非滑动时间聚合完成时，输出将具有增量时间序列种类。

附加到 count_true 结果的度量单位为 1。

min   一组数值中的最小值。

签名：  min(Num )   →   Num

收集传递给它的数值并返回最小值。结果类型与输入类型相同。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 min 结果的度量单位与输入的单位相同。

max   一组数值中的最大值。

签名：  max(Num )   →   Num

收集传递给它的数值并返回最大值。结果类型与输入类型相同。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 max 结果的度量单位与输入的单位相同。

diameter   一组数值的最大值减去最小值。

签名：  diameter(Num )   →   Num

收集传递给它的数值，并返回最大值和最小值之间的差值。结果类型与输入类型（Int 或 Double）相同。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 diameter 结果的度量单位与输入的单位相同。

mean   一组数值的平均值。

签名：  mean(Summable )   →   Double

如果参数表达式是数字（Int 或 *Double），则返回传递给它的值的平均值。

如果参数表达式的类型为 Distribution，则返回所有分布中所有值的平均值。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响平均值。

附加到 mean 结果的度量单位与输入的单位相同。

stddev   一组值的标准差。

签名：  stddev(Summable )   →   Double

如果参数表达式是数字（Int 或 *Double），则返回传递给它的值的标准差。

如果参数表达式是 Distribution 值，则返回所有分布中所有值的标准差。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响标准差。

附加到 stddev 结果的度量单位与输入的单位相同。

variance   一组数值的方差。

签名：  variance(Summable )   →   Double

如果参数表达式是数字（Int 或 *Double），则返回传递给它的值的方差。

如果参数表达式的类型为 Distribution，则返回所有分布中所有值的方差。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响方差。

variance 函数的结果不附加任何度量单位。

covariance   一组值对的协方差。

签名：  covariance(Num,   Num )   →   Double

返回传递给它的数值（Int 或 *Double）对的协方差。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响协方差。

covariance 函数的结果不附加任何度量单位。

median   一组数值或分布值的中位数。

签名：  median(Summable )   →   Double

如果参数表达式是数值（Int 或 *Double），则返回传递给它的值总体的中位数的估算值。中位数的计算方法是根据总体中的值创建一个分布值，分桶边界间隔为 10%，则估算误差将限制在该数值内。

用于从数值输入累积分布值以估算中位数的分桶规范为 powers_of(1.05).num_buckets(500).lower(.01)。这包括从 .01 到约 4e+8 范围内的值。这可以处理许多用例，但可能需要使用 scale 函数来调整输入，例如，从 By 到 MiBy 或“MBy”（如果字节数范围将以千兆字节或太字节为单位）。

如果参数表达式是 Distribution 值，则返回所有分布合并后的总体值的中位数的估算值。中位数的计算方法为，将所有输入分布合并为一个分布并估算中位数。中位数的准确度取决于输入分布的分桶边界。

如果对于某个输入行，参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响标准差。

附加到 median 结果的度量单位与输入的单位相同。

percentile   一组数值或分布值的百分位。

签名：  percentile(Summable,   lit-Num )   →   Double

lit-Num 参数提供一个百分位（范围为 0 到 100）。

如果第一个参数表达式是数字（Int 或 Double），则返回传递给它的总体值的百分位的估算值。百分位的计算方法是根据总体中的值创建一个分布值，分桶边界间隔为 10%，则估算误差将限制在该数值内。

用于从数值输入累积分布值以估算百分位的分桶规范为 powers_of(1.05).num_buckets(500).lower(.01)。这包括从 .01 到约 4e+8 范围内的值。这可以处理许多用例，但可能需要使用 scale 函数来调整输入，例如，从 By 到 MiBy 或“MBy”（如果字节数范围将以千兆字节或太字节为单位）。

如果参数表达式为分布值，则返回所有分布合并后的总体值的百分位的估算值。百分位的计算方法为，将所有输入分布合并为一个分布并估算百分位。百分位的准确度取决于输入分布的分桶边界。

如果对于某个输入行，第一个参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响百分位。

附加到 percentile 结果的度量单位与输入的单位相同。

fraction_less_than   一组值中小于固定值的值的比例。

签名：  fraction_less_than(Summable,   lit-Num )   →   Double

如果第一个参数是数值（Int 或 *Double），则返回传递给第一个参数且小于 lit-Num 的值的比例。在计算此比例时，它会忽略非有限 Double 值以及不是一个值的 Int 和 Double 值。

如果第一个参数是 Distribution 值，合并传递给它的所有分布的总体，并估算该聚合分布中所有小于 lit-Num 参数的值占总体的比例。

附加到 fraction_less_than 结果的度量单位为 10^2.%。

fraction_true   一组布尔值中 true 值的比例。

签名：  fraction_true(Bool )   →   Double

收集输入的布尔值，结果是值为 true 的输入值的比例，该比例是 Double 值，范围是 0 到 1。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 fraction_true 结果的度量单位为 10^2.%。

any_true   一组布尔值的析取。

签名：  any_true(Bool )   →   Bool

如果 any_true 函数的所有输入值都为 true，则计算结果为 true 值，否则返回 false。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

all_true   一组布尔值的结合。

签名：  all_true(Bool )   →   Bool

如果 all_true 函数的所有输入值都为 true，则计算结果为 true 值，否则返回 false。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

pick_any   一组值中任意元素的值（任意选择）。

签名：  pick_any(ColumnValue )   →   FirstArgType

此函数返回提供给它的任意一个值。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 pick_any 结果的度量单位与输入的单位相同（如有）。

singleton   一组值中只有一个元素的元素的值。

签名：  singleton(ColumnValue )   →   FirstArgType

此函数返回其对一个行进行运算的参数表达式值。如果其参数表达式针对多行进行运算并生成值，则会出错，即使计算结果为先前生成的值也是如此。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 singleton 结果的度量单位与输入的单位相同。

unique   一组值（必须全部相同）的公共值。

签名：  unique(Comparable )   →   FirstArgType

unique 函数返回的值与提供给它的每个值都相同。如果没有这样的值（至少提供了两个不同的值），则它会生成错误并返回一个提供给它的值。

如果对于某个输入行，参数表达式的计算结果不是一个值，则该输入行不影响结果。

附加到 unique 结果的度量单位与输入的单位相同。

aggregate   任意类型的一组值的默认聚合值。

签名：  aggregate(Num )   →   Num.Delta     (temporal only)
          aggregate(Distribution )   →   Distribution.Delta     (temporal only)
          aggregate(Num )   →   Num.Gauge     (sliding temporal only)
          aggregate(Distribution )   →   Distribution.Gauge     (sliding temporal only)
          aggregate(Num )   →   Num.FirstArgKind
          aggregate(Distribution )   →   Distribution.FirstArgKind
          aggregate(Bool )   →   Bool
          aggregate(String )   →   String

aggregate 函数进行取决于输入类型的聚合。

  • 对于 Int 和 Double 输入，它与 sum 聚合器相同。

  • 对于 Distribution 输入，它与 distribution 聚合器相同。

  • 对于 Bool 输入，它与 any_true 聚合器相同。

  • 对于 String 输入，它与 pick_any 聚合器相同。

weighted_distribution   一组加权值的分布。

签名：  weighted_distribution(Num,   Int,   lit-BucketSpecification )   →   Distribution.Delta     (temporal only)
          weighted_distribution(Num,   Int,   lit-BucketSpecification )   →   Distribution.Gauge

将输入值收集到一个分布结果中，该结果的分桶规范由 lit-Bucketer 参数提供。第一个参数是要添加到分布的值，第二个参数是该值的权重。权重为 M 的值 N 在分布中表示为值为 N 的 M 实例。

如果对于某个输入行，第一个参数表达式的计算结果不是一个值或者是一个非有限 Double 值，则该输入行不影响百分位。

附加到 weighted_distribution 结果的度量单位与输入的单位相同。

校准

align 表操作使用校准函数来生成校准表，该表的时间序列中的点具有定期时间戳。

除了其明确的 Duration 参数之外，校准函数还会接受输入时间序列和时间点，并生成该特定时间的输出点。

interpolate 校准函数在输入时间序列中两个相邻时间点之间进行插值操作，从而在给定时间生成值。

next_older 和 next_younger 校准函数会从输入时间序列中的一个点生成值，该点的时间戳是输出时间戳的上一个时间点或下一个时间点。

delta、rate 和 delta_gauge 校准函数根据输入时间序列的值在一个时间窗口上的变化来计算输出。该时间窗口以输出点的结束时间为较晚边缘并具有 Duration 参数的时长。该变化值的计算方法如下：

  • 因此，输入时间序列的任何给定时间的值都可以通过在最接近输出时间的上一个点和下一个点之间进行线性插值来计算。给定窗口上的值变化是窗口较早边缘与较晚边缘上的内插值之间的差值。

  • 窗口中的变化量是范围完全在窗口中的所有点的值的总和，以及范围部分与窗口重叠的点的成比例的份额。

  • 对于累积时间序列，开始时间相同的两个相邻点之间的插值是通过两个值之间的线性插值来完成的。具有不同开始时间的相邻点之间的插值（这使得较晚点的开始时间在两点的结束时间之间）按如下方式处理：

    • 如果输出时间在较早点的结束时间和较晚点的开始时间之间，则结果为较早点的值。（较早点和重置时间之间没有变化。）

    • 如果输出时间在较晚点的开始时间和结束时间之间，则值为零（在开始时间）和该点值之间的线性插值。

    对于累积时间序列，给定窗口上的值变化是窗口较早边缘与较晚边缘上的内插值之间的差值，加上一个重置修正值。对于该窗口内的每个重置时间，该重置时间的上一个点的值会加到变化值中，以弥补在该时间重置为 0 的时间序列值。

    聚合校准函数 mean_aligner 和 int_mean_aligner 将聚合函数应用于时间窗口内的输入点，该时间窗口的宽度由 Duration 参数指定，其较晚边缘为输出点的时间戳。该集合的结果指的是输出点的值。

    校准函数的输出的度量单位通常与输入相同。例外情况如下：

    • rate 的输出的单位为输入除以单位“s”。

    • count_true_aligner 的输出的单位为 1。

    • fraction_true_aligner 的输出的单位为 10^2.%

rate   计算校准时间点的变化率。

签名：  ImplicitRowInput   rate([ lit-Duration ] )   →   Double.Gauge     (implicit row input)

rate 校准器使用单个数字（Int 或 *Double）类型的值列对输入时间序列进行运算。它始终生成这样一个输出表：该表具有单个 Double 类型的值列和采样平均值时间序列种类。

rate 校准器计算时间序列的值在其窗口上的变化（如此处所述），并将其除以窗口宽度（以秒为单位）。窗口的范围为输出点时间往前至 Duration 参数时间。

Duration 参数的默认值是校准时间段。与 'delta' 校准函数不同的是，不要求校准时间段与窗口宽度匹配。

delta   计算校准时间点的值变化。

签名：  ImplicitRowInput   delta([ lit-Duration ] )   →   InputType.Delta     (implicit row input)

delta 校准器使用单个 Summable 类型（Int、Double 或 Distribution）的值列对输入时间序列进行运算，输出是一个时间序列，其值列的类型与输入相同，但具有增量时间序列种类。

“delta_gauge”校准器计算输入时间序列在一个时间窗口上的值变化。该时间窗口以输出时间为较晚边缘并具有 Duration 参数的时长。输出点的开始时间是从输出时间（该点的结束时间）往前推移 Duration 参数时长的时间点。

delta 校准器要求其 Duration 参数与其使用的校准时间段相同。Duration 参数的默认值为该校准时间段。

any_true_aligner   通过查找窗口中的任何真实值来对齐布尔值时间序列。

签名：  ImplicitRowInput   any_true_aligner([ lit-Duration ] )   →   Bool.Gauge     (implicit row input)

any_true_aligner 函数对具有布尔值类型的单个值列的输入表进行操作，并生成具有布尔值类型和仪表盘时间序列类型的单个值列的输出表。

Duration 参数会提供在该输出点结束时每个输出点的时间窗口宽度。如果未指定 Duration 参数，则默认为对齐时间段。如果窗口中的任何输入点为 true，则输出点的值为 true，否则为 false。

count_true_aligner   通过计算窗口中的真实值来对齐布尔值时间序列。

签名：  ImplicitRowInput   count_true_aligner([ lit-Duration ] )   →   Int.Gauge     (implicit row input)

count_true_aligner 函数对具有布尔值类型的单个值列的输入表进行操作，并生成具有 Int 类型和仪表盘时间序列类型的单个值列的输出表。

Duration 参数会提供在该输出点结束时每个输出点的时间窗口宽度。如果未指定 Duration 参数，则默认为对齐时间段。输出点的值是窗口中输入点的数量，值为 true。

delta_gauge   计算校准时间点的值变化（采样平均值时间序列）。

签名：  ImplicitRowInput   delta_gauge([ lit-Duration ] )   →   InputType.Gauge     (implicit row input)

delta_gauge 校准器使用单个 Summable 类型（Int、Double 或 Distribution）的值列对输入时间序列进行运算，输出是一个时间序列，其值列的类型与输入相同，但具有采样平均值时间序列种类。

delta_gauge 校准器计算输入时间序列值在其窗口上的值变化（如此处所述）。窗口的范围为输出点时间往前至 Duration 参数时间。

Duration 参数的默认值是校准时间段。与 'delta' 校准函数不同的是，不要求校准时间段与窗口宽度匹配。

fraction_true_aligner   对齐布尔值时间序列与窗口中真实值的比例。

签名：  ImplicitRowInput   fraction_true_aligner([ lit-Duration ] )   →   Double.Gauge     (implicit row input)

fraction_true_aligner 函数对具有布尔值类型的单个值列的输入表进行操作，并生成具有 Double 类型和仪表盘时间序列类型的单个值列的输出表。

Duration 参数会提供在该输出点结束时每个输出点的时间窗口宽度。如果未指定 Duration 参数，则默认为对齐时间段。输出点的值是窗口中具有 true 值的所有输入点的比例。

int_mean_aligner   通过找到窗口中 Int 值的平均值对齐。

签名：  ImplicitRowInput   int_mean_aligner([ lit-Duration ] )   →   Int.Gauge     (implicit row input)

int_mean_aligner 函数在输入表上运行，该表具有一个 Int 类型和刻度盘或 Delta 时间序列类型的单值列。这会生成一个输出表，包含 Int 类型和刻度盘时间序列类型的单值列。

Duration 参数会提供在该输出点结束时每个输出点的时间窗口宽度。如果未指定 Duration 参数，则默认为对齐时间段。输出点的值是落在上述窗口的输入表值点的平均值，四舍五入到最接近的整数值。

interpolate   计算校准时间点的内插值。

签名：  ImplicitRowInput   interpolate([ lit-Duration ] )   →   InputType.Gauge     (implicit row input)

interpolate 校准器使用单个数字（Int 或 *Double）类型并且具有采样平均值时间序列种类的值列对输入表进行运算。生成一个输出表，该表包含具有相同类型和时间序列种类的单个值列。

如果 interpolate 校准函数的输出时间与输入时间序列中某个点的结束时间相同，则把该时间用于输出点。否则，interpolate 校准器会考虑其结束时间为最接近输出时间的较早点和较晚点的输入点。如果这些点之间的距离不超过 Duration 参数，则输出时间上的输出值为这两个点之间的线性内插值。如果没有输入点早于输出时间，或者没有输入点晚于输出时间，或者如果两个输入点之间的距离超过了 Duration 参数，则不会生成输出值。

Duration 参数的默认值是校准时间段的两倍。

mean_aligner   通过查找窗口中值的平均值对齐。

签名：  ImplicitRowInput   mean_aligner([ lit-Duration ] )   →   Double.Gauge     (implicit row input)

mean_aligner 函数在具有数字类型单值列的输入表上运行。（Int 或 Double）和刻度盘或 Delta 时间序列类型。它会生成这样一个输出表：该表具有单个 Double 类型的值列和采样平均值时间序列种类。

Duration 参数会提供在该输出点结束时每个输出点的时间窗口宽度。如果未指定 Duration 参数，则默认为对齐时间段。输出点的值是输入在上述窗口内的输入表值点的平均值。

next_older 通过从较早时间移动到较晚时间校准时间点。

签名：  ImplicitRowInput   next_older([ lit-Duration ] )   →   InputType.Gauge     (implicit row input)

next_older 校准器使用任意类型但具有采样平均值时间序列种类的任意数量的值列对时间序列进行运算。生成具有相同类型和时间序列种类的输出列。

为了创建输出点，next_older 校准器查找结束时间不晚于输出时间且结束时间与输出时间的距离不超过 Duration 参数的最晚输入点。如果没有此类输入点，则不创建输出点。

Duration 参数的默认值是校准时间段的两倍。

next_younger 通过从较晚时间移动到较早时间校准时间点。

签名：  ImplicitRowInput   next_younger([ lit-Duration ] )   →   InputType.Gauge     (implicit row input)

next_younger 校准器使用任意类型但具有采样平均值时间序列种类的任意数量的值列对时间序列进行运算。生成具有相同类型和时间序列种类的输出列。

为了创建输出点，next_younger 校准器查找结束时间不早于输出时间且结束时间与输出时间的距离不超过 Duration 参数的最早输入点。如果没有此类输入点，则不创建输出点。

Duration 参数的默认值是校准时间段的两倍。

操纵单位

这些函数会更改其应用到的表达式的单位。

scale 将值缩放到不同的度量单位。

签名：  scale(Num,   [ lit-String ] )   →   Double
          scale(Duration,   [ lit-String ] )   →   Double
          scale(Date,   [ lit-String ] )   →   Double

scale 函数返回第一个参数的值，该值转换为双精度型（如有必要）并可能经过缩放，以具有第二个参数提供的单位。

如果未提供第二个参数，scale 函数只会将其第一个参数转换为双精度型，而不更改单位（如果如此处所述调用了自动缩放）。在这种情况下，第二个参数是隐式提供的，并且 scale 的行为与提供了两个参数时一样。

第二个参数（如果提供）必须是第一个参数要缩放到的单位的有效 UCUM 代码字符串。 在这种情况下，返回值表示与输入值相同的物理量，但使用第二个参数提供的单位表示。实现方法是将参数乘以相应的缩放比例。

例如，表达式 scale(3 "min", "s") 会将单位为分钟 (min) 的值 3 转换为单位为秒 (s) 的值 180。时间相同，单位不同。

如果第一个参数没有单位，或者第一个参数的单位的量纲与作为第二个参数提供的单位代码不同，则会发生错误。如果它们的量纲不相同，无法将第一个参数缩放为第二个参数提供的量纲。

例如，scale(3 "km", "m/s") 要求将 3 公里缩放为以米/秒为单位的某个数字，这是错误的，因为公里的量纲为“距离”，米/秒的量纲为“单位时间的距离”（速度）。没有缩放比例能将距离转换为速度。因此，为了进行计算，我们需要将距离除以某个以时间为单位的值。例如，scale(3 "km" / 10 "min", "m/s") 会将 .3 "km/min" 缩放为 5 "m/s"。

如果第一个参数是 Date 或 Duration 参数，则第二个参数必须提供时间单位（例如 "s"、"h" 或 "wk"）。返回值将为 Double 值，指定第一个参数值在第二个参数提供的单位中的时间。对于 Date 值，这将为自 Unix 纪元以来的时间长度。

例如：scale(1m, "s") 会生成值 60.0，单位为 s，而 scale(d'1970/01/01-01:00:00+00', "h") 会生成值 1.0，单位为“h”（从 Unix 纪元开始一个小时）。

cast_units 设置值的度量单位。

签名：  cast_units(Summable,   lit-String )   →   FirstArgType

cast_units 函数返回第一个参数的未变化的值，但将该值的度量单位设置为第二个参数字符串提供的单位。

该字符串必须是值所需单位的 UCUM 代码字符串。第一个参数在应用此函数之前具有的单位会被忽略。

定期窗口

定期窗口函数用于注释传递到 WindowDuration 参数的 Duration 实际参数。WindowDuration 参数指定用于选择输入点以进行定期计算的窗口宽度。Duration 参数会传递到 group_by 表操作，该操作输出校准时间序列。window 和 sliding 函数根据输出校准时间段限制输入窗口宽度。

window 函数表示校准时间段和窗口宽度必须相同，从而使输入点窗口不重叠。

sliding 函数表示校准时间段可以小于窗口宽度，从而导致输入窗口重叠。

window   表示与校准时间段相同的窗口。

签名：  window([ lit-Duration ] )   →   lit-WindowDuration

window 函数对传递给 WindowDuration 参数的 Duration 实际参数进行注释，WindowDuration 参数指定用于生成校准时间序列的计算的窗口宽度。它要求窗口宽度和输出校准时间段都与其 Duration 参数相同。如果未提供 Duration 参数，则它指定窗口宽度为输出校准时间段，但该值已定义。

例如，表操作 |group_bywindow(5m), .mean 生成的输出点是在输出结束时间 5 分钟窗口内的输入点的平均值。window 函数注释 5m 窗口宽度，要求 group_by 的校准时间段也为 5 分钟。表操作 | group_by window(), .mean 还要求窗口宽度与输出校准时间段相同，但不指定具体的值。

sliding   表示滑动（重叠）而非不相交的窗口。

签名：  sliding(lit-Duration )   →   lit-SlidingDuration

sliding 函数对传递给 WindowDuration 参数的 Duration 实际参数进行注释，WindowDuration 参数指定用于生成校准时间序列的计算的窗口宽度。它要求窗口宽度是其 Duration 参数，并要求校准时间段不大于这个值（但可以小于）。

例如，表操作 |group_bysliding(5m), .mean 生成的输出点是在输出结束时间 5 分钟窗口内的输入点的平均值。注释 5m 窗口宽度的 sliding 函数表示 group_by 的校准时间段可以为 5 分钟以下的任意时间。如果有一个表示 1 分钟校准的 | every 1m 表操作，则每个 5 分钟窗口中的 4 分钟将与上一个输出点的窗口重叠。

分布

count_from   一个分布值中值的数量。

签名：  count_from(Distribution.CumulativeOK )   →   Int.FirstArgKind

count_from 函数返回其输入分布值中的总体值的大小。

附加到 count_from 结果的度量单位为 1。

sum_from   一个分布值中各值的总和。

签名：  sum_from(Distribution.CumulativeOK )   →   Double.FirstArgKind

sum_from 函数返回其输入分配值中包含的所有值的总和。

sum_from 的结果与输入具有相同的度量单位。

mean_from   一个分布值中值的平均值。

签名：  mean_from(Distribution )   →   Double

mean_from 函数返回其输入分配值中包含的所有值的算术平均值。

mean_from 的结果与输入具有相同的度量单位。

stddev_from   一个分布值中值的标准差。

签名：  stddev_from(Distribution )   →   Double

stddev_from 函数返回其输入分布值中包含的总体值的方差。

stddev_from 的结果与输入具有相同的度量单位。

variance_from   一个分布值中值的方差。

签名：  variance_from(Distribution )   →   Double

variance_from 函数返回其输入分布值中包含的总体值的方差。

“variance_from”函数的结果没有度量单位。

median_from   一个分布值中值的中位数。

签名：  median_from(Distribution )   →   Double

median_from 函数返回其输入分布值中包含的总体值的中位数。

median_from 的结果与输入具有相同的度量单位。

percentile_from   一个分布值中值的百分位。

签名：  percentile_from(Distribution,   lit-Num )   →   Double

percentile_from 函数返回其输入分布值中包含的总体值的百分位。Num 参数提供介于 0 到 100 之间的百分位估算值。

percentile_from 的结果与输入具有相同的度量单位。

fraction_less_than_from   分布值中小于一个固定值的值的比例。

签名：  fraction_less_than_from(Distribution,   lit-Num )   →   Double

fraction_less_than_from 函数返回其输入分布值中小于 Num 的值占总体的比例的估算值。

附加到 fraction_less_than 结果的度量单位为 10^2.%。

bounded_percentile_from   分布值中某个边界内值的百分位。

签名：  bounded_percentile_from(Distribution,   lit-Num,   [ lit-Num ],   [ lit-Num ] )   →   Double

bounded_percentile_from 函数对输入分布中包含的值的子集执进行运算。估算值由以下总体值组成：大于第二个 Num 参数（如果提供），并且小于或等于第三个 Num 参数（如果提供）的值。必须至少提供第二个和第三个 Num 参数中的一个，如果两个参数都提供，则第二个必须小于第三个。

返回该估算总体值的百分位估算值。第一个 Num 参数提供介于 0 到 100 之间的百分位估算值。

bounded_percentile_from 的结果与输入具有相同的度量单位。

rebucket   转换为新的分桶规范的分布值。

签名：  rebucket(Distribution,   lit-BucketSpecification )   →   Distribution

将输入的 Distribution 值转换为分桶规范由第二个参数 BucketSpecification 提供的 Distribution 值。

这样，在假设分桶中计数的值均匀分布在该分桶的范围内的前提下，将输入分布中每个分桶的计数分布到输出分布的分桶中。输出分布具有与输入分布相同的总计数，但计数在输出分布桶中的分布并不相同。输出分布与输入分布具有相同的总和、均值和标准差。

分桶说明符

一个分布值具有一个由分桶组成的直方图。每个分桶都与一个值范围相关联，并且包含分布中位于该范围内的值的数量。每个分布都有一个分桶规范，描述了分布值中分桶的边界。本部分中的函数生成分桶规范。

powers_of   分桶边界指数增长的分桶规范。

签名：  powers_of(lit-Num )   →   lit-BucketSpecification

powers_of 函数返回一个分桶规范，其中每个分桶的上限等于一个固定因子（由 Num 参数提供）乘以下限。因此，分桶大小以指数级速率增长，计算百分位的误差受限于值为 true 的常数因子。

这不会设置分桶的数量或第一个分桶的下限，这两个值要么由 'num_buckets' 和 'lower' 指定，要么使用默认值（30 个分桶，下限为 1.0）。如果分桶规范由 powers_of 提供，则下限必须大于 0。

以下示例提供了一个分桶规范，其中规定 50 个分桶，其大小以 1.1 的速率城指数级增长，起始值为 100。因此，分桶边界为 1、1.1、1.21、1.331 等。

powers_of(1.1).num_buckets(30).lower(100.0)

fixed_width 分桶大小相同的分桶规范。

签名：  fixed_width(lit-Num )   →   lit-BucketSpecification

fixed_width 函数返回一个分桶规范，其中每个分桶的上限比下限（由 Num 参数提供）多出一个固定数量。因此，分桶大小是固定的。

这不会设置分桶的数量或第一个分桶的下限，这两个值要么由 'num_buckets' 和 'lower' 指定，要么使用默认值（30 个分桶，下限为 1.0）。

以下示例提供了一个分桶规范，其中包含 100 个大小为 1 的分桶，起始值为 1。这是百分比值分布的良好规范。

fixed_width(1).num_buckets(100)

custom   基于分桶边界列表的分桶规范。

签名：  custom(lit-Num... )   →   lit-BucketSpecification

custom 函数返回具有明确给定的分桶边界的分桶规范。函数接受多个数值参数，这些参数必须按升序提供。第一个分桶的下限由第一个参数提供，最后一个分桶的上限由最后一个参数提供。每个中间参数都提供上一个分桶的上限和下一个分桶的上限。

这完全确定了分桶规范，提供了分桶的数量以及每个分桶的确切边界。

以下示例提供了包含 3 个分桶的分桶规范。第一个的边界为 3 和 27，第二个为 27 和 105，第三个为 105 和 277。

custom(3,27,105,277)

num_buckets   设置分桶规范中的分桶数量。

签名：  num_buckets(lit-BucketSpecification,   lit-Num )   →   lit-BucketSpecification

应用于未确定分桶数量的分桶规范时，num_buckets 函数返回分桶规范，其中包含由 Num 参数提供的分桶数量。输入分桶规范的所有其他方面均保留。

将 num_buckets 应用于已确定分桶数量的分桶规范会发生错误。

bounds   设置第一个分桶的下限和最后一个分桶的上限。

签名：  bounds(lit-BucketSpecification,   lit-Num,   lit-Num )   →   lit-BucketSpecification

如果将其应用于没有确定第一个分桶下限或最后一个分桶上限的分桶规范，bounds 函数返回一个分桶规范，其中第一个分桶的下限由第一个 Num 参数提供，最后一个分桶的上限由第二个 Num 参数提供。输入分桶规范的所有其他方面均保留。

将 bounds 应用于已确定第一个分桶下限或最后一个分桶上限的分桶规范会发生错误。

lower   设置分桶规范中第一个分桶的下限。

签名：  lower(lit-BucketSpecification,   lit-Num )   →   lit-BucketSpecification

应用于未确定第一个分桶下限的分桶规范时，num_buckets 函数返回一个分桶规范，其中第一个分桶的下限由其 Num 参数指定。输入分桶规范的所有其他方面均保留。

将lower应用于已确定第一个分桶下限的分桶规范时出错。

其他

cast_double   将 Int 值转换为 Double。

签名：  cast_double(Num.CumulativeOK )   →   Double.FirstArgKind

cast_double 函数接受单个 Int 参数并返回最接近的 Double 值。

cast_double 的结果与输入具有相同的度量单位。

cast_gauge   将累积或增量时间序列值转换为采样平均值。

签名：  cast_gauge(ColumnValue.CumulativeOK )   →   FirstArgType.Gauge

cast_gauge 函数返回其参数的值，但会将值的时间序列种类更改为采样平均值。

如果这会导致输出表不包含具有增量时间序列种类的值列，则输出表将没有开始时间列。

cast_gauge 的结果与输入具有相同的度量单位。

within   指定排序值计算的窗口。

签名：  within(ColumnValue,   [ lit-DateOrDuration ],   [ lit-DateOrDuration ] )   →   Windowed.FirstArgKind

within 函数修饰 top 或 bottom 表操作的 Windowed(Num) 排序值参数绑定的表达式。它指定在其中计算排序值表达式的窗口，方法是指定以下三个值中的一个或两个：窗口的最早（开始）时间、窗口的最晚（结束）时间或窗口的持续时间）。

如果 within 的两个参数中有一个为正值 Duration，则设置为窗口的宽度。最多只能有一个参数是这样的 Duration。

如果第一个参数是 Date，则指定为开始时间。如果第二个参数是 Date，则指定为结束时间。如果这两个值都是 Date 值，则第二个值代表的时间必须晚于第一个值。Date 参数可以作为 Date 字面量提供，也可以与负的 Duration 字面量一起提供。在后一种情况中，时间是指定的早于外部查询窗口结束时间的 Duration（请参阅 within 表操作）。

如果未指定第一个参数，则默认为外部查询窗口的开始时间。如果未指定第二个参数，则默认为外部查询窗口的结束时间。

例如，.mean().within(1h,-2h) 表示应将 max 缩减器应用于输入时间序列中的所有如下点：其结束时间在宽度为 1 小时的窗口内，且结束时间在 2 小时之前。mean 聚合器应用于结束时间在此窗口中的所有输入点。

例如，max(val()).within(10m) 表示应将 max 缩减器应用于输入时间序列中的所有如下点：其结束时间在查询结束时间以及往前 10 分钟的时间范围内。max 聚合器应用于结束时间在此窗口中的所有输入点。

表操作和函数索引

所有表操作和函数的索引。

  • abs 绝对值。
  • absent_for 创建输入缺失条件。
  • add 两个数字的总和。
  • adjacent_delta 输入点与上一个点之间的值变化。
  • adjacent_rate 输入点与上一个点（行）之间的变化率。
  • aggregate 一组值中任意类型的默认聚合值。
  • align 使用校准函数生成校准表。
  • all_true 一组布尔值的结合。
  • and 两个布尔值的逻辑与。
  • any_true 一组布尔值的析取。
  • any_true_aligner    通过查找窗口中的任何真实值来对齐布尔值时间序列。
  • ascii_to_lower 将 ASCII 大写字母字符更改为小写字母。
  • ascii_to_upper 将 ASCII 小写字母字符更改为大写字母。
  • bottom 根据排序值表达式选择最靠后的时间序列。
  • bottom_by 根据排序值表达式在不同组中选择时间序列。
  • bounded_percentile_from 分布值中某个边界内值的百分位。
  • bounds 设置第一个分桶的下限和最后一个分桶的上限。
  • cast_double 将 Int 值转换为 Double。
  • cast_gauge 将累积或增量时间序列值转换为采样平均值。
  • cast_units 设置值的度量单位。
  • concatenate 字符串串联。
  • condition 向输入表添加布尔条件列。
  • count 一组值中值的数量。
  • count_from 一个分布值中值的数量。
  • count_true 一组布尔值中 true 值的数量。
  • count_true_aligner    通过计算窗口中的真实值来对齐布尔值时间序列。
  • covariance 一组值对的协方差。
  • custom 来自分桶边界列表的分桶规范。
  • delta 计算校准时间点的值变化。
  • delta_gauge 计算校准时间点的值变化（采样平均值时间序列）。
  • diameter 一组数值中最大值减去最小值。
  • distribution 一组数值或分布值的分布。
  • div 两个数字的比率。
  • end 输入点（行）的结束时间。
  • eq 等于。
  • every 指定校准表输出的时间段。
  • exp e 的幂运算。
  • false 布尔值 false。
  • fetch 从数据库生成表。
  • fetch_cumulative 从数据库生成累积时间序列表。
  • filter 按谓词过滤输入表中的行。
  • filter_ratio 计算输入值列的两个过滤总和的比率。
  • filter_ratio_by 计算输入值列的两个过滤总和的分组比率。
  • fixed_width 分桶大小相同的分桶规范。
  • fraction_less_than 一组值中小于固定值的值的比例。
  • fraction_less_than_from 分布值中小于一个固定值的值的比例。
  • fraction_true 一组布尔值中 true 值的比例。
  • fraction_true_aligner    对齐布尔值时间序列与窗口中真实值的比例。
  • ge 大于或等于。
  • graph_period 指定绘制时间序列图表的首选输出期。
  • group_by 根据映射的时间序列标识符和时间窗口聚合行。
  • gt 大于。
  • has 如果 set 参数包含特定值，则为 true。
  • has_value 如果参数表达式计算出一个值，则为 true。
  • hash_tsid 返回时间序列标识符列的哈希值。
  • ident 身份表操作：不更改输入表。
  • if 有条件地从两个值中选择的值。
  • int_ceil 上限整数。
  • int_div 两个整数相除的商。
  • int_floor 下限整数。
  • int_mean_aligner    通过找到窗口中 Int 值的平均值对齐。
  • int_round 四舍五入的整数。
  • interpolate 计算校准时间点的内插值。
  • join 多个表的自然联接。
  • le 小于或等于。
  • log 自然对数。
  • lower 设置分桶规范中第一个分桶的下限。
  • lt 小于。
  • map 重写表中每一行的时间序列标识符和值列。
  • max 一组数值中的最大值。
  • mean 一组数值的平均值。
  • mean_aligner    通过查找窗口中值的平均值对齐。
  • mean_from 一个分布值中值的平均值。
  • median 一组数值或分布值的中位数。
  • median_from 一个分布值中值的中位数。
  • metric 从一组表中生成特定指标类型的表。
  • min 一组数值中的最小值。
  • mul 两个数字的乘积。
  • ne 不等于。
  • neg 数字的负数。
  • next_older 通过从较早时间移动到较晚时间校准时间点。
  • next_younger 通过从较晚时间移动到较早时间校准时间点。
  • not 布尔值的逻辑求反。
  • num_buckets 设置分桶规范中的分桶数量。
  • older 时间序列中上一个点（行）的值。
  • or 两个布尔值的逻辑或。
  • or_else 一个值，或者如果不是一个值，则为另一个值。
  • outer_join 两个表的自然外联接。
  • percentile 一组数值或分布值的百分位。
  • percentile_from 一个分布值中值的百分位。
  • pick_any 一组值中任意元素的值（任意选择）。
  • pos 数字输入的身份。
  • power 幂运算。
  • powers_of 分桶边界指数增加的分桶规范。
  • rate 计算校准时间点的变化率。
  • ratio 计算两个校准的输入表的值列的比率。
  • re_extract 提取正则表达式在另一个字符串中匹配的值。
  • re_full_match 如果正则表达式与整个字符串值匹配，则为 true。
  • re_global_replace 替换正则表达式在另一个字符串中的所有匹配。
  • re_partial_match 如果正则表达式与字符串值的某个部分匹配，则为 true。
  • re_replace 替换正则表达式在另一个字符串中的第一个匹配。
  • rebucket 转换为新的分桶规范的分布值。
  • rem 两个整数相除的余数。
  • row_count 遇到的输入行数。
  • scale 将值缩放到不同的度量单位。
  • singleton 一组值中只有一个元素的元素的值。
  • sliding 表示滑动（重叠）而非不相交的窗口。
  • sqrt 平方根。
  • start 输入点（行）的开始时间。
  • stddev 一组值的标准差。
  • stddev_from 一个分布值中值的标准差。
  • string_to_double 将 String 转换为 Double。
  • string_to_int64 将 String 转换为 Int。
  • sub 两个数字之差。
  • sum 一组数值之和。
  • sum_from 一个分布值中各值的总和。
  • time_shift 将时间序列在时间上前移。
  • top 根据排序值表达式选择最靠前的时间序列。
  • top_by 根据排序值表达式在不同组中选择时间序列。
  • true 布尔值 true。
  • unaligned_group_by 根据映射的时间序列标识符聚合行，但不校准。
  • union 多个表的并集。
  • union_group_by 聚合来自多个表的行。
  • unique 一组值（必须全部相同）的公共值。
  • utf8_normalize适合用于大小写折叠比较的 Unicode 字符串。
  • val 值列在输入点（行）中的值。
  • value 重写表中每行的值列。
  • variance 一组数值的方差。
  • variance_from 一个分布值中值的方差。
  • weighted_distribution 一组加权值的分布。
  • window 表示与校准时间段相同的窗口。
  • window 指定校准操作的窗口。
  • within 指定排序值计算的窗口。
  • within 指定查询输出的时间范围。