选择表达式

语法定义

选择表达式（selectExpr）是 SELECT 子句的组成单元，每个 selectExpr 对应查询结果集中的一列，其语法定义如下：

  1. selectClause
  2.     : SELECT resultColumn (',' resultColumn)*
  3.     ;
  5. resultColumn
  6.     : selectExpr (AS alias)?
  7.     ;
  9. selectExpr
  10.     : '(' selectExpr ')'
  11.     | '-' selectExpr
  12.     | selectExpr ('*' | '/' | '%') selectExpr
  13.     | selectExpr ('+' | '-') selectExpr
  14.     | functionName '(' selectExpr (',' selectExpr)* functionAttribute* ')'
  15.     | timeSeriesSuffixPath
  16.     | number
  17.     ;

由该语法定义可知，selectExpr 可以包含：

  • 时间序列路径后缀
  • 函数
    • 内置聚合函数，详见 聚合查询 。
    • 时间序列生成函数
    • 用户自定义函数，详见 UDF 。
  • 表达式
    • 算数运算表达式
    • 时间序列查询嵌套表达式
    • 聚合查询嵌套表达式
  • 数字常量（仅用于表达式）

算数运算查询

请注意，目前对齐时间序列(Aligned Timeseries)尚不支持算数运算查询。算数运算所选时间序列包含对齐时间序列时，会提示错误。

运算符

一元算数运算符

支持的运算符：+, -

输入数据类型要求：INT32, INT64, FLOAT和 DOUBLE

输出数据类型：与输入数据类型一致

二元算数运算符

支持的运算符：+, -, *, /, %

输入数据类型要求：INT32, INT64, FLOAT和 DOUBLE

输出数据类型：DOUBLE

注意：当某个时间戳下左操作数和右操作数都不为空（null）时，二元运算操作才会有输出结果

使用示例

例如：

  1. select s1, - s1, s2, + s2, s1 + s2, s1 - s2, s1 * s2, s1 / s2, s1 % s2 from root.sg.d1

结果：

  1. +-----------------------------+-------------+--------------+-------------+-------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+
  2. |                         Time|root.sg.d1.s1|-root.sg.d1.s1|root.sg.d1.s2|root.sg.d1.s2|root.sg.d1.s1 + root.sg.d1.s2|root.sg.d1.s1 - root.sg.d1.s2|root.sg.d1.s1 * root.sg.d1.s2|root.sg.d1.s1 / root.sg.d1.s2|root.sg.d1.s1 % root.sg.d1.s2|
  3. +-----------------------------+-------------+--------------+-------------+-------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+
  4. |1970-01-01T08:00:00.001+08:00|          1.0|          -1.0|          1.0|          1.0|                          2.0|                          0.0|                          1.0|                          1.0|                          0.0|
  5. |1970-01-01T08:00:00.002+08:00|          2.0|          -2.0|          2.0|          2.0|                          4.0|                          0.0|                          4.0|                          1.0|                          0.0|
  6. |1970-01-01T08:00:00.003+08:00|          3.0|          -3.0|          3.0|          3.0|                          6.0|                          0.0|                          9.0|                          1.0|                          0.0|
  7. |1970-01-01T08:00:00.004+08:00|          4.0|          -4.0|          4.0|          4.0|                          8.0|                          0.0|                         16.0|                          1.0|                          0.0|
  8. |1970-01-01T08:00:00.005+08:00|          5.0|          -5.0|          5.0|          5.0|                         10.0|                          0.0|                         25.0|                          1.0|                          0.0|
  9. +-----------------------------+-------------+--------------+-------------+-------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+-----------------------------+
  10. Total line number = 5
  11. It costs 0.014s

内置时间序列生成函数

时间序列生成函数可接受若干原始时间序列作为输入，产生一列时间序列输出。与聚合函数不同的是，时间序列生成函数的结果集带有时间戳列。

所有的时间序列生成函数都可以接受 * 作为输入，都可以与原始查询混合进行。

请注意，目前对齐时间序列(Aligned Timeseries)尚不支持内置函数查询。使用内置函数时，如果自变量包含对齐时间序列，会提示错误。

数学函数

目前 IoTDB 支持下列数学函数，这些数学函数的行为与这些函数在 Java Math 标准库中对应实现的行为一致。

函数名输入序列类型输出序列类型Java 标准库中的对应实现
SININT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#sin(double)
COSINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#cos(double)
TANINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#tan(double)
ASININT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#asin(double)
ACOSINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#acos(double)
ATANINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#atan(double)
SINHINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#sinh(double)
COSHINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#cosh(double)
TANHINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#tanh(double)
DEGREESINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#toDegrees(double)
RADIANSINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#toRadians(double)
ABSINT32 / INT64 / FLOAT / DOUBLE与输入序列的实际类型一致Math#abs(int) / Math#abs(long) /Math#abs(float) /Math#abs(double)
SIGNINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#signum(double)
CEILINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#ceil(double)
FLOORINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#floor(double)
ROUNDINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#rint(double)
EXPINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#exp(double)
LNINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#log(double)
LOG10INT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#log10(double)
SQRTINT32 / INT64 / FLOAT / DOUBLEDOUBLEMath#sqrt(double)

