我的书签
添加书签
移除书签内置函数与表达式
聚合函数
聚合函数是多对一函数。它们对一组值进行聚合计算，得到单个聚合结果。
除了 COUNT(), COUNT_IF()之外，其他所有聚合函数都忽略空值，并在没有输入行或所有值为空时返回空值。 例如，SUM() 返回 null 而不是零，而 AVG() 在计数中不包括 null 值。
IoTDB 支持的聚合函数如下：
| 函数名 | 功能描述 | 允许的输入类型 | 必要的属性参数 | 输出类型 |
|---|---|---|---|---|
| SUM | 求和。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| COUNT | 计算数据点数。 | 所有类型 | 无 | INT64 |
| AVG | 求平均值。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| STDDEV | STDDEV_SAMP 的别名，求样本标准差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| STDDEV_POP | 求总体标准差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| STDDEV_SAMP | 求样本标准差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| VARIANCE | VAR_SAMP 的别名，求样本方差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| VAR_POP | 求总体方差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| VAR_SAMP | 求样本方差。 | INT32 INT64 FLOAT DOUBLE | 无 | DOUBLE |
| EXTREME | 求具有最大绝对值的值。如果正值和负值的最大绝对值相等，则返回正值。 | INT32 INT64 FLOAT DOUBLE | 无 | 与输入类型一致 |
| MAX_VALUE | 求最大值。 | INT32 INT64 FLOAT DOUBLE | 无 | 与输入类型一致 |
| MIN_VALUE | 求最小值。 | INT32 INT64 FLOAT DOUBLE | 无 | 与输入类型一致 |
| FIRST_VALUE | 求时间戳最小的值。 | 所有类型 | 无 | 与输入类型一致 |
| LAST_VALUE | 求时间戳最大的值。 | 所有类型 | 无 | 与输入类型一致 |
| MAX_TIME | 求最大时间戳。 | 所有类型 | 无 | Timestamp |
| MIN_TIME | 求最小时间戳。 | 所有类型 | 无 | Timestamp |
| COUNT_IF | 求数据点连续满足某一给定条件，且满足条件的数据点个数（用keep表示）满足指定阈值的次数。 | BOOLEAN | [keep >=/>/=/!=/</<=]threshold：被指定的阈值或阈值条件，若只使用threshold则等价于keep >= threshold,threshold类型为INT64 ignoreNull：可选，默认为true；为true表示忽略null值，即如果中间出现null值，直接忽略，不会打断连续性；为false表示不忽略null值，即如果中间出现null值，会打断连续性 |
INT64 |
| TIME_DURATION | 求某一列最大一个不为NULL的值所在时间戳与最小一个不为NULL的值所在时间戳的时间戳差 | 所有类型 | 无 | INT64 |
| MODE | 求众数。注意： 1.输入序列的不同值个数过多时会有内存异常风险; 2.如果所有元素出现的频次相同，即没有众数，则返回对应时间戳最小的值; 3.如果有多个众数，则返回对应时间戳最小的众数。 | 所有类型 | 无 | 与输入类型一致 |
| COUNT_TIME | 查询结果集的时间戳的数量。与 align by device 搭配使用时，得到的结果是每个设备的结果集的时间戳的数量。 | 所有类型，输入参数只能为* | 无 | INT64 |
| MAX_BY | MAX_BY(x, y) 求二元输入 x 和 y 在 y 最大时对应的 x 的值。MAX_BY(time, x) 返回 x 取最大值时对应的时间戳。 注：V1.3.2 版本开始支持 | 第一个输入 x 可以是任意类型，第二个输入 y 只能是 INT32 INT64 FLOAT DOUBLE | 无 | 与第一个输入 x 的数据类型一致 |
| MIN_BY | MIN_BY(x, y) 求二元输入 x 和 y 在 y 最小时对应的 x 的值。MIN_BY(time, x) 返回 x 取最小值时对应的时间戳。 注：V1.3.2 版本开始支持 | 第一个输入 x 可以是任意类型，第二个输入 y 只能是 INT32 INT64 FLOAT DOUBLE | 无 | 与第一个输入 x 的数据类型一致 |
COUNT_IF
语法
1. count_if(predicate, [keep >=/>/=/!=/</<=]threshold[, 'ignoreNull'='true/false'])
predicate: 返回类型为BOOLEAN的合法表达式
threshold 及 ignoreNull 用法见上表
注意: count_if 当前暂不支持与 group by time 的 SlidingWindow 一起使用
使用示例
原始数据
1. +-----------------------------+-------------+-------------+
2. | Time|root.db.d1.s1|root.db.d1.s2|
3. +-----------------------------+-------------+-------------+
4. |1970-01-01T08:00:00.001+08:00| 0| 0|
5. |1970-01-01T08:00:00.002+08:00| null| 0|
6. |1970-01-01T08:00:00.003+08:00| 0| 0|
7. |1970-01-01T08:00:00.004+08:00| 0| 0|
8. |1970-01-01T08:00:00.005+08:00| 1| 0|
9. |1970-01-01T08:00:00.006+08:00| 1| 0|
10. |1970-01-01T08:00:00.007+08:00| 1| 0|
11. |1970-01-01T08:00:00.008+08:00| 0| 0|
12. |1970-01-01T08:00:00.009+08:00| 0| 0|
13. |1970-01-01T08:00:00.010+08:00| 0| 0|
14. +-----------------------------+-------------+-------------+
不使用ignoreNull参数(忽略null)
SQL:
1. select count_if(s1=0 & s2=0, 3), count_if(s1=1 & s2=0, 3) from root.db.d1
输出:
1. +--------------------------------------------------+--------------------------------------------------+
2. |count_if(root.db.d1.s1 = 0 & root.db.d1.s2 = 0, 3)|count_if(root.db.d1.s1 = 1 & root.db.d1.s2 = 0, 3)|
3. +--------------------------------------------------+--------------------------------------------------+
4. | 2| 1|
5. +--------------------------------------------------+--------------------------------------------------
使用ignoreNull参数
SQL:
1. select count_if(s1=0 & s2=0, 3, 'ignoreNull'='false'), count_if(s1=1 & s2=0, 3, 'ignoreNull'='false') from root.db.d1
输出:
1. +------------------------------------------------------------------------+------------------------------------------------------------------------+
2. |count_if(root.db.d1.s1 = 0 & root.db.d1.s2 = 0, 3, "ignoreNull"="false")|count_if(root.db.d1.s1 = 1 & root.db.d1.s2 = 0, 3, "ignoreNull"="false")|
3. +------------------------------------------------------------------------+------------------------------------------------------------------------+
4. | 1| 1|
5. +------------------------------------------------------------------------+------------------------------------------------------------------------+
TIME_DURATION
语法
1. time_duration(Path)
使用示例
准备数据
1. +----------+-------------+
2. | Time|root.db.d1.s1|
3. +----------+-------------+
4. | 1| 70|
5. | 3| 10|
6. | 4| 303|
7. | 6| 110|
8. | 7| 302|
9. | 8| 110|
10. | 9| 60|
11. | 10| 70|
12. |1677570934| 30|
13. +----------+-------------+
写入语句
1. "CREATE DATABASE root.db",
2. "CREATE TIMESERIES root.db.d1.s1 WITH DATATYPE=INT32, ENCODING=PLAIN tags(city=Beijing)",
3. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(1, 2, 10, true)",
4. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(2, null, 20, true)",
5. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(3, 10, 0, null)",
6. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(4, 303, 30, true)",
7. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(5, null, 20, true)",
8. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(6, 110, 20, true)",
9. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(7, 302, 20, true)",
10. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(8, 110, null, true)",
11. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(9, 60, 20, true)",
12. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(10,70, 20, null)",
13. "INSERT INTO root.db.d1(timestamp,s1,s2,s3) values(1677570934, 30, 0, true)",
查询：
1. select time_duration(s1) from root.db.d1
输出
1. +----------------------------+
2. |time_duration(root.db.d1.s1)|
3. +----------------------------+
4. | 1677570933|
5. +----------------------------+
注：若数据点只有一个，则返回0，若数据点为null，则返回null。
COUNT_TIME
语法
1. count_time(*)
使用示例
准备数据
1. +----------+-------------+-------------+-------------+-------------+
2. | Time|root.db.d1.s1|root.db.d1.s2|root.db.d2.s1|root.db.d2.s2|
3. +----------+-------------+-------------+-------------+-------------+
4. | 0| 0| null| null| 0|
5. | 1| null| 1| 1| null|
6. | 2| null| 2| 2| null|
7. | 4| 4| null| null| 4|
8. | 5| 5| 5| 5| 5|
9. | 7| null| 7| 7| null|
10. | 8| 8| 8| 8| 8|
11. | 9| null| 9| null| null|
12. +----------+-------------+-------------+-------------+-------------+
写入语句
1. CREATE DATABASE root.db;
2. CREATE TIMESERIES root.db.d1.s1 WITH DATATYPE=INT32, ENCODING=PLAIN;
3. CREATE TIMESERIES root.db.d1.s2 WITH DATATYPE=INT32, ENCODING=PLAIN;
4. CREATE TIMESERIES root.db.d2.s1 WITH DATATYPE=INT32, ENCODING=PLAIN;
5. CREATE TIMESERIES root.db.d2.s2 WITH DATATYPE=INT32, ENCODING=PLAIN;
6. INSERT INTO root.db.d1(time, s1) VALUES(0, 0), (4,4), (5,5), (8,8);
7. INSERT INTO root.db.d1(time, s2) VALUES(1, 1), (2,2), (5,5), (7,7), (8,8), (9,9);
8. INSERT INTO root.db.d2(time, s1) VALUES(1, 1), (2,2), (5,5), (7,7), (8,8);
9. INSERT INTO root.db.d2(time, s2) VALUES(0, 0), (4,4), (5,5), (8,8);
查询示例1：
1. select count_time(*) from root.db.**
输出
1. +-------------+
2. |count_time(*)|
3. +-------------+
4. | 8|
5. +-------------+
查询示例2：
1. select count_time(*) from root.db.d1, root.db.d2
输出
1. +-------------+
2. |count_time(*)|
3. +-------------+
4. | 8|
5. +-------------+
查询示例3：
1. select count_time(*) from root.db.** group by([0, 10), 2ms)
输出
1. +-----------------------------+-------------+
2. | Time|count_time(*)|
3. +-----------------------------+-------------+
4. |1970-01-01T08:00:00.000+08:00| 2|
5. |1970-01-01T08:00:00.002+08:00| 1|
6. |1970-01-01T08:00:00.004+08:00| 2|
7. |1970-01-01T08:00:00.006+08:00| 1|
8. |1970-01-01T08:00:00.008+08:00| 2|
9. +-----------------------------+-------------+
查询示例4：
1. select count_time(*) from root.db.** group by([0, 10), 2ms) align by device
输出
1. +-----------------------------+----------+-------------+
2. | Time| Device|count_time(*)|
3. +-----------------------------+----------+-------------+
4. |1970-01-01T08:00:00.000+08:00|root.db.d1| 2|
5. |1970-01-01T08:00:00.002+08:00|root.db.d1| 1|
6. |1970-01-01T08:00:00.004+08:00|root.db.d1| 2|
7. |1970-01-01T08:00:00.006+08:00|root.db.d1| 1|
8. |1970-01-01T08:00:00.008+08:00|root.db.d1| 2|
9. |1970-01-01T08:00:00.000+08:00|root.db.d2| 2|
10. |1970-01-01T08:00:00.002+08:00|root.db.d2| 1|
11. |1970-01-01T08:00:00.004+08:00|root.db.d2| 2|
12. |1970-01-01T08:00:00.006+08:00|root.db.d2| 1|
13. |1970-01-01T08:00:00.008+08:00|root.db.d2| 1|
14. +-----------------------------+----------+-------------+
注：
- count_time里的表达式只能为*。
- count_time不能和其他的聚合函数一起使用。
- having语句里不支持使用count_time, 使用count_time聚合函数时不支持使用having语句。
- count_time不支持与group by level, group by tag一起使用。
MAX_BY
功能定义
max_by(x, y)： 返回 y 最大时对应时间戳下的 x 值。
- max_by 必须有两个输入参数 x 和 y。
- 第一个输入可以为 time 关键字, max_by(time, x) 返回 x 取最大值时对应的时间戳。
- 如果 y 最大时对应的时间戳下 x 为 null，则返回 null。
- 如果 y 可以在多个时间戳下取得最大值，取最大值中最小时间戳对应的 x 值。
- 与 IoTDB max_value 保持一致，仅支持 INT32、INT64、FLOAT、DOUBLE 作为 y 的输入，支持所有六种类型作为 x 的输入。
- x, y 的输入均不允许为具体数值。
语法
1. select max_by(x, y) from root.sg
2. select max_by(time, x) from root.sg
使用示例
原始数据
1. IoTDB> select * from root.test
2. +-----------------------------+-----------+-----------+
3. | Time|root.test.a|root.test.b|
4. +-----------------------------+-----------+-----------+
5. |1970-01-01T08:00:00.001+08:00| 1.0| 10.0|
6. |1970-01-01T08:00:00.002+08:00| 2.0| 10.0|
7. |1970-01-01T08:00:00.003+08:00| 3.0| 3.0|
8. |1970-01-01T08:00:00.004+08:00| 10.0| 10.0|
9. |1970-01-01T08:00:00.005+08:00| 10.0| 12.0|
10. |1970-01-01T08:00:00.006+08:00| 6.0| 6.0|
11. +-----------------------------+-----------+-----------+
查询示例
查询最大值对应的时间戳：
1. IoTDB> select max_by(time, a), max_value(a) from root.test
2. +-------------------------+------------------------+
3. |max_by(Time, root.test.a)| max_value(root.test.a)|
4. +-------------------------+------------------------+
5. | 4| 10.0|
6. +-------------------------+------------------------+
求 a 最大时对应的 b 值：
1. IoTDB> select max_by(b, a) from root.test
2. +--------------------------------+
3. |max_by(root.test.b, root.test.a)|
4. +--------------------------------+
5. | 10.0|
6. +--------------------------------+
结合表达式使用：
1. IoTDB> select max_by(b + 1, a * 2) from root.test
2. +----------------------------------------+
3. |max_by(root.test.b + 1, root.test.a * 2)|
4. +----------------------------------------+
5. | 11.0|
6. +----------------------------------------+
结合 group by time 子句使用：
1. IoTDB> select max_by(b, a) from root.test group by ([0,7),4ms)
2. +-----------------------------+--------------------------------+
3. | Time|max_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.000+08:00| 3.0|
6. +-----------------------------+--------------------------------+
7. |1970-01-01T08:00:00.004+08:00| 10.0|
8. +-----------------------------+--------------------------------+
结合 having 子句使用：
1. IoTDB> select max_by(b, a) from root.test group by ([0,7),4ms) having max_by(b, a) > 4.0
2. +-----------------------------+--------------------------------+
3. | Time|max_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.004+08:00| 10.0|
6. +-----------------------------+--------------------------------+
结合 order by 子句使用：
1. IoTDB> select max_by(b, a) from root.test group by ([0,7),4ms) order by time desc
2. +-----------------------------+--------------------------------+
3. | Time|max_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.004+08:00| 10.0|
6. +-----------------------------+--------------------------------+
7. |1970-01-01T08:00:00.000+08:00| 3.0|
8. +-----------------------------+--------------------------------+
MIN_BY
功能定义
min_by(x, y)： 返回 y 最小时对应时间戳下的 x 值。
- min_by 必须有两个输入参数 x 和 y。
- 第一个输入可以为 time 关键字, min_by(time, x) 返回 x 取最小值时对应的时间戳。
- 如果 y 最大时对应的时间戳下 x 为 null，则返回 null。
- 如果 y 可以在多个时间戳下取得最小值，取最小值中最小时间戳对应的 x 值。
- 与 IoTDB min_value 保持一致，仅支持 INT32、INT64、FLOAT、DOUBLE 作为 y 的输入，支持所有六种类型作为 x 的输入。
- x, y 的输入均不允许为具体数值。
语法
1. select min_by(x, y) from root.sg
2. select min_by(time, x) from root.sg
使用示例
原始数据
1. IoTDB> select * from root.test
2. +-----------------------------+-----------+-----------+
3. | Time|root.test.a|root.test.b|
4. +-----------------------------+-----------+-----------+
5. |1970-01-01T08:00:00.001+08:00| 4.0| 10.0|
6. |1970-01-01T08:00:00.002+08:00| 3.0| 10.0|
7. |1970-01-01T08:00:00.003+08:00| 2.0| 3.0|
8. |1970-01-01T08:00:00.004+08:00| 1.0| 10.0|
9. |1970-01-01T08:00:00.005+08:00| 1.0| 12.0|
10. |1970-01-01T08:00:00.006+08:00| 6.0| 6.0|
11. +-----------------------------+-----------+-----------+
查询示例
查询最小值对应的时间戳：
1. IoTDB> select min_by(time, a), min_value(a) from root.test
2. +-------------------------+------------------------+
3. |min_by(Time, root.test.a)| min_value(root.test.a)|
4. +-------------------------+------------------------+
5. | 4| 1.0|
6. +-------------------------+------------------------+
求 a 最小时对应的 b 值：
1. IoTDB> select min_by(b, a) from root.test
2. +--------------------------------+
3. |min_by(root.test.b, root.test.a)|
4. +--------------------------------+
5. | 10.0|
6. +--------------------------------+
结合表达式使用：
1. IoTDB> select min_by(b + 1, a * 2) from root.test
2. +----------------------------------------+
3. |min_by(root.test.b + 1, root.test.a * 2)|
4. +----------------------------------------+
5. | 11.0|
6. +----------------------------------------+
结合 group by time 子句使用：
1. IoTDB> select min_by(b, a) from root.test group by ([0,7),4ms)
2. +-----------------------------+--------------------------------+
3. | Time|min_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.000+08:00| 3.0|
6. +-----------------------------+--------------------------------+
7. |1970-01-01T08:00:00.004+08:00| 10.0|
8. +-----------------------------+--------------------------------+
结合 having 子句使用：
1. IoTDB> select min_by(b, a) from root.test group by ([0,7),4ms) having max_by(b, a) > 4.0
2. +-----------------------------+--------------------------------+
3. | Time|min_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.004+08:00| 10.0|
6. +-----------------------------+--------------------------------+
结合 order by 子句使用：
1. IoTDB> select min_by(b, a) from root.test group by ([0,7),4ms) order by time desc
2. +-----------------------------+--------------------------------+
3. | Time|min_by(root.test.b, root.test.a)|
4. +-----------------------------+--------------------------------+
5. |1970-01-01T08:00:00.004+08:00| 10.0|
6. +-----------------------------+--------------------------------+
7. |1970-01-01T08:00:00.000+08:00| 3.0|
8. +-----------------------------+--------------------------------+
算数运算符和函数
算数运算符
一元算数运算符
支持的运算符：+, -
输入数据类型要求：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
数学函数
目前 IoTDB 支持下列数学函数，这些数学函数的行为与这些函数在 Java Math 标准库中对应实现的行为一致。
| 函数名 | 输入序列类型 | 输出序列类型 | 必要属性参数 | Java 标准库中的对应实现 |
|---|---|---|---|---|
| SIN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#sin(double) | |
| COS | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#cos(double) | |
| TAN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#tan(double) | |
| ASIN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#asin(double) | |
| ACOS | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#acos(double) | |
| ATAN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#atan(double) | |
| SINH | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#sinh(double) | |
| COSH | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#cosh(double) | |
| TANH | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#tanh(double) | |
| DEGREES | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#toDegrees(double) | |
| RADIANS | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#toRadians(double) | |
| ABS | INT32 / INT64 / FLOAT / DOUBLE | 与输入序列的实际类型一致 | Math#abs(int) / Math#abs(long) /Math#abs(float) /Math#abs(double) | |
| SIGN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#signum(double) | |
| CEIL | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#ceil(double) | |
| FLOOR | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#floor(double) | |
| ROUND | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | places:四舍五入有效位数，正数为小数点后面的有效位数，负数为整数位的有效位数 |
Math#rint(Math#pow(10,places))/Math#pow(10,places) |
| EXP | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#exp(double) | |
| LN | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#log(double) | |
| LOG10 | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#log10(double) | |
| SQRT | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | Math#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
ROUND
例如：
1. select s4,round(s4),round(s4,2),round(s4,-1) from root.sg1.d1
1. +-----------------------------+-------------+--------------------+----------------------+-----------------------+
2. | Time|root.db.d1.s4|ROUND(root.db.d1.s4)|ROUND(root.db.d1.s4,2)|ROUND(root.db.d1.s4,-1)|
3. +-----------------------------+-------------+--------------------+----------------------+-----------------------+
4. |1970-01-01T08:00:00.001+08:00| 101.14345| 101.0| 101.14| 100.0|
5. |1970-01-01T08:00:00.002+08:00| 20.144346| 20.0| 20.14| 20.0|
6. |1970-01-01T08:00:00.003+08:00| 20.614372| 21.0| 20.61| 20.0|
7. |1970-01-01T08:00:00.005+08:00| 20.814346| 21.0| 20.81| 20.0|
8. |1970-01-01T08:00:00.006+08:00| 60.71443| 61.0| 60.71| 60.0|
9. |2023-03-13T16:16:19.764+08:00| 10.143425| 10.0| 10.14| 10.0|
10. +-----------------------------+-------------+--------------------+----------------------+-----------------------+
11. Total line number = 6
12. It costs 0.059s
比较运算符和函数
基本比较运算符
- 输入数据类型：
INT32,INT64,FLOAT,DOUBLE。 - 注意：会将所有数据转换为
DOUBLE类型后进行比较。==和!=可以直接比较两个BOOLEAN。 - 返回类型：
BOOLEAN。
| 运算符 | 含义 |
|---|---|
> |
大于 |
>= |
大于等于 |
< |
小于 |
<= |
小于等于 |
== |
等于 |
!= / <> |
不等于 |
示例：
1. select a, b, a > 10, a <= b, !(a <= b), a > 10 && a > b from root.test;
运行结果
1. IoTDB> select a, b, a > 10, a <= b, !(a <= b), a > 10 && a > b from root.test;
2. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
3. | Time|root.test.a|root.test.b|root.test.a > 10|root.test.a <= root.test.b|!root.test.a <= root.test.b|(root.test.a > 10) & (root.test.a > root.test.b)|
4. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
5. |1970-01-01T08:00:00.001+08:00| 23| 10.0| true| false| true| true|
6. |1970-01-01T08:00:00.002+08:00| 33| 21.0| true| false| true| true|
7. |1970-01-01T08:00:00.004+08:00| 13| 15.0| true| true| false| false|
8. |1970-01-01T08:00:00.005+08:00| 26| 0.0| true| false| true| true|
9. |1970-01-01T08:00:00.008+08:00| 1| 22.0| false| true| false| false|
10. |1970-01-01T08:00:00.010+08:00| 23| 12.0| true| false| true| true|
11. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
BETWEEN … AND … 运算符
| 运算符 | 含义 |
|---|---|
BETWEEN … AND … |
在指定范围内 |
NOT BETWEEN … AND … |
不在指定范围内 |
示例： 选择区间 [36.5,40] 内或之外的数据：
1. select temperature from root.sg1.d1 where temperature between 36.5 and 40;
1. select temperature from root.sg1.d1 where temperature not between 36.5 and 40;
模糊匹配运算符
对于 TEXT 类型的数据，支持使用 Like 和 Regexp 运算符对数据进行模糊匹配
| 运算符 | 含义 |
|---|---|
LIKE |
匹配简单模式 |
NOT LIKE |
无法匹配简单模式 |
REGEXP |
匹配正则表达式 |
NOT REGEXP |
无法匹配正则表达式 |
输入数据类型：TEXT
返回类型：BOOLEAN
使用 Like 进行模糊匹配
匹配规则：
%表示任意0个或多个字符。_表示任意单个字符。
示例 1： 查询 root.sg.d1 下 value 含有'cc'的数据。
1. IoTDB> select * from root.sg.d1 where value like '%cc%'
2. +-----------------------------+----------------+
3. | Time|root.sg.d1.value|
4. +-----------------------------+----------------+
5. |2017-11-01T00:00:00.000+08:00| aabbccdd|
6. |2017-11-01T00:00:01.000+08:00| cc|
7. +-----------------------------+----------------+
8. Total line number = 2
9. It costs 0.002s
示例 2： 查询 root.sg.d1 下 value 中间为 'b'、前后为任意单个字符的数据。
1. IoTDB> select * from root.sg.device where value like '_b_'
2. +-----------------------------+----------------+
3. | Time|root.sg.d1.value|
4. +-----------------------------+----------------+
5. |2017-11-01T00:00:02.000+08:00| abc|
6. +-----------------------------+----------------+
7. Total line number = 1
8. It costs 0.002s
使用 Regexp 进行模糊匹配
需要传入的过滤条件为 Java 标准库风格的正则表达式。
常见的正则匹配举例：
1. 长度为3-20的所有字符：^.{3,20}$
2. 大写英文字符：^[A-Z]+$
3. 数字和英文字符：^[A-Za-z0-9]+$
4. 以a开头的：^a.*
示例 1： 查询 root.sg.d1 下 value 值为26个英文字符组成的字符串。
1. IoTDB> select * from root.sg.d1 where value regexp '^[A-Za-z]+$'
2. +-----------------------------+----------------+
3. | Time|root.sg.d1.value|
4. +-----------------------------+----------------+
5. |2017-11-01T00:00:00.000+08:00| aabbccdd|
6. |2017-11-01T00:00:01.000+08:00| cc|
7. +-----------------------------+----------------+
8. Total line number = 2
9. It costs 0.002s
示例 2： 查询 root.sg.d1 下 value 值为26个小写英文字符组成的字符串且时间大于100的。
1. IoTDB> select * from root.sg.d1 where value regexp '^[a-z]+$' and time > 100
2. +-----------------------------+----------------+
3. | Time|root.sg.d1.value|
4. +-----------------------------+----------------+
5. |2017-11-01T00:00:00.000+08:00| aabbccdd|
6. |2017-11-01T00:00:01.000+08:00| cc|
7. +-----------------------------+----------------+
8. Total line number = 2
9. It costs 0.002s
示例 3：
1. select b, b like '1%', b regexp '[0-2]' from root.test;
运行结果
1. +-----------------------------+-----------+-------------------------+--------------------------+
2. | Time|root.test.b|root.test.b LIKE '^1.*?$'|root.test.b REGEXP '[0-2]'|
3. +-----------------------------+-----------+-------------------------+--------------------------+
4. |1970-01-01T08:00:00.001+08:00| 111test111| true| true|
5. |1970-01-01T08:00:00.003+08:00| 333test333| false| false|
6. +-----------------------------+-----------+-------------------------+--------------------------+
IS NULL 运算符
| 运算符 | 含义 |
|---|---|
IS NULL |
是空值 |
IS NOT NULL |
不是空值 |
示例 1： 选择值为空的数据:
1. select code from root.sg1.d1 where temperature is null;
示例 2： 选择值为非空的数据:
1. select code from root.sg1.d1 where temperature is not null;
IN 运算符
| 运算符 | 含义 |
|---|---|
IN / CONTAINS |
是指定列表中的值 |
NOT IN / NOT CONTAINS |
不是指定列表中的值 |
输入数据类型：All Types
返回类型 BOOLEAN
注意：请确保集合中的值可以被转为输入数据的类型。
例如：
s1 in (1, 2, 3, 'test')，s1的数据类型是INT32我们将会抛出异常，因为
'test'不能被转为INT32类型
示例 1： 选择值在特定范围内的数据：
1. select code from root.sg1.d1 where code in ('200', '300', '400', '500');
示例 2： 选择值在特定范围外的数据：
1. select code from root.sg1.d1 where code not in ('200', '300', '400', '500');
示例 3：
1. select a, a in (1, 2) from root.test;
输出2:
1. +-----------------------------+-----------+--------------------+
2. | Time|root.test.a|root.test.a IN (1,2)|
3. +-----------------------------+-----------+--------------------+
4. |1970-01-01T08:00:00.001+08:00| 1| true|
5. |1970-01-01T08:00:00.003+08:00| 3| false|
6. +-----------------------------+-----------+--------------------+
条件函数
条件函数针对每个数据点进行条件判断，返回布尔值。
| 函数名 | 可接收的输入序列类型 | 必要的属性参数 | 输出序列类型 | 功能类型 |
|---|---|---|---|---|
| ON_OFF | INT32 / INT64 / FLOAT / DOUBLE | threshold:DOUBLE类型 |
BOOLEAN 类型 | 返回ts_value >= threshold的bool值 |
| IN_RANGE | INT32 / INT64 / FLOAT / DOUBLE | lower: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. +-----------------------------+------------+--------------------------------------------------+
逻辑运算符
一元逻辑运算符
- 支持运算符：
! - 输入数据类型：
BOOLEAN。 - 输出数据类型：
BOOLEAN。 - 注意：
!的优先级很高，记得使用括号调整优先级。
二元逻辑运算符
-
支持运算符
-
AND:
and,&,&& - OR:
or,|,|| - 输入数据类型：
BOOLEAN。 - 返回类型
BOOLEAN。 - 注意：当某个时间戳下左操作数和右操作数都为
BOOLEAN类型时，二元逻辑操作才会有输出结果。
示例：
1. select a, b, a > 10, a <= b, !(a <= b), a > 10 && a > b from root.test;
运行结果
1. IoTDB> select a, b, a > 10, a <= b, !(a <= b), a > 10 && a > b from root.test;
2. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
3. | Time|root.test.a|root.test.b|root.test.a > 10|root.test.a <= root.test.b|!root.test.a <= root.test.b|(root.test.a > 10) & (root.test.a > root.test.b)|
4. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
5. |1970-01-01T08:00:00.001+08:00| 23| 10.0| true| false| true| true|
6. |1970-01-01T08:00:00.002+08:00| 33| 21.0| true| false| true| true|
7. |1970-01-01T08:00:00.004+08:00| 13| 15.0| true| true| false| false|
8. |1970-01-01T08:00:00.005+08:00| 26| 0.0| true| false| true| true|
9. |1970-01-01T08:00:00.008+08:00| 1| 22.0| false| true| false| false|
10. |1970-01-01T08:00:00.010+08:00| 23| 12.0| true| false| true| true|
11. +-----------------------------+-----------+-----------+----------------+--------------------------+---------------------------+------------------------------------------------+
字符串处理
STRING_CONTAINS
函数简介
本函数判断字符串中是否存在子串 s
函数名: STRING_CONTAINS
输入序列: 仅支持单个输入序列，类型为 TEXT。
参数:
s: 待搜寻的字符串。
输出序列: 输出单个序列，类型为 BOOLEAN。
使用示例
1. select s1, string_contains(s1, 's'='warn') from root.sg1.d4;
结果：
1. +-----------------------------+--------------+-------------------------------------------+
2. | Time|root.sg1.d4.s1|string_contains(root.sg1.d4.s1, "s"="warn")|
3. +-----------------------------+--------------+-------------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| warn:-8721| true|
5. |1970-01-01T08:00:00.002+08:00| error:-37229| false|
6. |1970-01-01T08:00:00.003+08:00| warn:1731| true|
7. +-----------------------------+--------------+-------------------------------------------+
8. Total line number = 3
9. It costs 0.007s
STRING_MATCHES
函数简介
本函数判断字符串是否能够被正则表达式regex匹配。
函数名: STRING_MATCHES
输入序列: 仅支持单个输入序列，类型为 TEXT。
参数:
regex: Java 标准库风格的正则表达式。
输出序列: 输出单个序列，类型为 BOOLEAN。
使用示例
1. select s1, string_matches(s1, 'regex'='[^\\s]+37229') from root.sg1.d4;
结果：
1. +-----------------------------+--------------+------------------------------------------------------+
2. | Time|root.sg1.d4.s1|string_matches(root.sg1.d4.s1, "regex"="[^\\s]+37229")|
3. +-----------------------------+--------------+------------------------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| warn:-8721| false|
5. |1970-01-01T08:00:00.002+08:00| error:-37229| true|
6. |1970-01-01T08:00:00.003+08:00| warn:1731| false|
7. +-----------------------------+--------------+------------------------------------------------------+
8. Total line number = 3
9. It costs 0.007s
Length
函数简介
本函数用于获取输入序列的长度。
函数名: LENGTH
输入序列: 仅支持单个输入序列，类型为 TEXT。
输出序列: 输出单个序列，类型为 INT32。
提示: 如果输入是NULL，返回NULL。
使用示例
输入序列:
1. +-----------------------------+--------------+
2. | Time|root.sg1.d1.s1|
3. +-----------------------------+--------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1|
5. |1970-01-01T08:00:00.002+08:00| 22test22|
6. +-----------------------------+--------------+
用于查询的 SQL 语句:
1. select s1, length(s1) from root.sg1.d1
输出序列:
1. +-----------------------------+--------------+----------------------+
2. | Time|root.sg1.d1.s1|length(root.sg1.d1.s1)|
3. +-----------------------------+--------------+----------------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1| 6|
5. |1970-01-01T08:00:00.002+08:00| 22test22| 8|
6. +-----------------------------+--------------+----------------------+
Locate
函数简介
本函数用于获取target子串第一次出现在输入序列的位置，如果输入序列中不包含target则返回 -1 。
函数名: LOCATE
输入序列: 仅支持单个输入序列，类型为 TEXT。
参数:
target: 需要被定位的子串。reverse: 指定是否需要倒序定位，默认值为false, 即从左至右定位。
输出序列: 输出单个序列，类型为INT32。
提示: 下标从 0 开始。
使用示例
输入序列:
1. +-----------------------------+--------------+
2. | Time|root.sg1.d1.s1|
3. +-----------------------------+--------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1|
5. |1970-01-01T08:00:00.002+08:00| 22test22|
6. +-----------------------------+--------------+
用于查询的 SQL 语句:
1. select s1, locate(s1, "target"="1") from root.sg1.d1
输出序列:
1. +-----------------------------+--------------+------------------------------------+
2. | Time|root.sg1.d1.s1|locate(root.sg1.d1.s1, "target"="1")|
3. +-----------------------------+--------------+------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1| 0|
5. |1970-01-01T08:00:00.002+08:00| 22test22| -1|
6. +-----------------------------+--------------+------------------------------------+
另一个用于查询的 SQL 语句:
1. select s1, locate(s1, "target"="1", "reverse"="true") from root.sg1.d1
输出序列:
1. +-----------------------------+--------------+------------------------------------------------------+
2. | Time|root.sg1.d1.s1|locate(root.sg1.d1.s1, "target"="1", "reverse"="true")|
3. +-----------------------------+--------------+------------------------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1| 5|
5. |1970-01-01T08:00:00.002+08:00| 22test22| -1|
6. +-----------------------------+--------------+------------------------------------------------------+
StartsWith
函数简介
本函数用于判断输入序列是否有指定前缀。
函数名: STARTSWITH
输入序列: 仅支持单个输入序列，类型为 TEXT。
参数:
target: 需要匹配的前缀。
输出序列: 输出单个序列，类型为 BOOLEAN。
提示: 如果输入是NULL，返回NULL。
使用示例
输入序列:
1. +-----------------------------+--------------+
2. | Time|root.sg1.d1.s1|
3. +-----------------------------+--------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1|
5. |1970-01-01T08:00:00.002+08:00| 22test22|
6. +-----------------------------+--------------+
用于查询的 SQL 语句:
1. select s1, startswith(s1, "target"="1") from root.sg1.d1
输出序列:
1. +-----------------------------+--------------+----------------------------------------+
2. | Time|root.sg1.d1.s1|startswith(root.sg1.d1.s1, "target"="1")|
3. +-----------------------------+--------------+----------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1| true|
5. |1970-01-01T08:00:00.002+08:00| 22test22| false|
6. +-----------------------------+--------------+----------------------------------------+
EndsWith
函数简介
本函数用于判断输入序列是否有指定后缀。
函数名: ENDSWITH
输入序列: 仅支持单个输入序列，类型为 TEXT。
参数:
target: 需要匹配的后缀。
输出序列: 输出单个序列，类型为 BOOLEAN。
提示: 如果输入是NULL，返回NULL。
使用示例
输入序列:
1. +-----------------------------+--------------+
2. | Time|root.sg1.d1.s1|
3. +-----------------------------+--------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1|
5. |1970-01-01T08:00:00.002+08:00| 22test22|
6. +-----------------------------+--------------+
用于查询的 SQL 语句:
1. select s1, endswith(s1, "target"="1") from root.sg1.d1
输出序列:
1. +-----------------------------+--------------+--------------------------------------+
2. | Time|root.sg1.d1.s1|endswith(root.sg1.d1.s1, "target"="1")|
3. +-----------------------------+--------------+--------------------------------------+
4. |1970-01-01T08:00:00.001+08:00| 1test1| true|
5. |1970-01-01T08:00:00.002+08:00| 22test22| false|
6. +-----------------------------+--------------+--------------------------------------+
Concat
函数简介
本函数用于拼接输入序列和target字串。
函数名: CONCAT
输入序列: 至少一个输入序列，类型为 TEXT。
参数:
targets: 一系列 K-V, key需要以target为前缀且不重复, value是待拼接的字符串。series_behind: 指定拼接时时间序列是否在后面，默认为false。
输出序列: 输出单个序列，类型为 TEXT。
提示:
- 如果输入序列是NULL, 跳过该序列的拼接。
- 函数只能将输入序列和
targets区分开各自拼接。concat(s1, "target1"="IoT", s2, "target2"="DB")和concat(s1, s2, "target1"="IoT", "target2"="DB")得到的结果是一样的。
使用示例
输入序列:
``` 1. +-----------------------------+--------------+--------------+ 2. |
（本文超出站点单文档体积上限，已截断）
