', default: (\)
```
以 CSV 格式导出数据时，此字段指定应在写入 S3 存储桶的数据文件中作为转义字符处理的字符。如果存在以下情形，可能会发生转义：
1. 如果值本身包含引号字符（"），则将使用转义字符进行转义。例如，如果值为 `Time"stream`，其中（\$1）是已配置的转义字符，则将其转义为 `Time\"stream`。
1. 如果该值包含已配置的转义字符，则将对其进行转义。例如，如果值为 `Time\stream`，则将其转义为 `Time\\stream`。
如果导出的输出包含数组、行或时间序列等复杂数据类型，则会将其序列化为 JSON 字符串。以下为示例。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1HEADER
```
include_header = 'true' , default: 'false'
```
以 CSV 格式导出数据时，此字段允许您将列名作为导出 CSV 数据文件的首行。
可接受的值为“true”和“false”，默认值为“false”。`escaped_by` 和 `field_delimiter` 等文本转换选项同样适用于标题。
包含标题时，请避免使用回车符（ASCII 13、十六进制 0D、文本 '\$1r'）或换行符（ASCII 10、十六进制 0A、文本 '\$1n'）作为 `FIELD_DELIMITER`，否则将导致多数解析器无法正确解析最终 CSV 输出中的标题。
MAX\$1FILE\$1SIZE
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
此字段指定 `UNLOAD` 语句在 Amazon S3 中创建的文件最大大小。`UNLOAD` 语句可创建多个文件，但写入 Amazon S3 的每个文件最大大小将大致等于此字段中指定的值。
该字段的值必须在 16MB（含）和 78GB（含）之间。可以用整数（例如 `12GB`）或小数（例如 `0.5GB` 或 `24.7MB`）进行指定。默认值为 78 GB。
写入文件时，实际文件大小是近似值，因此实际最大大小可能不完全等于您指定的数字。
# 逻辑运算符
Timestream fo LiveAnalytics r 支持以下逻辑运算符。
| 运算符 | 描述 | 示例 |
| --- | --- | --- |
| AND | 如果两个值都为 true，则返回 true | a AND b |
| 或 | 如果任一值为 true，则返回 true | a OR b |
| NOT | 如果值为 false，则返回 true。 | NOT a |
+ 如果表达式的一侧或两侧均为 `NULL`，则 `AND` 的比较结果可能是 `NULL`。
+ 如果 `AND` 运算符的至少一侧为 `FALSE`，则表达式的计算结果为 `FALSE`。
+ 如果表达式的一侧或两侧均为 `NULL`，则 `OR` 的比较结果可能是 `NULL`。
+ 如果 `OR` 运算符的至少一侧为 `TRUE`，则表达式的计算结果为 `TRUE`。
+ `NULL` 的逻辑补语为 `NULL`。
以下真值表演示 `NULL` 在 `AND` 和 `OR` 中的处理方式：
| A | B | A and b | A or b |
| --- | --- | --- | --- |
| null | null | null | null |
| false | null | false | null |
| null | false | false | null |
| true | null | null | true |
| null | true | null | true |
| false | false | false | false |
| true | false | false | true |
| false | true | false | true |
| true | true | true | true |
以下真值表演示 NULL 在 NOT 中的处理方式：
| A | Not a |
| --- | --- |
| null | null |
| true | false |
| false | true |
# 比较运算符
Timestream for LiveAnalytics 支持以下比较运算符。
| 运算符 | 说明 |
| --- | --- |
| < | Less than |
| > | Greater than |
| <= | 小于或等于 |
| >= | 大于或等于 |
| = | Equal |
| <> | Not equal |
| \$1= | Not equal |
**注意**
`BETWEEN` 运算符用于测试值是否在指定范围内。语法如下：
```
BETWEEN min AND max
```
`BETWEEN` 或 `NOT BETWEEN` 语句中出现 `NULL` 将导致该语句的计算结果为 `NULL`。
`IS NULL ` 和 `IS NOT NULL` 运算符用于测试值是否为 null（未定义）。`NULL` 与 `IS NULL` 结合使用的计算结果为 true。
在 SQL 中，`NULL` 值表示未知值。
# 比较函数
的 Timestream LiveAnalytics 支持以下比较函数。
**Topics**
+ [greatest()](comparison-functions.greatest.md)
+ [least()](comparison-functions.least.md)
+ [ALL(), ANY() and SOME()](comparison-functions.all-any-some.md)
# greatest()
**greatest()** 函数返回所提供值中的最大值。如果提供的值中有任何一个为 `NULL`，则返回 `NULL`。语法如下所示。
```
greatest(value1, value2, ..., valueN)
```
# least()
**least()** 函数返回所提供值中的最小值。如果提供的值中有任何一个为 `NULL`，则返回 `NULL`。语法如下所示。
```
least(value1, value2, ..., valueN)
```
# ALL(), ANY() and SOME()
`ALL`、`ANY` 和 `SOME` 量词可与比较运算符结合使用，具体方式如下。
| Expression | 含义 |
| --- | --- |
| A = ALL(...) | 当 A 等于所有值时，计算结果为 true。 |
| A <> ALL(...) | 当 A 与任何值都不匹配时，计算结果为 true。 |
| A < ALL(...) | 当 A 小于最小值时，计算结果为 true。 |
| A = ANY(...) | 当 A 等于任何值时，计算结果为 true。 |
| A <> ANY(...) | 当 A 与一个或多个值不匹配时，计算结果为 true。 |
| A < ANY(...) | 当 A 小于最大值时，计算结果为 true。 |
## 示例和使用说明
**注意**
使用 `ALL`、`ANY` 或 `SOME` 时，如果比较值是字面值列表，则应使用关键字 `VALUES`。
## 示例：`ANY()`
查询语句中 `ANY()` 的示例如下。
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
同一操作的替代语法如下所示。
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
在本例中，`ANY()` 计算结果为 `True`。
## 示例：`ALL()`
查询语句中 `ALL()` 的示例如下。
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
同一操作的替代语法如下所示。
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
在本例中，`ALL()` 计算结果为 `False`。
## 示例：`SOME()`
查询语句中 `SOME()` 的示例如下。
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
同一操作的替代语法如下所示。
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
在本例中，`SOME()` 计算结果为 `True`。
# 条件表达式
Timestream LiveAnalytics 支持以下条件表达式。
**Topics**
+ [CASE 语句](conditional-expressions.CASE.md)
+ [IF 语句](conditional-expressions.IF.md)
+ [COALESCE 语句](conditional-expressions.COALESCE.md)
+ [NULLIF 语句](conditional-expressions.NULLIF.md)
+ [TRY 语句](conditional-expressions.TRY.md)
# CASE 语句
**CASE** 语句从左到右搜索每个值表达式，直至找到与 `expression` 相等的表达式。如果找到匹配项，则返回匹配值的结果。如果未找到匹配项，则返回 `ELSE` 子句的结果（如果存在）；否则返回 `null`。语法如下：
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
Timestream 还支持 **CASE** 语句的以下语法。在此语法中，“searched”形式会从左至右评估每个布尔条件，直至遇到条件为 `true` 的情况，并返回匹配结果。如果没有条件为 `true`，则返回 `ELSE` 子句的结果（如果存在）；否则返回 `null`。另请参阅以下替代语法：
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# IF 语句
**IF** 语句评估条件为真或假，并返回相应的值。Timestream 支持 **IF** 的以下两种语法表示形式：
```
if(condition, true_value)
```
如果条件为 `true`，则此语法计算并返回 `true_value`；否则返回 `null`，且不计算 `true_value`。
```
if(condition, true_value, false_value)
```
如果条件为 `true`，则此语法计算并返回 `true_value`，否则计算并返回 `false_value`。
## 示例
```
SELECT
if(true, 'example 1'),
if(false, 'example 2'),
if(true, 'example 3 true', 'example 3 false'),
if(false, 'example 4 true', 'example 4 false')
```
| \$1col0 | \$1col1 | \$1col2 | \$1col3 |
| --- | --- | --- | --- |
| `example 1` | `-` `null` | `example 3 true` | `example 4 false` |
# COALESCE 语句
**COALESCE** 返回参数列表中第一个非 null 值。语法如下：
```
coalesce(value1, value2[,...])
```
# NULLIF 语句
**IF** 语句评估条件为真或假，并返回相应的值。Timestream 支持 **IF** 的以下两种语法表示形式：
如果 `value1` 等于 `value2`，**NULLIF** 返回 null；否则返回 `value1` 语法如下：
```
nullif(value1, value2)
```
# TRY 语句
**TRY** 函数计算表达式并通过返回 `null`，以处理某些类型的错误。语法如下：
```
try(expression)
```
# 转换函数
Timestream LiveAnalytics 支持以下转换函数。
**Topics**
+ [cast()](#conversion-functions.cast)
+ [try\$1cast()](#conversion-functions.try-cast)
## cast()
显式将值转换为特定类型的 cast 函数语法如下。
```
cast(value AS type)
```
## try\$1cast()
Timestream LiveAnalytics 还支持 try\$1cast 函数，该函数与强制转换类似，但如果强制转换失败则返回 null。语法如下所示。
```
try_cast(value AS type)
```
# 数学运算
Timestream fo LiveAnalytics r 支持以下数学运算符。
| 运算符 | 说明 |
| --- | --- |
| \$1 | 加 |
| - | 减 |
| \$1 | 乘 |
| / | 除法（整数除法执行截断） |
| % | 模（余数） |
# 数学函数
Timestream LiveAnalytics 支持以下数学函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| abs(x) | [与输入相同] | 返回 x 的绝对值。 |
| cbrt(x) | double | 返回 x 的立方根。 |
| ceiling(x) or ceil(x) | [与输入相同] | 返回向上取整到最接近整数的 x 值。 |
| degrees(x) | double | 将以弧度为单位的角度 x 转换为度。 |
| e() | double | 返回常量欧拉数。 |
| exp(x) | double | 返回欧拉数的 x 次方。 |
| floor(x) | [与输入相同] | 返回向下取整到最接近整数的 x 值。 |
| from\$1base(string,radix) | bigint | 返回字符串作为基数解释后的值。 |
| ln(x) | double | 返回 x 的自然对数。 |
| log2(x) | double | 返回 x 的以 2 为底的对数。 |
| log10(x) | double | 返回 x 的以 10 为底的对数。 |
| mod(n,m) | [与输入相同] | 返回 n 除以 m 的模（余数）。 |
| pi() | double | 返回常量 Pi。 |
| pow(x, p) or power(x, p) | double | 返回 x 的 p 次方。 |
| radians(x) | double | 将以度为单位的角度 x 转换为弧度。 |
| rand() or random() | double | 返回在 0.0 到 1.0 范围内的伪随机值。 |
| random(n) | [与输入相同] | 返回 0 到 n（不含）范围内的伪随机值。 |
| round(x) | [与输入相同] | 返回四舍五入到最接近整数的 x 值。 |
| round(x,d) | [与输入相同] | 返回四舍五入到小数点后 d 位的 x。 |
| sign(x) | [与输入相同] | 返回 x 的符号函数，即： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/timestream/latest/developerguide/mathematical-functions.html) 对于双精度参数，该函数还会返回： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/timestream/latest/developerguide/mathematical-functions.html) |
| sqrt(x) | double | 返回 x 的平方根。 |
| to\$1base(x, radix) | varchar | 返回 x 的基数表示形式。 |
| truncate(x) | double | 通过去掉小数点后的数字，将 x 四舍五入为整数。 |
| acos(x) | double | 返回 x 的反余弦值。 |
| asin(x) | double | 返回 x 的反正弦值。 |
| atan(x) | double | 返回 x 的反正切值。 |
| atan2(y, x) | double | 返回 y/x 的反正切值。 |
| cos(x) | double | 返回 x 的余弦值。 |
| cosh(x) | double | 返回 x 的双曲余弦值。 |
| sin(x) | double | 返回 x 的正弦值。 |
| tan(x) | double | 返回 x 的正切值。 |
| tanh(x) | double | 返回 x 的双曲正切值。 |
| infinity() | double | 返回表示正无穷大的常数。 |
| is\$1finite(x) | 布尔值 | 判断 x 是否为有限数。 |
| is\$1infinite(x) | 布尔值 | 判断 x 是否为无穷大。 |
| is\$1nan(x) | 布尔值 | 确定 x 是否为 not-a-number。 |
| nan() | double | 返回表示的常量 not-a-number。 |
# 字符串运算符
Timestream for LiveAnalytics 支持用于连接一个或多个字符串的`||`运算符。
# 字符串函数
**注意**
除非另有说明，否则这些函数的输入数据类型默认为 varchar。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| chr(n) | varchar | 以 varchar 形式返回 Unicode 码点 n。 |
| codepoint(x) | 整数 | 返回 str 中唯一字符的 Unicode 码点。 |
| concat(x1, ..., xN) | varchar | 返回 x1、x2、...、xN 的串联结果。 |
| hamming\$1distance(x1,x2) | bigint | 返回 x1 和 x2 的汉明距离，即对应字符不同的位置数量。请注意，两个 varchar 输入必须具有相同的长度。 |
| length(x) | bigint | 返回 x 的长度（以字符为单位）。 |
| levenshtein\$1distance(x1, x2) | bigint | 返回 x1 和 x2 之间的 Levenshtein 编辑距离，即将 x1 变为 x2 所需的最小单字符编辑次数（插入、删除或替换）。 |
| lower(x) | varchar | 将 x 转换为小写形式。 |
| lpad(x1, bigint size, x2) | varchar | 左侧填充 x1，以使字符与 x2 对齐。如果 size 小于 x1 的长度，则结果被截断为 size 字符。size 不得为负数，x2 必须为非空。 |
| ltrim(x) | varchar | 移除 x 中的前导空格。 |
| replace(x1, x2) | varchar | 从 x1 中移除 x2 的所有实例。 |
| replace(x1, x2, x3) | varchar | 将 x2 的所有实例替换为 x1 中的 x3。 |
| Reverse(x) | varchar | 返回 x，其中字符按反向顺序排列。 |
| rpad(x1, bigint size, x2) | varchar | 右侧填充 x1，以使字符与 x2 对齐。如果 size 小于 x1 的长度，则结果被截断为 size 字符。size 不得为负数，x2 必须为非空。 |
| rtrim(x) | varchar | 移除 x 的尾随空格。 |
| split(x1, x2) | array(varchar) | 在分隔符 x2 处拆分 x1，并返回数组。 |
| split(x1, x2, bigint limit) | array(varchar) | 在分隔符 x2 处拆分 x1，并返回数组。数组中最后一个元素始终包含 x1 中剩余的所有内容。limit 必须为正数。 |
| split\$1part(x1, x2, bigint pos) | varchar | 在分隔符 x2 处拆分 x1，并返回 pos 位置处的 varchar 字段。字段索引从 1 开始。如果 pos 大于字段数，则返回 null。 |
| strpos(x1, x2) | bigint | 返回 x1 中 x2 的第一个实例的起始位置。位置从 1 开始。如果未找到，则返回 0。 |
| strpos(x1, x2,bigint instance) | bigint | 返回 x1 中 x2 的第 N 个实例的位置。instance 必须为正数。位置从 1 开始。如果未找到，则返回 0。 |
| strrpos(x1, x2) | bigint | 返回 x1 中 x2 的最后一个实例的起始位置。位置从 1 开始。如果未找到，则返回 0。 |
| strrpos(x1, x2, bigint instance) | bigint | 返回 x1 中 x2 的第 N 个实例的位置，从 x1 的末尾开始计数。instance 必须为正数。位置从 1 开始。如果未找到，则返回 0。 |
| position(x2 IN x1) | bigint | 返回 x1 中 x2 的第一个实例的起始位置。位置从 1 开始。如果未找到，则返回 0。 |
| substr(x, bigint start) | varchar | 返回从起始位置 start 开始的 x 其余部分。位置从 1 开始。负起始位置解释为相对于 x 的末尾。 |
| substr(x, bigint start, bigint len) | varchar | 从起始位置 start 返回长度为 len 的 x 的子字符串。位置从 1 开始。负起始位置解释为相对于 x 的末尾。 |
| trim(x) | varchar | 从 x 中删除前导和尾随空格。 |
| upper(x) | varchar | 将 x 转换为大写形式 |
# 数组运算符
的 Timestream LiveAnalytics 支持以下数组运算符。
| 运算符 | 说明 |
| --- | --- |
| [] | 访问数组元素时，其起始索引从 1 开始。 |
| \$1\$1 | 将数组与另一个数组或相同类型的元素进行连接。 |
# 数组函数
的 Timestream LiveAnalytics 支持以下数组函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| array\$1distinct(x) | array | 从数组 x 中删除重复值。 SELECT array_distinct(ARRAY[1,2,2,3])
示例结果：`[ 1,2,3 ]` |
| array\$1intersect(x, y) | array | 返回包含 x 和 y 交集元素的数组，且不含重复项。 SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
示例结果：`[ 3 ]` |
| array\$1union(x, y) | array | 返回包含 x 和 y 并集元素的数组，且不含重复项。 SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
示例结果：`[ 1,2,3,4,5 ]` |
| array\$1except(x, y) | array | 返回数组，包含 x 中的元素，但不包含 y 中的元素，且不包含重复项。 SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
示例结果：`[ 1,2 ]` |
| array\$1join(x, delimiter, null\$1replacement) | varchar | 使用分隔符和可选字符串连接给定数组的元素以替换 null 值。 SELECT array_join(ARRAY[1,2,3], ';', '')
示例结果：`1;2;3` |
| array\$1max(x) | 与数组元素相同 | 返回输入数组中的最大值。 SELECT array_max(ARRAY[1,2,3])
示例结果：`3` |
| array\$1min(x) | 与数组元素相同 | 返回输入数组中的最小值。 SELECT array_min(ARRAY[1,2,3])
示例结果：`1` |
| array\$1position(x, element) | bigint | 返回元素在数组 x 中首次出现的位置（如果未找到，则返回 0）。 SELECT array_position(ARRAY[3,4,5,9], 5)
示例结果：`3` |
| array\$1remove(x, element) | array | 从数组 x 中移除所有等于元素的元素。 SELECT array_remove(ARRAY[3,4,5,9], 4)
示例结果：`[ 3,5,9 ]` |
| array\$1sort(x) | array | 对数组 x 进行排序并返回。x 的元素必须可排序。Null 元素将放置在返回数组的末尾。 SELECT array_sort(ARRAY[6,8,2,9,3])
示例结果：`[ 2,3,6,8,9 ]` |
| arrays\$1overlap(x, y) | 布尔值 | 测试数组 x 和 y 是否有共同的非 null 元素。如果没有共同的非 null 元素，但任何一个数组包含 null 值，则返回 null。 SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
示例结果：`true` |
| cardinality(x) | bigint | 返回数组 x 的大小。 SELECT cardinality(ARRAY[6,8,2,9,3])
示例结果：`5` |
| concat(array1, array2, ..., arrayN) | array | 连接数组 array1、array2、...、arrayN。 SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
示例结果：`[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at(array(E), index) | E | 返回数组中指定索引处的元素。如果索引 < 0，则 element\$1at 从最后一个元素开始访问直至第一个元素。 SELECT element_at(ARRAY[6,8,2,9,3], 1)
示例结果：`6` |
| repeat(element, count) | array | 重复元素计数次数。 SELECT repeat(1, 3)
示例结果：`[ 1,1,1 ]` |
| reverse(x) | array | 返回一个数组，其顺序与数组 x 的顺序相反。 SELECT reverse(ARRAY[6,8,2,9,3])
示例结果：`[ 3,9,2,8,6 ]` |
| sequence(start, stop) | array(bigint) | 生成从 start 到 stop 的整数序列，如果 start 小于或等于 stop，则以 1 为增量，否则以 -1 为增量。 SELECT sequence(3, 8)
示例结果：`[ 3,4,5,6,7,8 ]` |
| sequence(start, stop, step) | array(bigint) | 生成从 start 到 stop 的整数序列，以 step 为增量。 SELECT sequence(3, 15, 2)
示例结果：`[ 3,5,7,9,11,13,15 ]` |
| sequence(start, stop) | array(timestamp) | 生成从 start date 到 stop date 的时间戳序列，以 1 天为增量。 SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) 示例结果：`[ 2023-04-02 19:26:12.941000000,2023-04-03 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-05 19:26:12.941000000,2023-04-06 19:26:12.941000000 ]` |
| sequence(start, stop, step) | array(timestamp) | 生成从 start 到 stop 的时间戳序列，以 step 为增量。step 的数据类型是间隔。 SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) 示例结果：`[ 2023-04-02 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-06 19:26:12.941000000,2023-04-08 19:26:12.941000000,2023-04-10 19:26:12.941000000 ]` |
| shuffle(x) | array | 生成给定数组 x 的随机排列。 SELECT shuffle(ARRAY[6,8,2,9,3])
示例结果：`[ 6,3,2,9,8 ]` |
| slice(x, start, length) | array | 子集数组 x 从索引开头开始（如果起始为负数，则从末尾开始），长度为 length。 SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
示例结果：`[ 6,8,2 ]` |
| zip(array1, array2[, ...]) | array(row) | 按元素将给定数组合并为单个行数组。如果参数长度不一致，则用 NULL 填充缺失值。 SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
示例结果：`[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# 按位函数
的 Timestream LiveAnalytics 支持以下按位函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| bit\$1count(bigint, bigint) | bigint（二进制补码） | 返回第一个 bigint 参数中位数的计数，其中第二个参数是有符号的位整数，例如 8 或 64。 SELECT bit_count(19, 8)
示例结果：`3` SELECT bit_count(19, 2)
示例结果：`Number must be representable with the bits specified. 19 can not be represented with 2 bits` |
| bitwise\$1and(bigint, bigint) | bigint（二进制补码） | 返回 bigint 参数的按位与结果。 SELECT bitwise_and(12, 7)
示例结果：`4` |
| bitwise\$1not(bigint) | bigint（二进制补码） | 返回 bigint 参数的按位非结果。 SELECT bitwise_not(12)
示例结果：`-13` |
| bitwise\$1or(bigint, bigint) | bigint（二进制补码） | 返回 bigint 参数的按位或结果。 SELECT bitwise_or(12, 7)
示例结果：`15` |
| bitwise\$1xor(bigint, bigint) | bigint（二进制补码） | 返回 bigint 参数的按位异或结果。 SELECT bitwise_xor(12, 7)
示例结果：`11` |
# 正则表达式函数
Timestream 中的正则表达式函数 LiveAnalytics 支持 [Java 模式语法](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)。Timestream LiveAnalytics 支持以下正则表达式函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| regexp\$1extract\$1all(string, pattern) | array(varchar) | 返回字符串中与正则表达式模式相匹配的子字符串。 SELECT regexp_extract_all('example expect complex', 'ex\w') 示例结果：`[ exa,exp ]` |
| regexp\$1extract\$1all(string, pattern, group) | array(varchar) | 在字符串中查找所有符合正则表达式模式的匹配项，并返回 [capturing group number](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber) 组。 SELECT regexp_extract_all('example expect complex', '(ex)(\w)', 2) 示例结果：`[ a,p ]` |
| regexp\$1extract(string, pattern) | varchar | 返回字符串中与正则表达式模式相匹配的第一个子字符串。 SELECT regexp_extract('example expect', 'ex\w') 示例结果：`exa` |
| regexp\$1extract(string, pattern, group) | varchar | 在字符串中查找第一个符合正则表达式模式的匹配项，并返回 [capturing group number](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber) 组。 SELECT regexp_extract('example expect', '(ex)(\w)', 2) 示例结果：`a` |
| regexp\$1like(string, pattern) | 布尔值 | 评估正则表达式模式，并判断其是否包含在字符串中。此函数类似于 LIKE 运算符，区别在于模式只需包含在字符串中，而不必匹配所有字符串。换言之，这执行的是包含操作而非匹配操作。您可以使用 ^ 和 \$1 锚定模式来匹配整个字符串。 SELECT regexp_like('example', 'ex') 示例结果：`true` |
| regexp\$1replace(string, pattern) | varchar | 从字符串中移除所有匹配正则表达式模式的子字符串实例。 SELECT regexp_replace('example expect', 'expect') 示例结果：`example` |
| regexp\$1replace(string, pattern, replacement) | varchar | 将字符串中所有匹配正则表达式模式的子字符串实例替换为替换内容。捕获的分组可在替换时使用 \$1g 表示编号分组，或使用 \$1\$1name\$1 表示命名分组。如需在替换内容中包含美元符号（\$1），可通过反斜杠（\$1\$1）进行转义。 SELECT regexp_replace('example expect', 'expect', 'surprise') 示例结果：`example surprise` |
| regexp\$1replace(string, pattern, function) | varchar | 使用函数替换字符串中所有匹配正则表达式模式的子字符串实例。每次匹配都会调用 [lambda expression](https://prestodb.io/docs/current/functions/lambda.html) 函数，并将捕获组作为数组传递。捕获组编号从 1 开始；整个匹配项没有组（如果需要，请用括号将整个表达式括起来）。 SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) 示例结果：`EXAMPLE` |
| regexp\$1split(string, pattern) | array(varchar) | 使用正则表达式模式拆分字符串，并返回数组。保留尾随的空字符串。 SELECT regexp_split('example', 'x') 示例结果：`[ e,ample ]` |
# 日期/时间运算符
**注意**
的时间流 LiveAnalytics 不支持负时间值。任何导致负时间的操作均会导致错误。
Timestream LiveAnalytics 支持对`timestamps``dates`、和`intervals`进行以下操作。
| 运算符 | 说明 |
| --- | --- |
| \$1 | 加 |
| - | 减 |
**Topics**
+ [操作](#date-time-operators-operations)
+ [加](#date-time-operators-addition)
+ [减](#date-time-operators-subtraction)
## 操作
运算的结果类型取决于操作数。可以使用间隔表示形式，例如 `1day` 和 `3s`。。
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
各间隔的示例结果：`2022-05-23`
间隔单位包括 `second`、`minute`、`hour`、`day`、`week`、`month` 和 `year`。但某些情况下并非全部适用。例如，无法对日期进行秒、分、小时的增减操作。
```
SELECT interval '4' year + interval '2' month
```
示例结果：`4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
示例结果：`interval year to month`
间隔运算的结果类型可能为 `'interval year to month'` 或 `'interval day to second'`，具体取决于操作数。间隔运算可对 `dates` 和 `timestamps` 进行加减操作。但是，`date` 或 `timestamp` 不能与 `date` 或 `timestamp` 相加或相减。要查找与日期或时间戳相关的间隔或持续时间，请参阅 `date_diff` 及[间隔和持续时间](date-time-functions.md#date-time-functions-interval-duration)中的相关函数。
## 加
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
示例结果：`2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
示例结果：`date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
示例结果：`2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
示例结果：`interval year to month`
## 减
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
示例结果：`2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
示例结果：`timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
示例结果：`5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
示例结果：`interval day to second`
# 日期/时间函数
**注意**
的时间流 LiveAnalytics 不支持负时间值。任何导致负时间的操作均会导致错误。
timestream LiveAnalytics 使用 UTC 时区作为日期和时间。Timestream 支持以下日期和时间函数。
**Topics**
+ [通用和转换](#date-time-functions-general)
+ [间隔和持续时间](#date-time-functions-interval-duration)
+ [格式化与解析](#date-time-functions-formatting-parsing)
+ [提取](#date-time-functions-extraction)
## 通用和转换
Timestream for LiveAnalytics 支持以下日期和时间的常规函数和转换函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| current\$1date | date | 返回以 UTC 为单位的当前日期。未使用括号。 SELECT current_date
示例结果：`2022-07-07` 这也是一个保留关键字。有关保留关键字的列表，请参阅[保留关键字](ts-limits.md#limits.reserved)。 |
| current\$1time | 时间 | 返回以 UTC 为单位的当前时间。未使用括号。 SELECT current_time
示例结果：`17:41:52.827000000` 这也是一个保留关键字。有关保留关键字的列表，请参阅[保留关键字](ts-limits.md#limits.reserved)。 |
| current\$1timestamp or now() | timestamp | 返回以 UTC 为单位的当前时间戳。 SELECT current_timestamp
示例结果：`2022-07-07 17:42:32.939000000` 这也是一个保留关键字。有关保留关键字的列表，请参阅[保留关键字](ts-limits.md#limits.reserved)。 |
| current\$1timezone() | varchar 该值将是“UTC”。 | Timestream 使用 UTC 时区作为日期和时间标准。 SELECT current_timezone()
示例结果：`UTC` |
| date(varchar(x)), date(timestamp) | date | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
示例结果：`2022-07-07` |
| last\$1day\$1of\$1month(timestamp), last\$1day\$1of\$1month(date) | date | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
示例结果：`2022-07-31` |
| from\$1iso8601\$1timestamp(string) | timestamp | 将 ISO 8601 时间戳解析为内部时间戳格式。 SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') 示例结果：`2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date(string) | date | 将 ISO 8601 日期字符串解析为指定日期 UTC 00:00:00 的内部时间戳格式。 SELECT from_iso8601_date('2022-07-17') 示例结果：`2022-07-17` |
| to\$1iso8601(timestamp), to\$1iso8601(date) | varchar | 返回输入的 ISO 8601 格式字符串。 SELECT to_iso8601(from_iso8601_date('2022-06-17')) 示例结果：`2022-06-17` |
| from\$1milliseconds(bigint) | timestamp | SELECT from_milliseconds(1)
示例结果：`1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds(bigint) | timestamp | select from_nanoseconds(300000001)
示例结果：`1970-01-01 00:00:00.300000001` |
| from\$1unixtime(double) | timestamp | 返回与给定 unixtime 相对应的时间戳。 SELECT from_unixtime(1)
示例结果：`1970-01-01 00:00:01.000000000` |
| localtime | 时间 | 返回以 UTC 为单位的当前时间。未使用括号。 SELECT localtime
示例结果：`17:58:22.654000000` 这也是一个保留关键字。有关保留关键字的列表，请参阅[保留关键字](ts-limits.md#limits.reserved)。 |
| localtimestamp | timestamp | 返回以 UTC 为单位的当前时间戳。未使用括号。 SELECT localtimestamp
示例结果：`2022-07-07 17:59:04.368000000` 这也是一个保留关键字。有关保留关键字的列表，请参阅[保留关键字](ts-limits.md#limits.reserved)。 |
| to\$1milliseconds(interval day to second), to\$1milliseconds(timestamp) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
示例结果：`183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
示例结果：`1655487883771` |
| to\$1nanoseconds(interval day to second), to\$1nanoseconds(timestamp) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
示例结果：`183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
示例结果：`1655487883771000678` |
| to\$1unixtime(timestamp) | double | 返回给定时间戳的 unixtime。 SELECT to_unixtime('2022-06-17 17:44:43.771000000') 示例结果：`1.6554878837710001E9` |
| date\$1trunc(unit, timestamp) | timestamp | 返回截断为指定单位的时间戳，单位为 [秒、分钟、小时、日、周、月、季度、年] 其中之一。 SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') 示例结果：`2022-06-17 17:44:00.000000000` |
## 间隔和持续时间
Timestream for LiveAnalytics 支持以下日期和时间间隔和持续时间函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| date\$1add(unit, bigint, date), date\$1add(unit, bigint, time), date\$1add(varchar(x), bigint, timestamp) | timestamp | 添加 bigint，单位为 [秒、分钟、小时、日、周、月、季度、年] 其中之一。 SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') 示例结果：`2022-06-17 09:00:00.000000000` |
| date\$1diff(unit, date, date) , date\$1diff(unit, time, time) , date\$1diff(unit, timestamp, timestamp) | bigint | 返回差值，其中单位为 [秒、分钟、小时、日、周、月、季度、年] 之一。 SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') 示例结果：`1` |
| parse\$1duration(string) | interval | 解析输入字符串，以返回等效的 `interval`。 SELECT parse_duration('42.8ms') 示例结果：`0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) 示例结果：`interval day to second` |
| bin(timestamp, interval) | timestamp | 将参数 `timestamp` 的整数部分向下取整，取其最接近的参数 `interval` 的整数倍数。 此返回值的含义可能并不明显。该值通过整数运算计算得出：首先将时间戳整数除以间隔整数，然后将结果乘以间隔整数。 请注意，时间戳将 UTC 时间点指定为自 POSIX epoch（1970 年 1 月 1 日）起经过的若干个零点几秒，因此其返回值很少与日历时间单位完全对应。例如，如果指定 30 天间隔，则自 epoch 以来所有天数都将划分为 30 天增量，并返回最近 30 天增量的起始点，该起始点与日历月份无关。 下面是一些示例： bin(TIMESTAMP '2022-06-17 10:15:20', 5m) ==> 2022-06-17 10:15:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 1d) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 10day) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 30day) ==> 2022-05-28 00:00:00.000000000
|
| ago(interval) | timestamp | 返回与 current\$1timestamp `interval` 对应的值。 SELECT ago(1d)
示例结果：`2022-07-06 21:08:53.245000000` |
| 间隔字面值，例如 1h、1d 和 30m | interval | 间隔字面值是 parse\$1duration(string) 的简易形式。例如，`1d` 与 `parse_duration('1d')` 相同。这允许在任何使用间隔的地方使用字面值。例如，`ago(1d)` 和 `bin(, 1m)`。 |
一些间隔字面值可作为 parse\$1duration 的简写形式。例如，`parse_duration('1day')`、`1day`、`parse_duration('1d')` 和 `1d` 均返回 `1 00:00:00.000000000`，其中类型为 `interval day to second`。允许给定格式 `parse_duration` 中存在空格。例如，`parse_duration('1day')` 也返回 `00:00:00.000000000`。但 `1 day` 不是间隔字面值。
与 `interval day to second` 相关的单位包括：ns（纳秒）、us（微秒）、ms（毫秒）、s（秒）、m（分钟）、h（小时）、d（天）。
还有 `interval year to month`。与间隔年到月相关的单位包括：y（年）、月。例如，`SELECT 1year` 返回 `1-0`。`SELECT 12month` 也返回 `1-0`。`SELECT 8month` 返回 `0-8`。
尽管 `quarter` 的单位也可用于某些函数，例如 `date_trunc` 和 `date_add`，但 `quarter` 不能作为间隔字面值使用。
## 格式化与解析
Timestream for LiveAnalytics 支持以下日期和时间的格式化和解析函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| date\$1format(timestamp, varchar(x)) | varchar | [有关此函数使用的格式说明符的更多信息，请参见 \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_format(TIMESTAMP '2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s')
示例结果：`2019-10-20 10:20:20` |
| date\$1parse(varchar(x), varchar(y)) | timestamp | [有关此函数使用的格式说明符的更多信息，请参见 \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_parse('2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s') 示例结果：`2019-10-20 10:20:20.000000000` |
| format\$1datetime(timestamp, varchar(x)) | varchar | 有关此函数使用的格式字符串的更多信息，请参阅 [http://joda-time.sourceforge。 net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT format_datetime(parse_datetime('1968-01-13 12', 'yyyy-MM-dd HH'), 'yyyy-MM-dd HH') 示例结果：`1968-01-13 12` |
| parse\$1datetime(varchar(x), varchar(y)) | timestamp | 有关此函数使用的格式字符串的更多信息，请参阅 [http://joda-time.sourceforge。 net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT parse_datetime('2019-12-29 10:10 PST', 'uuuu-LL-dd HH:mm z') 示例结果：`2019-12-29 18:10:00.000000000` |
## 提取
Timestream for LiveAnalytics 支持以下日期和时间提取函数。提取函数是其余便捷函数的基础。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| extract | bigint | 从时间戳中提取字段，字段为 [YEAR、QUARTER、MONTH、WEEK、DAY、DAY\$1OF\$1MONTH、DAY\$1OF\$1WEEK、DOW、DAY\$1OF\$1YEAR、DOY、YEAR\$1OF\$1WEEK、YOW、HOUR、MINUTE、SECOND] 其中之一。 SELECT extract(YEAR FROM '2019-10-12 23:10:34.000000000')
示例结果：`2019` |
| day(timestamp), day(date), day(interval day to second) | bigint | SELECT day('2019-10-12 23:10:34.000000000') 示例结果：`12` |
| day\$1of\$1month(timestamp), day\$1of\$1month(date), day\$1of\$1month(interval day to second) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') 示例结果：`12` |
| day\$1of\$1week(timestamp), day\$1of\$1week(date) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') 示例结果：`6` |
| day\$1of\$1year(timestamp), day\$1of\$1year(date) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') 示例结果：`285` |
| dow(timestamp), dow(date) | bigint | day\$1of\$1week 的别名 |
| doy(timestamp), doy(date) | bigint | day\$1of\$1year 的别名 |
| hour(timestamp), hour(time), hour(interval day to second) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') 示例结果：`23` |
| millisecond(timestamp), millisecond(time), millisecond(interval day to second) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') 示例结果：`0` |
| minute(timestamp), minute(time), minute(interval day to second) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') 示例结果：`10` |
| month(timestamp), month(date), month(interval year to month) | bigint | SELECT month('2019-10-12 23:10:34.000000000') 示例结果：`10` |
| nanosecond(timestamp), nanosecond(time), nanosecond(interval day to second) | bigint | SELECT nanosecond(current_timestamp)
示例结果：`162000000` |
| quarter(timestamp), quarter(date) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') 示例结果：`4` |
| second(timestamp), second(time), second(interval day to second) | bigint | SELECT second('2019-10-12 23:10:34.000000000') 示例结果：`34` |
| week(timestamp), week(date) | bigint | SELECT week('2019-10-12 23:10:34.000000000') 示例结果：`41` |
| week\$1of\$1year(timestamp), week\$1of\$1year(date) | bigint | week 的别名 |
| year(timestamp), year(date), year(interval year to month) | bigint | SELECT year('2019-10-12 23:10:34.000000000') 示例结果：`2019` |
| year\$1of\$1week(timestamp), year\$1of\$1week(date) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') 示例结果：`2019` |
| yow(timestamp), yow(date) | bigint | year\$1of\$1week 的别名 |
# 聚合函数
Timestream LiveAnalytics 支持以下聚合函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| arbitrary(x) | [与输入相同] | 返回 x 的任意非 null 值（如果存在）。 SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`1` |
| array\$1agg(x) | 数组<[与输入相同] | 返回由输入 x 个元素创建的数组。 SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`[ 1,2,3,4 ]` |
| avg(x) | double | 返回所有输入值的平均值（算术平均值）。 SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`2.5` |
| bool\$1and(boolean) every(boolean) | 布尔值 | 如果每个输入值都为 TRUE，则返回 TRUE，否则返回 FALSE。 SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
示例结果：`false` |
| bool\$1or(boolean) | 布尔值 | 如果任何输入值为 TRUE，则返回 TRUE，否则返回 FALSE。 SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
示例结果：`true` |
| count(\$1) count(x) | bigint | count(\$1) 返回输入行的数量。 count(x) 返回非 null 输入值的数量。 SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
示例结果：`4` |
| count\$1if(x) | bigint | 返回 TRUE 输入值的数量。 SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
示例结果：`3` |
| geometric\$1mean(x) | double | 返回所有输入值的几何平均值。 SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`2.213363839400643` |
| max\$1by(x, y) | [与 x 相同] | 返回所有输入值中与 y 的最大值相关联的 x 值。 SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) 示例结果：`d` |
| max\$1by(x, y, n) | 数组<[与 x 相同]> | 返回与所有输入 y 值中降序排列的 n 个最大值相关联的 n 个 x 值。 SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) 示例结果：`[ d,c ]` |
| min\$1by(x, y) | [与 x 相同] | 返回所有输入值中与 y 的最小值相关联的 x 值。 SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) 示例结果：`a` |
| min\$1by(x, y, n) | 数组<[与 x 相同]> | 返回与所有输入 y 值中升序排列的 n 个最小值相关联的 n 个 x 值。 SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) 示例结果：`[ a,b ]` |
| max(x) | [与输入相同] | 返回所有输入值的最大值。 SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`4` |
| max(x, n) | 数组<[与 x 相同]> | 返回 x 的所有输入值中的 n 个最大值。 SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`[ 4,3 ]` |
| min(x) | [与输入相同] | 返回所有输入值的最小值。 SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`1` |
| min(x, n) | 数组<[与 x 相同]> | 返回 x 的所有输入值中的 n 个最小值。 SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`[ 1,2 ]` |
| sum(x) | [与输入相同] | 返回所有输入值的总和。 SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`10` |
| bitwise\$1and\$1agg(x) | bigint | 返回所有输入值以 2 补码表示形式的按位与结果。 SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
示例结果：`1` |
| bitwise\$1or\$1agg(x) | bigint | 返回所有输入值以 2 补码表示形式的按位或结果。 SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
示例结果：`-3` |
| approx\$1distinct(x) | bigint | 返回输入值中不同值的大致数量 此函数提供对 count(DISTINCT x) 的近似值。如果所有输入值均为 null，则返回零。此函数应生成 2.3% 的标准误差，即所有可能集合（近似正态）误差分布的标准差。该函数不能保证对任何特定输入集的误差存在上限。 SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
示例结果：`5` |
| approx\$1distinct(x, e) | bigint | 返回输入值中不同值的大致数量 此函数提供对 count(DISTINCT x) 的近似值。如果所有输入值均为 null，则返回零。此函数应生成不大于 e 的标准误差，即所有可能集合（近似正态）误差分布的标准差。该函数不能保证对任何特定输入集的误差存在上限。此函数的当前实施要求 e 在 [0.0040625，0.26000] 范围内。 SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
示例结果：`5` |
| approx\$1percentile(x, percentage) | [与 x 相同] | 返回所有输入值 x 在给定百分比下的近似百分位数。百分比值必须介于零到一之间，且对所有输入行保持恒定。 SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`2` |
| approx\$1percentile(x, percentages) | 数组<[与 x 相同]> | 返回所有输入值 x 在每个指定百分比下的近似百分位数。百分比数组的每个元素都必须介于零到一之间，且该数组对所有输入行必须保持恒定。 SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`[ 1,4,4 ]` |
| approx\$1percentile(x, w, percentage) | [与 x 相同] | 返回所有输入值 x 在百分比 p 处使用单项权重 w 计算的近似加权百分位数。权重必须是至少为 1 的整数值。该值实际上是百分位数集中值 x 的复制计数。p 值必须介于零到一之间，且对所有输入行保持恒定。 SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`1` |
| approx\$1percentile(x, w, percentages) | 数组<[与 x 相同]> | 返回所有输入值 x 在数组中指定百分比处使用每项权重 w 计算的近似加权百分位数。权重必须是至少为 1 的整数值。该值实际上是百分位数集中值 x 的复制计数。数组的每个元素都必须介于零到一之间，且该数组对所有输入行必须保持恒定。 SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`[ 1,4,4 ]` |
| approx\$1percentile(x, w, percentage, accuracy) | [与 x 相同] | 返回所有输入值 x 在百分比 p 处使用单项权重 w 计算的近似加权百分位数，最大等级误差为精度。权重必须是至少为 1 的整数值。该值实际上是百分位数集中值 x 的复制计数。p 值必须介于零到一之间，且对所有输入行保持恒定。精度必须是大于零且小于一的值，且对所有输入行保持恒定。 SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
示例结果：`1` |
| corr(y, x) | double | 返回输入值的相关系数。 SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
示例结果：`1.0` |
| covar\$1pop(y, x) | double | 返回输入值的总体协方差。 SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
示例结果：`1.25` |
| covar\$1samp(y, x) | double | 返回输入值的样本协方差。 SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
示例结果：`1.6666666666666667` |
| regr\$1intercept(y, x) | double | 返回输入值的线性回归截距。y 为因变量，x 为自变量。 SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
示例结果：`0.0` |
| regr\$1slope(y, x) | double | 返回输入值的线性回归斜率。y 为因变量，x 为自变量。 SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
示例结果：`1.0` |
| skewness(x) | double | 返回所有输入值的偏度。 SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
示例结果：`0.8978957037987335` |
| stddev\$1pop(x) | double | 返回所有输入值的总体标准差 SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
示例结果：`2.4166091947189146` |
| stddev\$1samp(x) stddev(x) | double | 返回所有输入值的样本标准差。 SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
示例结果：`2.701851217221259` |
| var\$1pop(x) | double | 返回所有输入值的总体方差。 SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
示例结果：`5.840000000000001` |
| var\$1samp(x) variance(x) | double | 返回所有输入值的样本方差。 SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
示例结果：`7.300000000000001` |
# 窗口函数
窗口函数对查询结果的各行进行计算。该函数在 HAVING 子句之后但在 ORDER BY 子句之前运行。调用窗口函数需要使用特殊语法，通过 OVER 子句指定窗口。窗口包含三个组件：
+ 分区规范，用于将输入行划分为不同的分区。这类似于 GROUP BY 子句将行划分为不同组以便进行聚合函数计算的方式。
+ 排序规范，用于确定窗口函数处理输入行时的顺序。
+ 窗口框架，用于指定函数处理给定行时所涉及的行数范围。如果未指定框架，则默认为 RANGE UNBOUNDED PRECEDING，这与 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 相同。此框架包含从分区开头到当前行最后一个对等节点的所有行。
所有聚合函数均可通过添加 OVER 子句作为窗口函数使用。聚合函数针对当前行窗口框架内的每行数据进行计算。除了聚合函数外，Timestream 还 LiveAnalytics 支持以下排名和值函数。
| 函数 | 输出数据类型 | 说明 |
| --- | --- | --- |
| cume\$1dist() | bigint | 返回某个值在值组中的累积分布。结果是窗口分区窗口排序中该行之前或与该行同级的行数除以窗口分区中的总行数。因此，排序中的任何平局值均计算为相同的分布值。 |
| dense\$1rank() | bigint | 返回某个值在值组中的排序。这与 rank() 类似，不同之处在于平局值不会导致序列出现间隔。 |
| ntile(n) | bigint | 将每个窗口分区的行划分为 n 个存储桶，桶号范围从 1 到最大 n。存储桶值最多相差 1。如果分区的行数不能被存储桶的数量整除，则将剩余行值从第一个存储桶开始，按每个存储桶分配一行。 |
| percent\$1rank() | double | 返回某个值在值组中的百分比排序。结果为 (r - 1) / (n - 1)，其中 r 是该行的秩，n 是窗口分区中的总行数。 |
| rank() | bigint | 返回某个值在值组中的排序。排序等于 1 加上该行之前所有非同级行的行数。因此，排序中的平局值将导致序列出现间隔。对每个窗口分区进行排序。 |
| row\$1number() | bigint | 根据窗口分区内行的排序，为每行返回一个唯一的序号，从 1 开始。 |
| first\$1value(x) | [与输入相同] | 返回窗口的第一个值。此函数的作用域限定在窗口框架内。该函数以表达式或目标作为其参数。 |
| last\$1value(x) | [与输入相同] | 返回窗口的最后一个值。此函数的作用域限定在窗口框架内。该函数以表达式或目标作为其参数。 |
| nth\$1value(x, offset) | [与输入相同] | 返回窗口起始位置指定偏移量处的值。偏移量从 1 开始。偏移量可以是任意标量表达式。如果偏移量为 null 或大于窗口中的值数，则返回 null。偏移量为零或负值时将导致错误。该函数以表达式或目标作为其第一个参数。 |
| lead(x[, offset[, default\$1value]]) | [与输入相同] | 返回窗口中当前行之后偏移行数处的值。偏移量从 0 开始，即当前行。偏移量可以是任意标量表达式。默认偏移量为 1。如果偏移量为 null 或大于窗口范围，则返回 default\$1value；如果未指定，则返回 null。该函数以表达式或目标作为其第一个参数。 |
| lag(x[, offset[, default\$1value]]) | [与输入相同] | 返回窗口中当前行之前偏移行数处的值。偏移量从 0 开始，即当前行。偏移量可以是任意标量表达式。默认偏移量为 1。如果偏移量为 null 或大于窗口范围，则返回 default\$1value；如果未指定，则返回 null。该函数以表达式或目标作为其第一个参数。 |
# 查询示例
本节包括 Timestream 的查询语言 LiveAnalytics的示例用例。
**Topics**
+ [简单查询](sample-queries.basic-scenarios.md)
+ [包含时间序列函数的查询](sample-queries.devops-scenarios.md)
+ [使用聚合函数查询](sample-queries.iot-scenarios.md)
# 简单查询
以下是最近为表添加的 10 个数据点。
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
以下是特定度量的 5 个最早数据点。
```
SELECT * FROM .
WHERE measure_name = ''
ORDER BY time ASC
LIMIT 5
```
以下内容采用纳秒级粒度的时间戳。
```
SELECT now() AS time_now
, now() - (INTERVAL '12' HOUR) AS twelve_hour_earlier -- Compatibility with ANSI SQL
, now() - 12h AS also_twelve_hour_earlier -- Convenient time interval literals
, ago(12h) AS twelve_hours_ago -- More convenience with time functionality
, bin(now(), 10m) AS time_binned -- Convenient time binning support
, ago(50ns) AS fifty_ns_ago -- Nanosecond support
, now() + (1h + 50ns) AS hour_fifty_ns_future
```
多度量记录的度量值由列名进行标识。单度量记录的度量值由 `measure_value::` 进行表示，其中 `` 为 `double`、`bigint`、`boolean` 或 `varchar` 其中之一（如 [支持的数据类型](supported-data-types.md) 中所述）。有关度量值建模方式的更多信息，请参阅[单表与多表](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords)。
以下内容从多度量记录中检索名为 `speed` 的度量的值，其中 `measure_name` 为 `IoTMulti-stats`。
```
SELECT speed FROM . where measure_name = 'IoTMulti-stats'
```
以下内容从单度量记录中检索 `double` 值，其中`measure_name` 为 `load`。
```
SELECT measure_value::double FROM . WHERE measure_name = 'load'
```
# 包含时间序列函数的查询
**Topics**
+ [示例数据集和查询](#sample-queries.devops-scenarios.example)
## 示例数据集和查询
您可以使用 Timestream LiveAnalytics 来了解和提高您的服务和应用程序的性能和可用性。以下是示例表及其上运行的示例查询。
表 `ec2_metrics` 存储遥测数据，例如 EC2 实例的 CPU 利用率及其他指标。您可以查看下表。
| 时间 | region | az | 主机名 | measure\$1name | measure\$1value::double | measure\$1value::bigint |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1a | frontend01 | cpu\$1utilization | 35.1 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1a | frontend01 | memory\$1utilization | 55.3 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1in | null | 1500 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1out | null | 6,700 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1b | frontend02 | cpu\$1utilization | 38.5 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1b | frontend02 | memory\$1utilization | 58.4 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1in | null | 23,000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1out | null | 12000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1c | frontend03 | cpu\$1utilization | 45.0 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1c | frontend03 | memory\$1utilization | 65.8 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1in | null | 15000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1out | null | 836,000 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us–east–1a | frontend01 | cpu\$1utilization | 55.2 | null |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us–east–1a | frontend01 | memory\$1utilization | 75.0 | null |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1in | null | 1,245 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1out | null | 68,432 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us–east–1b | frontend02 | cpu\$1utilization | 65.6 | null |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us–east–1b | frontend02 | memory\$1utilization | 85.3 | null |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1in | null | 1,245 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1out | null | 68,432 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us–east–1c | frontend03 | cpu\$1utilization | 12.1 | null |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us–east–1c | frontend03 | memory\$1utilization | 32.0 | null |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1in | null | 1,400 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1out | null | 345 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us–east–1a | frontend01 | cpu\$1utilization | 15.3 | null |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us–east–1a | frontend01 | memory\$1utilization | 35.4 | null |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1in | null | 23 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us–east–1a | frontend01 | network\$1bytes\$1out | null | 0 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us–east–1b | frontend02 | cpu\$1utilization | 44.0 | null |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us–east–1b | frontend02 | memory\$1utilization | 64.2 | null |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1in | null | 1,450 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us–east–1b | frontend02 | network\$1bytes\$1out | null | 200 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us–east–1c | frontend03 | cpu\$1utilization | 66.4 | null |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us–east–1c | frontend03 | memory\$1utilization | 86.3 | null |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1in | null | 300 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us–east–1c | frontend03 | network\$1bytes\$1out | null | 423 |
计算过去 2 小时内特定 EC2 主机的平均 CPU 利用率、p90、p95 和 p99：
```
SELECT region, az, hostname, BIN(time, 15s) AS binned_timestamp,
ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.9), 2) AS p90_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.95), 2) AS p95_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.99), 2) AS p99_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY region, hostname, az, BIN(time, 15s)
ORDER BY binned_timestamp ASC
```
确定 CPU 利用率比过去 2 小时整个实例集平均 CPU 利用率高出 10% 或以上的 EC2 主机：
```
WITH avg_fleet_utilization AS (
SELECT COUNT(DISTINCT hostname) AS total_host_count, AVG(measure_value::double) AS fleet_avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
), avg_per_host_cpu AS (
SELECT region, az, hostname, AVG(measure_value::double) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
GROUP BY region, az, hostname
)
SELECT region, az, hostname, avg_cpu_utilization, fleet_avg_cpu_utilization
FROM avg_fleet_utilization, avg_per_host_cpu
WHERE avg_cpu_utilization > 1.1 * fleet_avg_cpu_utilization
ORDER BY avg_cpu_utilization DESC
```
计算过去 2 小时内特定 EC2 主机的 CPU 平均利用率，按 30 秒间隔进行分箱：
```
SELECT BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
ORDER BY binned_timestamp ASC
```
计算过去 2 小时内特定 EC2 主机的 CPU 平均利用率，按 30 秒间隔进行分箱，并使用线性插值填补缺失值：
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
计算过去 2 小时内特定 EC2 主机的 CPU 平均利用率，按 30 秒间隔进行分箱，并使用基于末次观测值结转的插值填补缺失值：
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LOCF(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
# 使用聚合函数查询
以下是 IoT 场景示例数据集的示例，用于说明使用聚合函数的查询。
**Topics**
+ [示例数据](#sample-queries.iot-scenarios.example-data)
+ [示例查询](#sample-queries.iot-scenarios.example-queries)
## 示例数据
Timestream 使您能够存储和分析 IoT 传感器数据，例如一个或多个卡车车队的位置、油耗、速度和载重，从而实现有效的车队管理。以下是 iot\$1trucks 表的架构和部分数据，该表存储卡车的位置、油耗、速度和载重等遥测数据。
| 时间 | truck\$1id | Make | 模型 | Fleet | fuel\$1capacity | load\$1capacity | measure\$1name | measure\$1value::double | measure\$1value::varchar |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | fuel\$1reading | 65.2 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | 负载 | 400.0 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | speed | 90.2 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | 地点 | null | 47.6062 N, 122.3321 W |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | fuel\$1reading | 10.1 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | 负载 | 950.3 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | speed | 50.8 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | 地点 | null | 北纬 40.7128 度，西经 74.0060 度 |
## 示例查询
获取车队中每辆卡车正在监控的所有传感器属性及值的列表。
```
SELECT
truck_id,
fleet,
fuel_capacity,
model,
load_capacity,
make,
measure_name
FROM "sampleDB".IoT
GROUP BY truck_id, fleet, fuel_capacity, model, load_capacity, make, measure_name
```
获取车队中每辆卡车过去 24 小时内的最新燃油读数。
```
WITH latest_recorded_time AS (
SELECT
truck_id,
max(time) as latest_time
FROM "sampleDB".IoT
WHERE measure_name = 'fuel-reading'
AND time >= ago(24h)
GROUP BY truck_id
)
SELECT
b.truck_id,
b.fleet,
b.make,
b.model,
b.time,
b.measure_value::double as last_reported_fuel_reading
FROM
latest_recorded_time a INNER JOIN "sampleDB".IoT b
ON a.truck_id = b.truck_id AND b.time = a.latest_time
WHERE b.measure_name = 'fuel-reading'
AND b.time > ago(24h)
ORDER BY b.truck_id
```
确定过去 48 小时内燃油量低于 10% 的卡车：
```
WITH low_fuel_trucks AS (
SELECT time, truck_id, fleet, make, model, (measure_value::double/cast(fuel_capacity as double)*100) AS fuel_pct
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND (measure_value::double/cast(fuel_capacity as double)*100) < 10
AND measure_name = 'fuel-reading'
),
other_trucks AS (
SELECT time, truck_id, (measure_value::double/cast(fuel_capacity as double)*100) as remaining_fuel
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND truck_id IN (SELECT truck_id FROM low_fuel_trucks)
AND (measure_value::double/cast(fuel_capacity as double)*100) >= 10
AND measure_name = 'fuel-reading'
),
trucks_that_refuelled AS (
SELECT a.truck_id
FROM low_fuel_trucks a JOIN other_trucks b
ON a.truck_id = b.truck_id AND b.time >= a.time
)
SELECT DISTINCT truck_id, fleet, make, model, fuel_pct
FROM low_fuel_trucks
WHERE truck_id NOT IN (
SELECT truck_id FROM trucks_that_refuelled
)
```
计算过去一周每辆卡车的平均载重和最高速度：
```
SELECT
bin(time, 1d) as binned_time,
fleet,
truck_id,
make,
model,
AVG(
CASE WHEN measure_name = 'load' THEN measure_value::double ELSE NULL END
) AS avg_load_tons,
MAX(
CASE WHEN measure_name = 'speed' THEN measure_value::double ELSE NULL END
) AS max_speed_mph
FROM "sampleDB".IoT
WHERE time >= ago(7d)
AND measure_name IN ('load', 'speed')
GROUP BY fleet, truck_id, make, model, bin(time, 1d)
ORDER BY truck_id
```
获取过去一周每辆卡车的装载效率：
```
WITH average_load_per_truck AS (
SELECT
truck_id,
avg(measure_value::double) AS avg_load
FROM "sampleDB".IoT
WHERE measure_name = 'load'
AND time >= ago(7d)
GROUP BY truck_id, fleet, load_capacity, make, model
),
truck_load_efficiency AS (
SELECT
a.truck_id,
fleet,
load_capacity,
make,
model,
avg_load,
measure_value::double,
time,
(measure_value::double*100)/avg_load as load_efficiency -- , approx_percentile(avg_load_pct, DOUBLE '0.9')
FROM "sampleDB".IoT a JOIN average_load_per_truck b
ON a.truck_id = b.truck_id
WHERE a.measure_name = 'load'
)
SELECT
truck_id,
time,
load_efficiency
FROM truck_load_efficiency
ORDER BY truck_id, time
```