例如：

  1. select s1, sin(s1), cos(s1), tan(s1) from root.sg1.d1 limit 5 offset 1000;

结果：

  1. +-----------------------------+-------------------+-------------------+--------------------+-------------------+
  2. |                         Time|     root.sg1.d1.s1|sin(root.sg1.d1.s1)| cos(root.sg1.d1.s1)|tan(root.sg1.d1.s1)|
  3. +-----------------------------+-------------------+-------------------+--------------------+-------------------+
  4. |2020-12-10T17:11:49.037+08:00|7360723084922759782| 0.8133527237573284|  0.5817708713544664| 1.3980636773094157|
  5. |2020-12-10T17:11:49.038+08:00|4377791063319964531|-0.8938962705202537|  0.4482738644511651| -1.994085181866842|
  6. |2020-12-10T17:11:49.039+08:00|7972485567734642915| 0.9627757585308978|-0.27030138509681073|-3.5618602479083545|
  7. |2020-12-10T17:11:49.040+08:00|2508858212791964081|-0.6073417341629443| -0.7944406950452296| 0.7644897069734913|
  8. |2020-12-10T17:11:49.041+08:00|2817297431185141819|-0.8419358900502509| -0.5395775727782725| 1.5603611649667768|
  9. +-----------------------------+-------------------+-------------------+--------------------+-------------------+
  10. Total line number = 5
  11. It costs 0.008s

字符串函数

目前 IoTDB 支持下列字符串处理函数：

函数名输入序列类型必要的属性参数输出序列类型功能描述
STRING_CONTAINSTEXTs: 待搜寻的字符串BOOLEAN判断字符串中是否存在s
STRING_MATCHESTEXTregex: Java 标准库风格的正则表达式BOOLEAN判断字符串是否能够被正则表达式regex匹配

例如：

  1. select s1, string_contains(s1, 's'='warn'), string_matches(s1, 'regex'='[^\\s]+37229') from root.sg1.d4;

结果：

  1. +-----------------------------+--------------+-------------------------------------------+------------------------------------------------------+
  2. |                         Time|root.sg1.d4.s1|string_contains(root.sg1.d4.s1, "s"="warn")|string_matches(root.sg1.d4.s1, "regex"="[^\\s]+37229")|
  3. +-----------------------------+--------------+-------------------------------------------+------------------------------------------------------+
  4. |1970-01-01T08:00:00.001+08:00|    warn:-8721|                                       true|                                                 false|
  5. |1970-01-01T08:00:00.002+08:00|  error:-37229|                                      false|                                                  true|
  6. |1970-01-01T08:00:00.003+08:00|     warn:1731|                                       true|                                                 false|
  7. +-----------------------------+--------------+-------------------------------------------+------------------------------------------------------+
  8. Total line number = 3
  9. It costs 0.007s

选择函数

目前 IoTDB 支持如下选择函数：

函数名输入序列类型必要的属性参数输出序列类型功能描述
TOP_KINT32 / INT64 / FLOAT / DOUBLE / TEXTk: 最多选择的数据点数，必须大于 0 小于等于 1000与输入序列的实际类型一致返回某时间序列中值最大的k个数据点。若多于k个数据点的值并列最大，则返回时间戳最小的数据点。
BOTTOM_KINT32 / INT64 / FLOAT / DOUBLE / TEXTk: 最多选择的数据点数，必须大于 0 小于等于 1000与输入序列的实际类型一致返回某时间序列中值最小的k个数据点。若多于k个数据点的值并列最小，则返回时间戳最小的数据点。

例如：

  1. select s1, top_k(s1, 'k'='2'), bottom_k(s1, 'k'='2') from root.sg1.d2 where time > 2020-12-10T20:36:15.530+08:00;

结果：

  1. +-----------------------------+--------------------+------------------------------+---------------------------------+
  2. |                         Time|      root.sg1.d2.s1|top_k(root.sg1.d2.s1, "k"="2")|bottom_k(root.sg1.d2.s1, "k"="2")|
  3. +-----------------------------+--------------------+------------------------------+---------------------------------+
  4. |2020-12-10T20:36:15.531+08:00| 1531604122307244742|           1531604122307244742|                             null|
  5. |2020-12-10T20:36:15.532+08:00|-7426070874923281101|                          null|                             null|
  6. |2020-12-10T20:36:15.533+08:00|-7162825364312197604|          -7162825364312197604|                             null|
  7. |2020-12-10T20:36:15.534+08:00|-8581625725655917595|                          null|             -8581625725655917595|
  8. |2020-12-10T20:36:15.535+08:00|-7667364751255535391|                          null|             -7667364751255535391|
  9. +-----------------------------+--------------------+------------------------------+---------------------------------+
  10. Total line number = 5
  11. It costs 0.006s

趋势计算函数

目前 IoTDB 支持如下趋势计算函数：

函数名输入序列类型输出序列类型功能描述
TIME_DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXTINT64统计序列中某数据点的时间戳与前一数据点时间戳的差。范围内第一个数据点没有对应的结果输出。
DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE与输入序列的实际类型一致统计序列中某数据点的值与前一数据点的值的差。范围内第一个数据点没有对应的结果输出。
NON_NEGATIVE_DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE与输入序列的实际类型一致统计序列中某数据点的值与前一数据点的值的差的绝对值。范围内第一个数据点没有对应的结果输出。
DERIVATIVEINT32 / INT64 / FLOAT / DOUBLEDOUBLE统计序列中某数据点相对于前一数据点的变化率，数量上等同于 DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。
NON_NEGATIVE_DERIVATIVEINT32 / INT64 / FLOAT / DOUBLEDOUBLE统计序列中某数据点相对于前一数据点的变化率的绝对值，数量上等同于 NON_NEGATIVE_DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。

例如：

  1. select s1, time_difference(s1), difference(s1), non_negative_difference(s1), derivative(s1), non_negative_derivative(s1) from root.sg1.d1 limit 5 offset 1000;

结果：

  1. +-----------------------------+-------------------+-------------------------------+--------------------------+---------------------------------------+--------------------------+---------------------------------------+
  2. |                         Time|     root.sg1.d1.s1|time_difference(root.sg1.d1.s1)|difference(root.sg1.d1.s1)|non_negative_difference(root.sg1.d1.s1)|derivative(root.sg1.d1.s1)|non_negative_derivative(root.sg1.d1.s1)|
  3. +-----------------------------+-------------------+-------------------------------+--------------------------+---------------------------------------+--------------------------+---------------------------------------+
  4. |2020-12-10T17:11:49.037+08:00|7360723084922759782|                              1|      -8431715764844238876|                    8431715764844238876|    -8.4317157648442388E18|                  8.4317157648442388E18|
  5. |2020-12-10T17:11:49.038+08:00|4377791063319964531|                              1|      -2982932021602795251|                    2982932021602795251|     -2.982932021602795E18|                   2.982932021602795E18|
  6. |2020-12-10T17:11:49.039+08:00|7972485567734642915|                              1|       3594694504414678384|                    3594694504414678384|     3.5946945044146785E18|                  3.5946945044146785E18|
  7. |2020-12-10T17:11:49.040+08:00|2508858212791964081|                              1|      -5463627354942678834|                    5463627354942678834|     -5.463627354942679E18|                   5.463627354942679E18|
  8. |2020-12-10T17:11:49.041+08:00|2817297431185141819|                              1|        308439218393177738|                     308439218393177738|     3.0843921839317773E17|                  3.0843921839317773E17|
  9. +-----------------------------+-------------------+-------------------------------+--------------------------+---------------------------------------+--------------------------+---------------------------------------+
  10. Total line number = 5
  11. It costs 0.014s

常序列生成函数

常序列生成函数用于生成所有数据点的值都相同的时间序列。

常序列生成函数接受一个或者多个时间序列输入，其输出的数据点的时间戳集合是这些输入序列时间戳集合的并集。

目前 IoTDB 支持如下常序列生成函数：

函数名必要的属性参数输出序列类型功能描述
CONSTvalue: 输出的数据点的值
type: 输出的数据点的类型，只能是 INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXT		由输入属性参数 type 决定根据输入属性 value 和 type 输出用户指定的常序列。
PI无DOUBLE常序列的值：π 的 double 值，圆的周长与其直径的比值，即圆周率，等于 Java标准库 中的Math.PI。
E无DOUBLE常序列的值：e 的 double 值，自然对数的底，它等于 Java 标准库 中的 Math.E。

例如：

  1. select s1, s2, const(s1, 'value'='1024', 'type'='INT64'), pi(s2), e(s1, s2) from root.sg1.d1;

结果：

  1. select s1, s2, const(s1, 'value'='1024', 'type'='INT64'), pi(s2), e(s1, s2) from root.sg1.d1; 
  2. +-----------------------------+--------------+--------------+-----------------------------------------------------+------------------+---------------------------------+
  3. |                         Time|root.sg1.d1.s1|root.sg1.d1.s2|const(root.sg1.d1.s1, "value"="1024", "type"="INT64")|pi(root.sg1.d1.s2)|e(root.sg1.d1.s1, root.sg1.d1.s2)|
  4. +-----------------------------+--------------+--------------+-----------------------------------------------------+------------------+---------------------------------+
  5. |1970-01-01T08:00:00.000+08:00|           0.0|           0.0|                                                 1024| 3.141592653589793|                2.718281828459045|
  6. |1970-01-01T08:00:00.001+08:00|           1.0|          null|                                                 1024|              null|                2.718281828459045|
  7. |1970-01-01T08:00:00.002+08:00|           2.0|          null|                                                 1024|              null|                2.718281828459045|
  8. |1970-01-01T08:00:00.003+08:00|          null|           3.0|                                                 null| 3.141592653589793|                2.718281828459045|
  9. |1970-01-01T08:00:00.004+08:00|          null|           4.0|                                                 null| 3.141592653589793|                2.718281828459045|
  10. +-----------------------------+--------------+--------------+-----------------------------------------------------+------------------+---------------------------------+
  11. Total line number = 5
  12. It costs 0.005s

数据类型转换函数

当前IoTDB支持6种数据类型，其中包括INT32、INT64、FLOAT、DOUBLE、BOOLEAN以及TEXT。当我们对数据进行查询或者计算时可能需要进行数据类型的转换， 比如说将TEXT转换为INT32，或者提高数据精度，比如说将FLOAT转换为DOUBLE。所以，IoTDB支持使用cast函数对数据类型进行转换。

函数名必要的属性参数输出序列类型功能类型
CASTtype:输出的数据点的类型，只能是 INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXT由输入属性参数type决定将数据转换为type参数指定的类型。
类型转换说明

1.当INT32、INT64类型的值不为0时，FLOAT与DOUBLE类型的值不为0.0时，TEXT类型不为空字符串或者”false”时，转换为BOOLEAN类型时值为true，否则为false。

2.当BOOLEAN类型的值为true时，转换为INT32与INT64类型的值为1，转换为FLOAT或者DOUBLE类型时值为1.0，转换为TEXT类型时值为”true”。当BOOLEAN类型的值为false时，转换为INT32与INT64类型的值为0，转换为FLOAT或者DOUBLE类型时值为0.0，转换为TEXT类型时值为”false”。

3.当TEXT类型转换为INT32、INT64、FLOAT类型时，会先将TEXT类型的数据转换为DOUBLE类型，然后再转换为对应的类型，此时可能会存在损失精度的问题。如果无法转换的话则直接跳过。

演示

测试数据：

  1. IoTDB> select text from root.test;
  2. +-----------------------------+--------------+
  3. |                         Time|root.test.text|
  4. +-----------------------------+--------------+
  5. |1970-01-01T08:00:00.001+08:00|           1.1|
  6. |1970-01-01T08:00:00.002+08:00|             1|
  7. |1970-01-01T08:00:00.003+08:00|   hello world|
  8. |1970-01-01T08:00:00.004+08:00|         false|
  9. +-----------------------------+--------------+

SQL语句：

  1. select cast(text, 'type'='BOOLEAN'), cast(text, 'type'='INT32'), cast(text, 'type'='INT64'), cast(text, 'type'='FLOAT'), cast(text, 'type'='DOUBLE') from root.test;

结果：

  1. +-----------------------------+--------------------------------------+------------------------------------+------------------------------------+------------------------------------+-------------------------------------+
  2. |                         Time|cast(root.test.text, "type"="BOOLEAN")|cast(root.test.text, "type"="INT32")|cast(root.test.text, "type"="INT64")|cast(root.test.text, "type"="FLOAT")|cast(root.test.text, "type"="DOUBLE")|
  3. +-----------------------------+--------------------------------------+------------------------------------+------------------------------------+------------------------------------+-------------------------------------+
  4. |1970-01-01T08:00:00.001+08:00|                                  true|                                   1|                                   1|                                 1.1|                                  1.1|
  5. |1970-01-01T08:00:00.002+08:00|                                  true|                                   1|                                   1|                                 1.0|                                  1.0|
  6. |1970-01-01T08:00:00.003+08:00|                                  true|                                null|                                null|                                null|                                 null|
  7. |1970-01-01T08:00:00.004+08:00|                                 false|                                null|                                null|                                null|                                 null|
  8. +-----------------------------+--------------------------------------+------------------------------------+------------------------------------+------------------------------------+-------------------------------------+
  9. Total line number = 4
  10. It costs 0.078s

条件函数

条件函数针对每个数据点进行条件判断，返回布尔值

目前IoTDB支持以下条件函数

函数名可接收的输入序列类型必要的属性参数输出序列类型功能类型
ON_OFFINT32 / INT64 / FLOAT / DOUBLEthreshold:DOUBLE类型BOOLEAN 类型返回ts_value >= threshold的bool值
IN_RANGEINT32 / INT64 / FLOAT / DOUBLElower:DOUBLE类型
upper:DOUBLE类型		BOOLEAN类型返回ts_value >= lower && ts_value <= upper的bool值

测试数据：

  1. IoTDB> select ts from root.test;
  2. +-----------------------------+------------+
  3. |                         Time|root.test.ts|
  4. +-----------------------------+------------+
  5. |1970-01-01T08:00:00.001+08:00|           1|
  6. |1970-01-01T08:00:00.002+08:00|           2|
  7. |1970-01-01T08:00:00.003+08:00|           3|
  8. |1970-01-01T08:00:00.004+08:00|           4|
  9. +-----------------------------+------------+
测试1

SQL语句：

  1. select ts, on_off(ts, 'threshold'='2') from root.test;

输出：

  1. IoTDB> select ts, on_off(ts, 'threshold'='2') from root.test;
  2. +-----------------------------+------------+-------------------------------------+
  3. |                         Time|root.test.ts|on_off(root.test.ts, "threshold"="2")|
  4. +-----------------------------+------------+-------------------------------------+
  5. |1970-01-01T08:00:00.001+08:00|           1|                                false|
  6. |1970-01-01T08:00:00.002+08:00|           2|                                 true|
  7. |1970-01-01T08:00:00.003+08:00|           3|                                 true|
  8. |1970-01-01T08:00:00.004+08:00|           4|                                 true|
  9. +-----------------------------+------------+-------------------------------------+
测试2

Sql语句：

  1. select ts, in_range(ts, 'lower'='2', 'upper'='3.1') from root.test;

输出：

  1. IoTDB> select ts, in_range(ts, 'lower'='2', 'upper'='3.1') from root.test;
  2. +-----------------------------+------------+--------------------------------------------------+
  3. |                         Time|root.test.ts|in_range(root.test.ts, "lower"="2", "upper"="3.1")|
  4. +-----------------------------+------------+--------------------------------------------------+
  5. |1970-01-01T08:00:00.001+08:00|           1|                                             false|
  6. |1970-01-01T08:00:00.002+08:00|           2|                                              true|
  7. |1970-01-01T08:00:00.003+08:00|           3|                                              true|
  8. |1970-01-01T08:00:00.004+08:00|           4|                                             false|
  9. +-----------------------------+------------+--------------------------------------------------+

连续满足区间函数

连续满足条件区间函数用来查询所有满足指定条件的连续区间。 按返回值可分为两类：

  1. 返回满足条件连续区间的起始时间戳和时间跨度(时间跨度为0表示此处只有起始时间这一个数据点满足条件)
  2. 返回满足条件连续区间的起始时间戳和后面连续满足条件的点的个数（个数为1表示此处只有起始时间这一个数据点满足条件）
函数名输入序列类型属性参数输出序列类型功能描述
ZERO_DURATIONINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:可选，默认值0
max:可选，默认值Long.MAX_VALUE		Long返回时间序列连续为0(false)的开始时间与持续时间，持续时间t(单位ms)满足t >= min && t <= max
NON_ZERO_DURATIONINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:可选，默认值0
max:可选，默认值Long.MAX_VALUE		Long返回时间序列连续不为0(false)的开始时间与持续时间，持续时间t(单位ms)满足t >= min && t <= max
ZERO_COUNTINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:可选，默认值1
max:可选，默认值Long.MAX_VALUE		Long返回时间序列连续为0(false)的开始时间与其后数据点的个数，数据点个数n满足n >= min && n <= max
NON_ZERO_COUNTINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:可选，默认值1
max:可选，默认值Long.MAX_VALUE		Long返回时间序列连续不为0(false)的开始时间与其后数据点的个数，数据点个数n满足n >= min && n <= max
演示

测试数据:

  1. IoTDB> select s1,s2,s3,s4,s5 from root.sg.d2;
  2. +-----------------------------+-------------+-------------+-------------+-------------+-------------+
  3. |                         Time|root.sg.d2.s1|root.sg.d2.s2|root.sg.d2.s3|root.sg.d2.s4|root.sg.d2.s5|
  4. +-----------------------------+-------------+-------------+-------------+-------------+-------------+
  5. |1970-01-01T08:00:00.000+08:00|            0|            0|          0.0|          0.0|        false|
  6. |1970-01-01T08:00:00.001+08:00|            1|            1|          1.0|          1.0|         true|
  7. |1970-01-01T08:00:00.002+08:00|            1|            1|          1.0|          1.0|         true|
  8. |1970-01-01T08:00:00.003+08:00|            0|            0|          0.0|          0.0|        false|
  9. |1970-01-01T08:00:00.004+08:00|            1|            1|          1.0|          1.0|         true|
  10. |1970-01-01T08:00:00.005+08:00|            0|            0|          0.0|          0.0|        false|
  11. |1970-01-01T08:00:00.006+08:00|            0|            0|          0.0|          0.0|        false|
  12. |1970-01-01T08:00:00.007+08:00|            1|            1|          1.0|          1.0|         true|
  13. +-----------------------------+-------------+-------------+-------------+-------------+-------------+

sql:

  1. select s1, zero_count(s1), non_zero_count(s2), zero_duration(s3), non_zero_duration(s4) from root.sg.d2;

结果:

  1. +-----------------------------+-------------+-------------------------+-----------------------------+----------------------------+--------------------------------+
  2. |                         Time|root.sg.d2.s1|zero_count(root.sg.d2.s1)|non_zero_count(root.sg.d2.s2)|zero_duration(root.sg.d2.s3)|non_zero_duration(root.sg.d2.s4)|
  3. +-----------------------------+-------------+-------------------------+-----------------------------+----------------------------+--------------------------------+
  4. |1970-01-01T08:00:00.000+08:00|            0|                        1|                         null|                           0|                            null|
  5. |1970-01-01T08:00:00.001+08:00|            1|                     null|                            2|                        null|                               1|
  6. |1970-01-01T08:00:00.002+08:00|            1|                     null|                         null|                        null|                            null|
  7. |1970-01-01T08:00:00.003+08:00|            0|                        1|                         null|                           0|                            null|
  8. |1970-01-01T08:00:00.004+08:00|            1|                     null|                            1|                        null|                               0|
  9. |1970-01-01T08:00:00.005+08:00|            0|                        2|                         null|                           1|                            null|
  10. |1970-01-01T08:00:00.006+08:00|            0|                     null|                         null|                        null|                            null|
  11. |1970-01-01T08:00:00.007+08:00|            1|                     null|                            1|                        null|                               0|
  12. +-----------------------------+-------------+-------------------------+-----------------------------+----------------------------+--------------------------------+

自定义时间序列生成函数

请参考 UDF。

已知的自定义时间序列生成函数库实现：

嵌套表达式

IoTDB支持嵌套表达式，由于聚合查询和时间序列查询不能在一条查询语句中同时出现，我们将支持的嵌套表达式分为时间序列查询嵌套表达式和聚合查询嵌套表达式两类。

下面是嵌套表达式统一的 SELECT 子句语法定义：

  1. selectClause
  2.     : SELECT resultColumn (',' resultColumn)*
  3.     ;
  5. resultColumn
  6.     : expression (AS ID)?
  7.     ;
  9. expression
  10.     : '(' expression ')'
  11.     | '-' expression
  12.     | expression ('*' | '/' | '%') expression
  13.     | expression ('+' | '-') expression
  14.     | functionName '(' expression (',' expression)* functionAttribute* ')'
  15.     | timeSeriesSuffixPath
  16.     | number
  17.     ;

时间序列查询嵌套表达式

IoTDB 支持在 SELECT 子句中计算由数字常量，时间序列、时间序列生成函数（包括用户自定义函数）和算数运算表达式组成的任意嵌套表达式。

示例

输入1：

  1. select a,
  2.        b,
  3.        ((a + 1) * 2 - 1) % 2 + 1.5,
  4.        sin(a + sin(a + sin(b))),
  5.        -(a + b) * (sin(a + b) * sin(a + b) + cos(a + b) * cos(a + b)) + 1
  6. from root.sg1;

结果集1：

  1. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  2. |                         Time|root.sg1.a|root.sg1.b|((((root.sg1.a + 1) * 2) - 1) % 2) + 1.5|sin(root.sg1.a + sin(root.sg1.a + sin(root.sg1.b)))|(-root.sg1.a + root.sg1.b * ((sin(root.sg1.a + root.sg1.b) * sin(root.sg1.a + root.sg1.b)) + (cos(root.sg1.a + root.sg1.b) * cos(root.sg1.a + root.sg1.b)))) + 1|
  3. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  4. |1970-01-01T08:00:00.010+08:00|         1|         1|                                     2.5|                                 0.9238430524420609|                                                                                                                      -1.0|
  5. |1970-01-01T08:00:00.020+08:00|         2|         2|                                     2.5|                                 0.7903505371876317|                                                                                                                      -3.0|
  6. |1970-01-01T08:00:00.030+08:00|         3|         3|                                     2.5|                                0.14065207680386618|                                                                                                                      -5.0|
  7. |1970-01-01T08:00:00.040+08:00|         4|      null|                                     2.5|                                               null|                                                                                                                      null|
  8. |1970-01-01T08:00:00.050+08:00|      null|         5|                                    null|                                               null|                                                                                                                      null|
  9. |1970-01-01T08:00:00.060+08:00|         6|         6|                                     2.5|                                -0.7288037411970916|                                                                                                                     -11.0|
  10. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  11. Total line number = 6
  12. It costs 0.048s

输入2：

  1. select (a + b) * 2 + sin(a) from root.sg

结果集2：

  1. +-----------------------------+----------------------------------------------+
  2. |                         Time|((root.sg.a + root.sg.b) * 2) + sin(root.sg.a)|
  3. +-----------------------------+----------------------------------------------+
  4. |1970-01-01T08:00:00.010+08:00|                             59.45597888911063|
  5. |1970-01-01T08:00:00.020+08:00|                            100.91294525072763|
  6. |1970-01-01T08:00:00.030+08:00|                            139.01196837590714|
  7. |1970-01-01T08:00:00.040+08:00|                            180.74511316047935|
  8. |1970-01-01T08:00:00.050+08:00|                            219.73762514629607|
  9. |1970-01-01T08:00:00.060+08:00|                             259.6951893788978|
  10. |1970-01-01T08:00:00.070+08:00|                             300.7738906815579|
  11. |1970-01-01T08:00:00.090+08:00|                             39.45597888911063|
  12. |1970-01-01T08:00:00.100+08:00|                             39.45597888911063|
  13. +-----------------------------+----------------------------------------------+
  14. Total line number = 9
  15. It costs 0.011s

输入3：

  1. select (a + *) / 2  from root.sg1

结果集3：

  1. +-----------------------------+-----------------------------+-----------------------------+
  2. |                         Time|(root.sg1.a + root.sg1.a) / 2|(root.sg1.a + root.sg1.b) / 2|
  3. +-----------------------------+-----------------------------+-----------------------------+
  4. |1970-01-01T08:00:00.010+08:00|                          1.0|                          1.0|
  5. |1970-01-01T08:00:00.020+08:00|                          2.0|                          2.0|
  6. |1970-01-01T08:00:00.030+08:00|                          3.0|                          3.0|
  7. |1970-01-01T08:00:00.040+08:00|                          4.0|                         null|
  8. |1970-01-01T08:00:00.060+08:00|                          6.0|                          6.0|
  9. +-----------------------------+-----------------------------+-----------------------------+
  10. Total line number = 5
  11. It costs 0.011s

输入4：

  1. select (a + b) * 3 from root.sg, root.ln

结果集4：

  1. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  2. |                         Time|(root.sg.a + root.sg.b) * 3|(root.sg.a + root.ln.b) * 3|(root.ln.a + root.sg.b) * 3|(root.ln.a + root.ln.b) * 3|
  3. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  4. |1970-01-01T08:00:00.010+08:00|                       90.0|                      270.0|                      360.0|                      540.0|
  5. |1970-01-01T08:00:00.020+08:00|                      150.0|                      330.0|                      690.0|                      870.0|
  6. |1970-01-01T08:00:00.030+08:00|                      210.0|                      450.0|                      570.0|                      810.0|
  7. |1970-01-01T08:00:00.040+08:00|                      270.0|                      240.0|                      690.0|                      660.0|
  8. |1970-01-01T08:00:00.050+08:00|                      330.0|                       null|                       null|                       null|
  9. |1970-01-01T08:00:00.060+08:00|                      390.0|                       null|                       null|                       null|
  10. |1970-01-01T08:00:00.070+08:00|                      450.0|                       null|                       null|                       null|
  11. |1970-01-01T08:00:00.090+08:00|                       60.0|                       null|                       null|                       null|
  12. |1970-01-01T08:00:00.100+08:00|                       60.0|                       null|                       null|                       null|
  13. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  14. Total line number = 9
  15. It costs 0.014s

说明

  • 当某个时间戳下左操作数和右操作数都不为空（null）时，表达式才会有结果，否则表达式值为null，且默认不出现在结果集中。
    • 从结果集1中可知，时间戳40下，时间序列root.sg.a的值为4，root.sg.b的值为null。所以在时间戳40下，表达式(a + b) * 2 + sin(a)的值为null，从结果集2可以看出，时间戳40没有出现。
  • 如果表达式中某个操作数对应多条时间序列（如通配符*），那么每条时间序列对应的结果都会出现在结果集中（按照笛卡尔积形式）。请参考示例中输入3、4和对应结果集3、4。

注意

目前对齐时间序列(Aligned Timeseries)尚不支持时间序列查询嵌套表达式。使用时间序列查询嵌套表达式时，如果操作数包含对齐时间序列，会提示错误。

聚合查询嵌套表达式

IoTDB 支持在 SELECT 子句中计算由数字常量，聚合查询和算数运算表达式组成的任意嵌套表达式。

示例

不指定 GROUP BY 的聚合查询。

输入1：

  1. select avg(temperature),
  2.        sin(avg(temperature)),
  3.        avg(temperature) + 1,
  4.        -sum(hardware),
  5.        avg(temperature) + sum(hardware)
  6. from root.ln.wf01.wt01;

结果集1：

  1. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  2. |avg(root.ln.wf01.wt01.temperature)|sin(avg(root.ln.wf01.wt01.temperature))|avg(root.ln.wf01.wt01.temperature) + 1|-sum(root.ln.wf01.wt01.hardware)|avg(root.ln.wf01.wt01.temperature) + sum(root.ln.wf01.wt01.hardware)|
  3. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  4. |                15.927999999999999|                   -0.21826546964855045|                    16.927999999999997|                         -7426.0|                                                            7441.928|
  5. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  6. Total line number = 1
  7. It costs 0.009s

输入2：

  1. select avg(*), 
  2.        (avg(*) + 1) * 3 / 2 -1 
  3. from root.sg1

结果集2：

  1. +---------------+---------------+-------------------------------------+-------------------------------------+
  2. |avg(root.sg1.a)|avg(root.sg1.b)|(((avg(root.sg1.a) + 1) * 3) / 2) - 1|(((avg(root.sg1.b) + 1) * 3) / 2) - 1|
  3. +---------------+---------------+-------------------------------------+-------------------------------------+
  4. |            3.2|            3.4|                    5.300000000000001|                   5.6000000000000005|
  5. +---------------+---------------+-------------------------------------+-------------------------------------+
  6. Total line number = 1
  7. It costs 0.007s

指定 GROUP BY 的聚合查询。

输入3：

  1. select avg(temperature),
  2.        sin(avg(temperature)),
  3.        avg(temperature) + 1,
  4.        -sum(hardware),
  5.        avg(temperature) + sum(hardware) as custom_sum
  6. from root.ln.wf01.wt01
  7. GROUP BY([10, 90), 10ms);

结果集3：

  1. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  2. |                         Time|avg(root.ln.wf01.wt01.temperature)|sin(avg(root.ln.wf01.wt01.temperature))|avg(root.ln.wf01.wt01.temperature) + 1|-sum(root.ln.wf01.wt01.hardware)|custom_sum|
  3. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  4. |1970-01-01T08:00:00.010+08:00|                13.987499999999999|                     0.9888207947857667|                    14.987499999999999|                         -3211.0| 3224.9875|
  5. |1970-01-01T08:00:00.020+08:00|                              29.6|                    -0.9701057337071853|                                  30.6|                         -3720.0|    3749.6|
  6. |1970-01-01T08:00:00.030+08:00|                              null|                                   null|                                  null|                            null|      null|
  7. |1970-01-01T08:00:00.040+08:00|                              null|                                   null|                                  null|                            null|      null|
  8. |1970-01-01T08:00:00.050+08:00|                              null|                                   null|                                  null|                            null|      null|
  9. |1970-01-01T08:00:00.060+08:00|                              null|                                   null|                                  null|                            null|      null|
  10. |1970-01-01T08:00:00.070+08:00|                              null|                                   null|                                  null|                            null|      null|
  11. |1970-01-01T08:00:00.080+08:00|                              null|                                   null|                                  null|                            null|      null|
  12. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  13. Total line number = 8
  14. It costs 0.012s

说明

  • 当某个时间戳下左操作数和右操作数都不为空（null）时，表达式才会有结果，否则表达式值为null，且默认不出现在结果集中。但在使用GROUP BY子句的聚合查询嵌套表达式中，我们希望保留每个时间窗口的值，所以表达式值为null的窗口也包含在结果集中。请参考输入3及结果集3。
  • 如果表达式中某个操作数对应多条时间序列（如通配符*），那么每条时间序列对应的结果都会出现在结果集中（按照笛卡尔积形式）。请参考输入2及结果集2。

注意

目前此功能尚不支持填充算子（FILL）和按层级聚合（GROUP BY LEVEL）查询, 在后续版本会支持。

聚合计算目前只能当做最底层表达式输入，暂不支持聚合函数内部出现表达式。

即不支持以下查询

  1. SELECT avg(s1 + 1) FROM root.sg.d1; -- 聚合函数内部有表达式
  2. SELECT avg(s1) + avg(s2) FROM root.sg.* GROUP BY LEVEL=1; -- 按层级聚合
  3. SELECT avg(s1) + avg(s2) FROM root.sg.d1 GROUP BY([0, 10000), 1s) FILL(previous); -- 空值填充

使用别名

由于 IoTDB 独特的数据模型，在每个传感器前都附带有设备等诸多额外信息。有时，我们只针对某个具体设备查询，而这些前缀信息频繁显示造成了冗余，影响了结果集的显示与分析。这时我们可以使用 IoTDB 提供的 AS 函数，将查询中出现的时间序列给定一个别名。

例如：

  1. select s1 as temperature, s2 as speed from root.ln.wf01.wt01;

则结果集将显示为：

Timetemperaturespeed
………