UDF函数库

基于用户自定义函数能力，IoTDB 提供了一系列关于时序数据处理的函数，包括数据质量、数据画像、异常检测、 频域分析、数据匹配、数据修复、序列发现、机器学习等，能够满足工业领域对时序数据处理的需求。

注意：当前UDF函数库中的函数仅支持毫秒级的时间戳精度。

安装步骤

  1. 请获取与 IoTDB 版本兼容的 UDF 函数库 JAR 包的压缩包。
UDF 安装包 支持的 IoTDB 版本 下载链接
apache-UDF-1.3.3.zip V1.3.3及以上 请联系天谋商务获取
apache-UDF-1.3.2.zip V1.0.0～V1.3.2 请联系天谋商务获取
2. 将获取的压缩包中的 library-udf.jar 文件放置在 IoTDB 集群所有节点的 /ext/udf 的目录下
3. 在 IoTDB 的 SQL 命令行终端（CLI）的 SQL 操作界面中，执行下述相应的函数注册语句。
4. 批量注册：两种注册方式：注册脚本 或 SQL汇总语句

  • 注册脚本

  • 将压缩包中的注册脚本（register-UDF.sh 或 register-UDF.bat）按需复制到 IoTDB 的 tools 目录下，修改脚本中的参数（默认为host=127.0.0.1，rpcPort=6667，user=root，pass=root）；

  • 启动 IoTDB 服务，运行注册脚本批量注册 UDF

  • SQL汇总语句

  • 打开压缩包中的SQl文件，复制全部 SQL 语句，在 IoTDB 的 SQL 命令行终端（CLI）的 SQL 操作界面中，执行全部 SQl 语句批量注册 UDF

数据质量

Completeness

注册语句

1. create function completeness as 'org.apache.iotdb.library.dquality.UDTFCompleteness'

函数简介

本函数用于计算时间序列的完整性。将输入序列划分为若干个连续且不重叠的窗口，分别计算每一个窗口的完整性，并输出窗口第一个数据点的时间戳和窗口的完整性。

函数名： COMPLETENESS

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • window：窗口大小，它是一个大于0的整数或者一个有单位的正数。前者代表每一个窗口包含的数据点数目，最后一个窗口的数据点数目可能会不足；后者代表窗口的时间跨度，目前支持五种单位，分别是’ms’（毫秒）、’s’（秒）、’m’（分钟）、’h’（小时）和’d’（天）。缺省情况下，全部输入数据都属于同一个窗口。
  • downtime：完整性计算是否考虑停机异常。它的取值为 ‘true’ 或 ‘false’，默认值为 ‘true’. 在考虑停机异常时，长时间的数据缺失将被视作停机，不对完整性产生影响。

输出序列： 输出单个序列，类型为DOUBLE，其中每一个数据点的值的范围都是 [0,1].

提示： 只有当窗口内的数据点数目超过10时，才会进行完整性计算。否则，该窗口将被忽略，不做任何输出。

使用示例

参数缺省

在参数缺省的情况下，本函数将会把全部输入数据都作为同一个窗口计算完整性。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. +-----------------------------+---------------+

用于查询的SQL语句：

1. select completeness(s1) from root.test.d1 where time <= 2020-01-01 00:00:30

输出序列：

1. +-----------------------------+-----------------------------+
2. |                         Time|completeness(root.test.d1.s1)|
3. +-----------------------------+-----------------------------+
4. |2020-01-01T00:00:02.000+08:00|                        0.875|
5. +-----------------------------+-----------------------------+
指定窗口大小

在指定窗口大小的情况下，本函数会把输入数据划分为若干个窗口计算完整性。

输入序列:

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. |2020-01-01T00:00:32.000+08:00|          130.0|
20. |2020-01-01T00:00:34.000+08:00|          132.0|
21. |2020-01-01T00:00:36.000+08:00|          134.0|
22. |2020-01-01T00:00:38.000+08:00|          136.0|
23. |2020-01-01T00:00:40.000+08:00|          138.0|
24. |2020-01-01T00:00:42.000+08:00|          140.0|
25. |2020-01-01T00:00:44.000+08:00|          142.0|
26. |2020-01-01T00:00:46.000+08:00|          144.0|
27. |2020-01-01T00:00:48.000+08:00|          146.0|
28. |2020-01-01T00:00:50.000+08:00|          148.0|
29. |2020-01-01T00:00:52.000+08:00|          150.0|
30. |2020-01-01T00:00:54.000+08:00|          152.0|
31. |2020-01-01T00:00:56.000+08:00|          154.0|
32. |2020-01-01T00:00:58.000+08:00|          156.0|
33. |2020-01-01T00:01:00.000+08:00|          158.0|
34. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select completeness(s1,"window"="15") from root.test.d1 where time <= 2020-01-01 00:01:00

输出序列：

1. +-----------------------------+--------------------------------------------+
2. |                         Time|completeness(root.test.d1.s1, "window"="15")|
3. +-----------------------------+--------------------------------------------+
4. |2020-01-01T00:00:02.000+08:00|                                       0.875|
5. |2020-01-01T00:00:32.000+08:00|                                         1.0|
6. +-----------------------------+--------------------------------------------+

Consistency

注册语句

1. create function consistency as 'org.apache.iotdb.library.dquality.UDTFConsistency'

函数简介

本函数用于计算时间序列的一致性。将输入序列划分为若干个连续且不重叠的窗口，分别计算每一个窗口的一致性，并输出窗口第一个数据点的时间戳和窗口的时效性。

函数名： CONSISTENCY

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE

参数：

  • window：窗口大小，它是一个大于0的整数或者一个有单位的正数。前者代表每一个窗口包含的数据点数目，最后一个窗口的数据点数目可能会不足；后者代表窗口的时间跨度，目前支持五种单位，分别是 ‘ms’（毫秒）、’s’（秒）、’m’（分钟）、’h’（小时）和’d’（天）。缺省情况下，全部输入数据都属于同一个窗口。

输出序列： 输出单个序列，类型为DOUBLE，其中每一个数据点的值的范围都是 [0,1].

提示： 只有当窗口内的数据点数目超过10时，才会进行一致性计算。否则，该窗口将被忽略，不做任何输出。

使用示例

参数缺省

在参数缺省的情况下，本函数将会把全部输入数据都作为同一个窗口计算一致性。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. +-----------------------------+---------------+

用于查询的SQL语句：

1. select consistency(s1) from root.test.d1 where time <= 2020-01-01 00:00:30

输出序列：

1. +-----------------------------+----------------------------+
2. |                         Time|consistency(root.test.d1.s1)|
3. +-----------------------------+----------------------------+
4. |2020-01-01T00:00:02.000+08:00|          0.9333333333333333|
5. +-----------------------------+----------------------------+
指定窗口大小

在指定窗口大小的情况下，本函数会把输入数据划分为若干个窗口计算一致性。

输入序列:

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. |2020-01-01T00:00:32.000+08:00|          130.0|
20. |2020-01-01T00:00:34.000+08:00|          132.0|
21. |2020-01-01T00:00:36.000+08:00|          134.0|
22. |2020-01-01T00:00:38.000+08:00|          136.0|
23. |2020-01-01T00:00:40.000+08:00|          138.0|
24. |2020-01-01T00:00:42.000+08:00|          140.0|
25. |2020-01-01T00:00:44.000+08:00|          142.0|
26. |2020-01-01T00:00:46.000+08:00|          144.0|
27. |2020-01-01T00:00:48.000+08:00|          146.0|
28. |2020-01-01T00:00:50.000+08:00|          148.0|
29. |2020-01-01T00:00:52.000+08:00|          150.0|
30. |2020-01-01T00:00:54.000+08:00|          152.0|
31. |2020-01-01T00:00:56.000+08:00|          154.0|
32. |2020-01-01T00:00:58.000+08:00|          156.0|
33. |2020-01-01T00:01:00.000+08:00|          158.0|
34. +-----------------------------+---------------+

用于查询的SQL语句：

1. select consistency(s1,"window"="15") from root.test.d1 where time <= 2020-01-01 00:01:00

输出序列：

1. +-----------------------------+-------------------------------------------+
2. |                         Time|consistency(root.test.d1.s1, "window"="15")|
3. +-----------------------------+-------------------------------------------+
4. |2020-01-01T00:00:02.000+08:00|                         0.9333333333333333|
5. |2020-01-01T00:00:32.000+08:00|                                        1.0|
6. +-----------------------------+-------------------------------------------+

Timeliness

注册语句

1. create function timeliness as 'org.apache.iotdb.library.dquality.UDTFTimeliness'

函数简介

本函数用于计算时间序列的时效性。将输入序列划分为若干个连续且不重叠的窗口，分别计算每一个窗口的时效性，并输出窗口第一个数据点的时间戳和窗口的时效性。

函数名： TIMELINESS

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE

参数：

  • window：窗口大小，它是一个大于0的整数或者一个有单位的正数。前者代表每一个窗口包含的数据点数目，最后一个窗口的数据点数目可能会不足；后者代表窗口的时间跨度，目前支持五种单位，分别是 ‘ms’（毫秒）、’s’（秒）、’m’（分钟）、’h’（小时）和’d’（天）。缺省情况下，全部输入数据都属于同一个窗口。

输出序列： 输出单个序列，类型为DOUBLE，其中每一个数据点的值的范围都是 [0,1].

提示： 只有当窗口内的数据点数目超过10时，才会进行时效性计算。否则，该窗口将被忽略，不做任何输出。

使用示例

参数缺省

在参数缺省的情况下，本函数将会把全部输入数据都作为同一个窗口计算时效性。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. +-----------------------------+---------------+

用于查询的SQL语句：

1. select timeliness(s1) from root.test.d1 where time <= 2020-01-01 00:00:30

输出序列：

1. +-----------------------------+---------------------------+
2. |                         Time|timeliness(root.test.d1.s1)|
3. +-----------------------------+---------------------------+
4. |2020-01-01T00:00:02.000+08:00|         0.9333333333333333|
5. +-----------------------------+---------------------------+
指定窗口大小

在指定窗口大小的情况下，本函数会把输入数据划分为若干个窗口计算时效性。

输入序列:

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. |2020-01-01T00:00:32.000+08:00|          130.0|
20. |2020-01-01T00:00:34.000+08:00|          132.0|
21. |2020-01-01T00:00:36.000+08:00|          134.0|
22. |2020-01-01T00:00:38.000+08:00|          136.0|
23. |2020-01-01T00:00:40.000+08:00|          138.0|
24. |2020-01-01T00:00:42.000+08:00|          140.0|
25. |2020-01-01T00:00:44.000+08:00|          142.0|
26. |2020-01-01T00:00:46.000+08:00|          144.0|
27. |2020-01-01T00:00:48.000+08:00|          146.0|
28. |2020-01-01T00:00:50.000+08:00|          148.0|
29. |2020-01-01T00:00:52.000+08:00|          150.0|
30. |2020-01-01T00:00:54.000+08:00|          152.0|
31. |2020-01-01T00:00:56.000+08:00|          154.0|
32. |2020-01-01T00:00:58.000+08:00|          156.0|
33. |2020-01-01T00:01:00.000+08:00|          158.0|
34. +-----------------------------+---------------+

用于查询的SQL语句：

1. select timeliness(s1,"window"="15") from root.test.d1 where time <= 2020-01-01 00:01:00

输出序列：

1. +-----------------------------+------------------------------------------+
2. |                         Time|timeliness(root.test.d1.s1, "window"="15")|
3. +-----------------------------+------------------------------------------+
4. |2020-01-01T00:00:02.000+08:00|                        0.9333333333333333|
5. |2020-01-01T00:00:32.000+08:00|                                       1.0|
6. +-----------------------------+------------------------------------------+

Validity

注册语句

1. create function validity as 'org.apache.iotdb.library.dquality.UDTFValidity'

函数简介

本函数用于计算时间序列的有效性。将输入序列划分为若干个连续且不重叠的窗口，分别计算每一个窗口的有效性，并输出窗口第一个数据点的时间戳和窗口的有效性。

函数名： VALIDITY

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE

参数：

  • window：窗口大小，它是一个大于0的整数或者一个有单位的正数。前者代表每一个窗口包含的数据点数目，最后一个窗口的数据点数目可能会不足；后者代表窗口的时间跨度，目前支持五种单位，分别是 ‘ms’（毫秒）、’s’（秒）、’m’（分钟）、’h’（小时）和’d’（天）。缺省情况下，全部输入数据都属于同一个窗口。

输出序列： 输出单个序列，类型为DOUBLE，其中每一个数据点的值的范围都是 [0,1].

提示： 只有当窗口内的数据点数目超过10时，才会进行有效性计算。否则，该窗口将被忽略，不做任何输出。

使用示例

参数缺省

在参数缺省的情况下，本函数将会把全部输入数据都作为同一个窗口计算有效性。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. +-----------------------------+---------------+

用于查询的SQL语句：

1. select validity(s1) from root.test.d1 where time <= 2020-01-01 00:00:30

输出序列：

1. +-----------------------------+-------------------------+
2. |                         Time|validity(root.test.d1.s1)|
3. +-----------------------------+-------------------------+
4. |2020-01-01T00:00:02.000+08:00|       0.8833333333333333|
5. +-----------------------------+-------------------------+
指定窗口大小

在指定窗口大小的情况下，本函数会把输入数据划分为若干个窗口计算有效性。

输入序列:

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:02.000+08:00|          100.0|
5. |2020-01-01T00:00:03.000+08:00|          101.0|
6. |2020-01-01T00:00:04.000+08:00|          102.0|
7. |2020-01-01T00:00:06.000+08:00|          104.0|
8. |2020-01-01T00:00:08.000+08:00|          126.0|
9. |2020-01-01T00:00:10.000+08:00|          108.0|
10. |2020-01-01T00:00:14.000+08:00|          112.0|
11. |2020-01-01T00:00:15.000+08:00|          113.0|
12. |2020-01-01T00:00:16.000+08:00|          114.0|
13. |2020-01-01T00:00:18.000+08:00|          116.0|
14. |2020-01-01T00:00:20.000+08:00|          118.0|
15. |2020-01-01T00:00:22.000+08:00|          120.0|
16. |2020-01-01T00:00:26.000+08:00|          124.0|
17. |2020-01-01T00:00:28.000+08:00|          126.0|
18. |2020-01-01T00:00:30.000+08:00|            NaN|
19. |2020-01-01T00:00:32.000+08:00|          130.0|
20. |2020-01-01T00:00:34.000+08:00|          132.0|
21. |2020-01-01T00:00:36.000+08:00|          134.0|
22. |2020-01-01T00:00:38.000+08:00|          136.0|
23. |2020-01-01T00:00:40.000+08:00|          138.0|
24. |2020-01-01T00:00:42.000+08:00|          140.0|
25. |2020-01-01T00:00:44.000+08:00|          142.0|
26. |2020-01-01T00:00:46.000+08:00|          144.0|
27. |2020-01-01T00:00:48.000+08:00|          146.0|
28. |2020-01-01T00:00:50.000+08:00|          148.0|
29. |2020-01-01T00:00:52.000+08:00|          150.0|
30. |2020-01-01T00:00:54.000+08:00|          152.0|
31. |2020-01-01T00:00:56.000+08:00|          154.0|
32. |2020-01-01T00:00:58.000+08:00|          156.0|
33. |2020-01-01T00:01:00.000+08:00|          158.0|
34. +-----------------------------+---------------+

用于查询的SQL语句：

1. select validity(s1,"window"="15") from root.test.d1 where time <= 2020-01-01 00:01:00

输出序列：

1. +-----------------------------+----------------------------------------+
2. |                         Time|validity(root.test.d1.s1, "window"="15")|
3. +-----------------------------+----------------------------------------+
4. |2020-01-01T00:00:02.000+08:00|                      0.8833333333333333|
5. |2020-01-01T00:00:32.000+08:00|                                     1.0|
6. +-----------------------------+----------------------------------------+

数据画像

ACF

注册语句

1. create function acf as 'org.apache.iotdb.library.dprofile.UDTFACF'

函数简介

本函数用于计算时间序列的自相关函数值，即序列与自身之间的互相关函数。

函数名： ACF

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

输出序列： 输出单个序列，类型为 DOUBLE。序列中共包含2N−12N-12N−1个数据点。

提示：

  • 序列中的NaN值会被忽略，在计算中表现为0。

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:01.000+08:00|              1|
5. |2020-01-01T00:00:02.000+08:00|            NaN|
6. |2020-01-01T00:00:03.000+08:00|              3|
7. |2020-01-01T00:00:04.000+08:00|            NaN|
8. |2020-01-01T00:00:05.000+08:00|              5|
9. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select acf(s1) from root.test.d1 where time <= 2020-01-01 00:00:05

输出序列：

1. +-----------------------------+--------------------+
2. |                         Time|acf(root.test.d1.s1)|
3. +-----------------------------+--------------------+
4. |1970-01-01T08:00:00.001+08:00|                 1.0|
5. |1970-01-01T08:00:00.002+08:00|                 0.0|
6. |1970-01-01T08:00:00.003+08:00|                 3.6|
7. |1970-01-01T08:00:00.004+08:00|                 0.0|
8. |1970-01-01T08:00:00.005+08:00|                 7.0|
9. |1970-01-01T08:00:00.006+08:00|                 0.0|
10. |1970-01-01T08:00:00.007+08:00|                 3.6|
11. |1970-01-01T08:00:00.008+08:00|                 0.0|
12. |1970-01-01T08:00:00.009+08:00|                 1.0|
13. +-----------------------------+--------------------+

Distinct

注册语句

1. create function distinct as 'org.apache.iotdb.library.dprofile.UDTFDistinct'

函数简介

本函数可以返回输入序列中出现的所有不同的元素。

函数名： DISTINCT

输入序列： 仅支持单个输入序列，类型可以是任意的

输出序列： 输出单个序列，类型与输入相同。

提示：

  • 输出序列的时间戳是无意义的。输出顺序是任意的。
  • 缺失值和空值将被忽略，但NaN不会被忽略。
  • 字符串区分大小写

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d2.s2|
3. +-----------------------------+---------------+
4. |2020-01-01T08:00:00.001+08:00|          Hello|
5. |2020-01-01T08:00:00.002+08:00|          hello|
6. |2020-01-01T08:00:00.003+08:00|          Hello|
7. |2020-01-01T08:00:00.004+08:00|          World|
8. |2020-01-01T08:00:00.005+08:00|          World|
9. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select distinct(s2) from root.test.d2

输出序列：

1. +-----------------------------+-------------------------+
2. |                         Time|distinct(root.test.d2.s2)|
3. +-----------------------------+-------------------------+
4. |1970-01-01T08:00:00.001+08:00|                    Hello|
5. |1970-01-01T08:00:00.002+08:00|                    hello|
6. |1970-01-01T08:00:00.003+08:00|                    World|
7. +-----------------------------+-------------------------+

Histogram

注册语句

1. create function histogram as 'org.apache.iotdb.library.dprofile.UDTFHistogram'

函数简介

本函数用于计算单列数值型数据的分布直方图。

函数名： HISTOGRAM

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • min：表示所求数据范围的下限，默认值为 -Double.MAX_VALUE。
  • max：表示所求数据范围的上限，默认值为 Double.MAX_VALUE，start的值必须小于或等于end。
  • count: 表示直方图分桶的数量，默认值为 1，其值必须为正整数。

输出序列： 直方图分桶的值，其中第 i 个桶（从 1 开始计数）表示的数据范围下界为min+(i−1)⋅max−mincountmin+ (i-1)\cdot\frac{max-min}{count}min+(i−1)⋅countmax−min​，数据范围上界为min+i⋅max−mincountmin+ i \cdot \frac{max-min}{count}min+i⋅countmax−min​。

提示：

  • 如果某个数据点的数值小于min，它会被放入第 1 个桶；如果某个数据点的数值大于max，它会被放入最后 1 个桶。
  • 数据中的空值、缺失值和NaN将会被忽略。

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:00.000+08:00|            1.0|
5. |2020-01-01T00:00:01.000+08:00|            2.0|
6. |2020-01-01T00:00:02.000+08:00|            3.0|
7. |2020-01-01T00:00:03.000+08:00|            4.0|
8. |2020-01-01T00:00:04.000+08:00|            5.0|
9. |2020-01-01T00:00:05.000+08:00|            6.0|
10. |2020-01-01T00:00:06.000+08:00|            7.0|
11. |2020-01-01T00:00:07.000+08:00|            8.0|
12. |2020-01-01T00:00:08.000+08:00|            9.0|
13. |2020-01-01T00:00:09.000+08:00|           10.0|
14. |2020-01-01T00:00:10.000+08:00|           11.0|
15. |2020-01-01T00:00:11.000+08:00|           12.0|
16. |2020-01-01T00:00:12.000+08:00|           13.0|
17. |2020-01-01T00:00:13.000+08:00|           14.0|
18. |2020-01-01T00:00:14.000+08:00|           15.0|
19. |2020-01-01T00:00:15.000+08:00|           16.0|
20. |2020-01-01T00:00:16.000+08:00|           17.0|
21. |2020-01-01T00:00:17.000+08:00|           18.0|
22. |2020-01-01T00:00:18.000+08:00|           19.0|
23. |2020-01-01T00:00:19.000+08:00|           20.0|
24. +-----------------------------+---------------+

用于查询的SQL语句：

1. select histogram(s1,"min"="1","max"="20","count"="10") from root.test.d1

输出序列：

1. +-----------------------------+---------------------------------------------------------------+
2. |                         Time|histogram(root.test.d1.s1, "min"="1", "max"="20", "count"="10")|
3. +-----------------------------+---------------------------------------------------------------+
4. |1970-01-01T08:00:00.000+08:00|                                                              2|
5. |1970-01-01T08:00:00.001+08:00|                                                              2|
6. |1970-01-01T08:00:00.002+08:00|                                                              2|
7. |1970-01-01T08:00:00.003+08:00|                                                              2|
8. |1970-01-01T08:00:00.004+08:00|                                                              2|
9. |1970-01-01T08:00:00.005+08:00|                                                              2|
10. |1970-01-01T08:00:00.006+08:00|                                                              2|
11. |1970-01-01T08:00:00.007+08:00|                                                              2|
12. |1970-01-01T08:00:00.008+08:00|                                                              2|
13. |1970-01-01T08:00:00.009+08:00|                                                              2|
14. +-----------------------------+---------------------------------------------------------------+

Integral

注册语句

1. create function integral as 'org.apache.iotdb.library.dprofile.UDAFIntegral'

函数简介

本函数用于计算时间序列的数值积分，即以时间为横坐标、数值为纵坐标绘制的折线图中折线以下的面积。

函数名： INTEGRAL

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • unit：积分求解所用的时间轴单位，取值为 “1S”, “1s”, “1m”, “1H”, “1d”（区分大小写），分别表示以毫秒、秒、分钟、小时、天为单位计算积分。 缺省情况下取 “1s”，以秒为单位。

输出序列： 输出单个序列，类型为 DOUBLE，序列仅包含一个时间戳为 0、值为积分结果的数据点。

提示：

  • 积分值等于折线图中每相邻两个数据点和时间轴形成的直角梯形的面积之和，不同时间单位下相当于横轴进行不同倍数放缩，得到的积分值可直接按放缩倍数转换。
  • 数据中NaN将会被忽略。折线将以临近两个有值数据点为准。

使用示例

参数缺省

缺省情况下积分以1s为时间单位。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:01.000+08:00|              1|
5. |2020-01-01T00:00:02.000+08:00|              2|
6. |2020-01-01T00:00:03.000+08:00|              5|
7. |2020-01-01T00:00:04.000+08:00|              6|
8. |2020-01-01T00:00:05.000+08:00|              7|
9. |2020-01-01T00:00:08.000+08:00|              8|
10. |2020-01-01T00:00:09.000+08:00|            NaN|
11. |2020-01-01T00:00:10.000+08:00|             10|
12. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select integral(s1) from root.test.d1 where time <= 2020-01-01 00:00:10

输出序列：

1. +-----------------------------+-------------------------+
2. |                         Time|integral(root.test.d1.s1)|
3. +-----------------------------+-------------------------+
4. |1970-01-01T08:00:00.000+08:00|                     57.5|
5. +-----------------------------+-------------------------+

其计算公式为：

12[(1+2)×1+(2+5)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]\=57.5\frac{1}{2}[(1+2)\times 1 + (2+5) \times 1 + (5+6) \times 1 + (6+7) \times 1 + (7+8) \times 3 + (8+10) \times 2] = 57.5 21​[(1+2)×1+(2+5)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]\=57.5

指定时间单位

指定以分钟为时间单位。

输入序列同上，用于查询的 SQL 语句如下：

1. select integral(s1, "unit"="1m") from root.test.d1 where time <= 2020-01-01 00:00:10

输出序列：

1. +-----------------------------+-------------------------+
2. |                         Time|integral(root.test.d1.s1)|
3. +-----------------------------+-------------------------+
4. |1970-01-01T08:00:00.000+08:00|                    0.958|
5. +-----------------------------+-------------------------+

其计算公式为：

12×60[(1+2)×1+(2+3)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]\=0.958\frac{1}{2\times 60}[(1+2) \times 1 + (2+3) \times 1 + (5+6) \times 1 + (6+7) \times 1 + (7+8) \times 3 + (8+10) \times 2] = 0.958 2×601​[(1+2)×1+(2+3)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]\=0.958

IntegralAvg

注册语句

1. create function integralavg as 'org.apache.iotdb.library.dprofile.UDAFIntegralAvg'

函数简介

本函数用于计算时间序列的函数均值，即在相同时间单位下的数值积分除以序列总的时间跨度。更多关于数值积分计算的信息请参考Integral函数。

函数名： INTEGRALAVG

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

输出序列： 输出单个序列，类型为 DOUBLE，序列仅包含一个时间戳为 0、值为时间加权平均结果的数据点。

提示：

  • 时间加权的平均值等于在任意时间单位unit下计算的数值积分（即折线图中每相邻两个数据点和时间轴形成的直角梯形的面积之和）， 除以相同时间单位下输入序列的时间跨度，其值与具体采用的时间单位无关，默认与 IoTDB 时间单位一致。
  • 数据中的NaN将会被忽略。折线将以临近两个有值数据点为准。
  • 输入序列为空时，函数输出结果为 0；仅有一个数据点时，输出结果为该点数值。

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:01.000+08:00|              1|
5. |2020-01-01T00:00:02.000+08:00|              2|
6. |2020-01-01T00:00:03.000+08:00|              5|
7. |2020-01-01T00:00:04.000+08:00|              6|
8. |2020-01-01T00:00:05.000+08:00|              7|
9. |2020-01-01T00:00:08.000+08:00|              8|
10. |2020-01-01T00:00:09.000+08:00|            NaN|
11. |2020-01-01T00:00:10.000+08:00|             10|
12. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select integralavg(s1) from root.test.d1 where time <= 2020-01-01 00:00:10

输出序列：

1. +-----------------------------+----------------------------+
2. |                         Time|integralavg(root.test.d1.s1)|
3. +-----------------------------+----------------------------+
4. |1970-01-01T08:00:00.000+08:00|                        5.75|
5. +-----------------------------+----------------------------+

其计算公式为：

12[(1+2)×1+(2+5)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]/10\=5.75\frac{1}{2}[(1+2)\times 1 + (2+5) \times 1 + (5+6) \times 1 + (6+7) \times 1 + (7+8) \times 3 + (8+10) \times 2] / 10 = 5.75 21​[(1+2)×1+(2+5)×1+(5+6)×1+(6+7)×1+(7+8)×3+(8+10)×2]/10\=5.75

Mad

注册语句

1. create function mad as 'org.apache.iotdb.library.dprofile.UDAFMad'

函数简介

本函数用于计算单列数值型数据的精确或近似绝对中位差，绝对中位差为所有数值与其中位数绝对偏移量的中位数。

如有数据集{1,3,3,5,5,6,7,8,9}{1,3,3,5,5,6,7,8,9}{1,3,3,5,5,6,7,8,9}，其中位数为5，所有数值与中位数的偏移量的绝对值为{0,0,1,2,2,2,3,4,4}{0,0,1,2,2,2,3,4,4}{0,0,1,2,2,2,3,4,4}，其中位数为2，故而原数据集的绝对中位差为2。

函数名： MAD

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • error：近似绝对中位差的基于数值的误差百分比，取值范围为 [0,1)，默认值为 0。如当error\=0.01 时，记精确绝对中位差为a，近似绝对中位差为b，不等式 0.99a≤b≤1.01a0.99a \le b \le 1.01a0.99a≤b≤1.01a 成立。当error\=0 时，计算结果为精确绝对中位差。

输出序列： 输出单个序列，类型为DOUBLE，序列仅包含一个时间戳为 0、值为绝对中位差的数据点。

提示： 数据中的空值、缺失值和NaN将会被忽略。

使用示例

精确查询

当error参数缺省或为0时，本函数计算精确绝对中位差。

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |1970-01-01T08:00:00.100+08:00|         0.0|
5. |1970-01-01T08:00:00.200+08:00|         0.0|
6. |1970-01-01T08:00:00.300+08:00|         1.0|
7. |1970-01-01T08:00:00.400+08:00|        -1.0|
8. |1970-01-01T08:00:00.500+08:00|         0.0|
9. |1970-01-01T08:00:00.600+08:00|         0.0|
10. |1970-01-01T08:00:00.700+08:00|        -2.0|
11. |1970-01-01T08:00:00.800+08:00|         2.0|
12. |1970-01-01T08:00:00.900+08:00|         0.0|
13. |1970-01-01T08:00:01.000+08:00|         0.0|
14. |1970-01-01T08:00:01.100+08:00|         1.0|
15. |1970-01-01T08:00:01.200+08:00|        -1.0|
16. |1970-01-01T08:00:01.300+08:00|        -1.0|
17. |1970-01-01T08:00:01.400+08:00|         1.0|
18. |1970-01-01T08:00:01.500+08:00|         0.0|
19. |1970-01-01T08:00:01.600+08:00|         0.0|
20. |1970-01-01T08:00:01.700+08:00|        10.0|
21. |1970-01-01T08:00:01.800+08:00|         2.0|
22. |1970-01-01T08:00:01.900+08:00|        -2.0|
23. |1970-01-01T08:00:02.000+08:00|         0.0|
24. +-----------------------------+------------+
25. ............
26. Total line number = 20

用于查询的 SQL 语句：

1. select mad(s1) from root.test

输出序列：

1. +-----------------------------+---------------------------------+
2. |                         Time|median(root.test.s1, "error"="0")|
3. +-----------------------------+---------------------------------+
4. |1970-01-01T08:00:00.000+08:00|                              0.0|
5. +-----------------------------+---------------------------------+
近似查询

当error参数取值不为 0 时，本函数计算近似绝对中位差。

输入序列同上，用于查询的 SQL 语句如下：

1. select mad(s1, "error"="0.01") from root.test

输出序列：

1. +-----------------------------+---------------------------------+
2. |                         Time|mad(root.test.s1, "error"="0.01")|
3. +-----------------------------+---------------------------------+
4. |1970-01-01T08:00:00.000+08:00|               0.9900000000000001|
5. +-----------------------------+---------------------------------+

Median

注册语句

1. create function median as 'org.apache.iotdb.library.dprofile.UDAFMedian'

函数简介

本函数用于计算单列数值型数据的精确或近似中位数。中位数是顺序排列的一组数据中居于中间位置的数；当序列有偶数个时，中位数为中间二者的平均数。

函数名： MEDIAN

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE

参数：

  • error：近似中位数的基于排名的误差百分比，取值范围 [0,1)，默认值为 0。如当error\=0.01 时，计算出的中位数的真实排名百分比在 0.49~0.51 之间。当error\=0 时，计算结果为精确中位数。

输出序列： 输出单个序列，类型为 DOUBLE，序列仅包含一个时间戳为 0、值为中位数的数据点。

使用示例

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |1970-01-01T08:00:00.100+08:00|         0.0|
5. |1970-01-01T08:00:00.200+08:00|         0.0|
6. |1970-01-01T08:00:00.300+08:00|         1.0|
7. |1970-01-01T08:00:00.400+08:00|        -1.0|
8. |1970-01-01T08:00:00.500+08:00|         0.0|
9. |1970-01-01T08:00:00.600+08:00|         0.0|
10. |1970-01-01T08:00:00.700+08:00|        -2.0|
11. |1970-01-01T08:00:00.800+08:00|         2.0|
12. |1970-01-01T08:00:00.900+08:00|         0.0|
13. |1970-01-01T08:00:01.000+08:00|         0.0|
14. |1970-01-01T08:00:01.100+08:00|         1.0|
15. |1970-01-01T08:00:01.200+08:00|        -1.0|
16. |1970-01-01T08:00:01.300+08:00|        -1.0|
17. |1970-01-01T08:00:01.400+08:00|         1.0|
18. |1970-01-01T08:00:01.500+08:00|         0.0|
19. |1970-01-01T08:00:01.600+08:00|         0.0|
20. |1970-01-01T08:00:01.700+08:00|        10.0|
21. |1970-01-01T08:00:01.800+08:00|         2.0|
22. |1970-01-01T08:00:01.900+08:00|        -2.0|
23. |1970-01-01T08:00:02.000+08:00|         0.0|
24. +-----------------------------+------------+
25. Total line number = 20

用于查询的 SQL 语句：

1. select median(s1, "error"="0.01") from root.test

输出序列：

1. +-----------------------------+------------------------------------+
2. |                         Time|median(root.test.s1, "error"="0.01")|
3. +-----------------------------+------------------------------------+
4. |1970-01-01T08:00:00.000+08:00|                                 0.0|
5. +-----------------------------+------------------------------------+

MinMax

注册语句

1. create function minmax as 'org.apache.iotdb.library.dprofile.UDTFMinMax'

函数简介

本函数将输入序列使用 min-max 方法进行标准化。最小值归一至 0，最大值归一至 1.

函数名： MINMAX

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • compute：若设置为”batch”，则将数据全部读入后转换；若设置为 “stream”，则需用户提供最大值及最小值进行流式计算转换。默认为 “batch”。
  • min：使用流式计算时的最小值。
  • max：使用流式计算时的最大值。

输出序列：输出单个序列，类型为 DOUBLE。

使用示例

全数据计算

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |1970-01-01T08:00:00.100+08:00|         0.0|
5. |1970-01-01T08:00:00.200+08:00|         0.0|
6. |1970-01-01T08:00:00.300+08:00|         1.0|
7. |1970-01-01T08:00:00.400+08:00|        -1.0|
8. |1970-01-01T08:00:00.500+08:00|         0.0|
9. |1970-01-01T08:00:00.600+08:00|         0.0|
10. |1970-01-01T08:00:00.700+08:00|        -2.0|
11. |1970-01-01T08:00:00.800+08:00|         2.0|
12. |1970-01-01T08:00:00.900+08:00|         0.0|
13. |1970-01-01T08:00:01.000+08:00|         0.0|
14. |1970-01-01T08:00:01.100+08:00|         1.0|
15. |1970-01-01T08:00:01.200+08:00|        -1.0|
16. |1970-01-01T08:00:01.300+08:00|        -1.0|
17. |1970-01-01T08:00:01.400+08:00|         1.0|
18. |1970-01-01T08:00:01.500+08:00|         0.0|
19. |1970-01-01T08:00:01.600+08:00|         0.0|
20. |1970-01-01T08:00:01.700+08:00|        10.0|
21. |1970-01-01T08:00:01.800+08:00|         2.0|
22. |1970-01-01T08:00:01.900+08:00|        -2.0|
23. |1970-01-01T08:00:02.000+08:00|         0.0|
24. +-----------------------------+------------+

用于查询的 SQL 语句：

1. select minmax(s1) from root.test

输出序列：

1. +-----------------------------+--------------------+
2. |                         Time|minmax(root.test.s1)|
3. +-----------------------------+--------------------+
4. |1970-01-01T08:00:00.100+08:00| 0.16666666666666666|
5. |1970-01-01T08:00:00.200+08:00| 0.16666666666666666|
6. |1970-01-01T08:00:00.300+08:00|                0.25|
7. |1970-01-01T08:00:00.400+08:00| 0.08333333333333333|
8. |1970-01-01T08:00:00.500+08:00| 0.16666666666666666|
9. |1970-01-01T08:00:00.600+08:00| 0.16666666666666666|
10. |1970-01-01T08:00:00.700+08:00|                 0.0|
11. |1970-01-01T08:00:00.800+08:00|  0.3333333333333333|
12. |1970-01-01T08:00:00.900+08:00| 0.16666666666666666|
13. |1970-01-01T08:00:01.000+08:00| 0.16666666666666666|
14. |1970-01-01T08:00:01.100+08:00|                0.25|
15. |1970-01-01T08:00:01.200+08:00| 0.08333333333333333|
16. |1970-01-01T08:00:01.300+08:00| 0.08333333333333333|
17. |1970-01-01T08:00:01.400+08:00|                0.25|
18. |1970-01-01T08:00:01.500+08:00| 0.16666666666666666|
19. |1970-01-01T08:00:01.600+08:00| 0.16666666666666666|
20. |1970-01-01T08:00:01.700+08:00|                 1.0|
21. |1970-01-01T08:00:01.800+08:00|  0.3333333333333333|
22. |1970-01-01T08:00:01.900+08:00|                 0.0|
23. |1970-01-01T08:00:02.000+08:00| 0.16666666666666666|
24. +-----------------------------+--------------------+

MvAvg

注册语句

1. create function mvavg as 'org.apache.iotdb.library.dprofile.UDTFMvAvg'

函数简介

本函数计算序列的移动平均。

函数名： MVAVG

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • window：移动窗口的长度。默认值为 10.

输出序列：输出单个序列，类型为 DOUBLE。

使用示例

指定窗口长度

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |1970-01-01T08:00:00.100+08:00|         0.0|
5. |1970-01-01T08:00:00.200+08:00|         0.0|
6. |1970-01-01T08:00:00.300+08:00|         1.0|
7. |1970-01-01T08:00:00.400+08:00|        -1.0|
8. |1970-01-01T08:00:00.500+08:00|         0.0|
9. |1970-01-01T08:00:00.600+08:00|         0.0|
10. |1970-01-01T08:00:00.700+08:00|        -2.0|
11. |1970-01-01T08:00:00.800+08:00|         2.0|
12. |1970-01-01T08:00:00.900+08:00|         0.0|
13. |1970-01-01T08:00:01.000+08:00|         0.0|
14. |1970-01-01T08:00:01.100+08:00|         1.0|
15. |1970-01-01T08:00:01.200+08:00|        -1.0|
16. |1970-01-01T08:00:01.300+08:00|        -1.0|
17. |1970-01-01T08:00:01.400+08:00|         1.0|
18. |1970-01-01T08:00:01.500+08:00|         0.0|
19. |1970-01-01T08:00:01.600+08:00|         0.0|
20. |1970-01-01T08:00:01.700+08:00|        10.0|
21. |1970-01-01T08:00:01.800+08:00|         2.0|
22. |1970-01-01T08:00:01.900+08:00|        -2.0|
23. |1970-01-01T08:00:02.000+08:00|         0.0|
24. +-----------------------------+------------+

用于查询的 SQL 语句：

1. select mvavg(s1, "window"="3") from root.test

输出序列：

1. +-----------------------------+---------------------------------+
2. |                         Time|mvavg(root.test.s1, "window"="3")|
3. +-----------------------------+---------------------------------+
4. |1970-01-01T08:00:00.300+08:00|               0.3333333333333333|
5. |1970-01-01T08:00:00.400+08:00|                              0.0|
6. |1970-01-01T08:00:00.500+08:00|              -0.3333333333333333|
7. |1970-01-01T08:00:00.600+08:00|                              0.0|
8. |1970-01-01T08:00:00.700+08:00|              -0.6666666666666666|
9. |1970-01-01T08:00:00.800+08:00|                              0.0|
10. |1970-01-01T08:00:00.900+08:00|               0.6666666666666666|
11. |1970-01-01T08:00:01.000+08:00|                              0.0|
12. |1970-01-01T08:00:01.100+08:00|               0.3333333333333333|
13. |1970-01-01T08:00:01.200+08:00|                              0.0|
14. |1970-01-01T08:00:01.300+08:00|              -0.6666666666666666|
15. |1970-01-01T08:00:01.400+08:00|                              0.0|
16. |1970-01-01T08:00:01.500+08:00|               0.3333333333333333|
17. |1970-01-01T08:00:01.600+08:00|                              0.0|
18. |1970-01-01T08:00:01.700+08:00|               3.3333333333333335|
19. |1970-01-01T08:00:01.800+08:00|                              4.0|
20. |1970-01-01T08:00:01.900+08:00|                              0.0|
21. |1970-01-01T08:00:02.000+08:00|              -0.6666666666666666|
22. +-----------------------------+---------------------------------+

PACF

注册语句

1. create function pacf as 'org.apache.iotdb.library.dprofile.UDTFPACF'

函数简介

本函数通过求解 Yule-Walker 方程，计算序列的偏自相关系数。对于特殊的输入序列，方程可能没有解，此时输出NaN。

函数名： PACF

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • lag：最大滞后阶数。默认值为min⁡(10log⁡10n,n−1)\min(10\log_{10}n,n-1)min(10log10​n,n−1)，nnn表示数据点个数。

输出序列：输出单个序列，类型为 DOUBLE。

使用示例

指定滞后阶数

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:01.000+08:00|              1|
5. |2020-01-01T00:00:02.000+08:00|            NaN|
6. |2020-01-01T00:00:03.000+08:00|              3|
7. |2020-01-01T00:00:04.000+08:00|            NaN|
8. |2020-01-01T00:00:05.000+08:00|              5|
9. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select pacf(s1, "lag"="5") from root.test.d1

输出序列：

1. +-----------------------------+--------------------------------+
2. |                         Time|pacf(root.test.d1.s1, "lag"="5")|
3. +-----------------------------+--------------------------------+
4. |2020-01-01T00:00:01.000+08:00|                             1.0|
5. |2020-01-01T00:00:02.000+08:00|             -0.5744680851063829|
6. |2020-01-01T00:00:03.000+08:00|              0.3172297297297296|
7. |2020-01-01T00:00:04.000+08:00|             -0.2977686586304181|
8. |2020-01-01T00:00:05.000+08:00|             -2.0609033521065867|
9. +-----------------------------+--------------------------------+

Percentile

注册语句

1. create function percentile as 'org.apache.iotdb.library.dprofile.UDAFPercentile'

函数简介

本函数用于计算单列数值型数据的精确或近似分位数。

函数名： PERCENTILE

输入序列： 仅支持单个输入序列，类型为 INT32 / INT64 / FLOAT / DOUBLE。

参数：

  • rank：所求分位数在所有数据中的排名百分比，取值范围为 (0,1]，默认值为 0.5。如当设为 0.5时则计算中位数。
  • error：近似分位数的基于排名的误差百分比，取值范围为 [0,1)，默认值为0。如rank\=0.5 且error\=0.01，则计算出的分位数的真实排名百分比在 0.49~0.51之间。当error\=0 时，计算结果为精确分位数。

输出序列： 输出单个序列，类型与输入序列相同。当error\=0时，序列仅包含一个时间戳为分位数第一次出现的时间戳、值为分位数的数据点；否则，输出值的时间戳为0。

提示： 数据中的空值、缺失值和NaN将会被忽略。

使用示例

输入序列：

``` 1. +-----------------------------+------------+ 2. | Time|root.test.s0| 3. +-----------------------------+------------+ 4. |2021-03-17T10:32:17.054+08:00| 0.5319929| 5. |2021-03-17T10:32:18.054+08:00| 0.9304316| 6. |2021-03-17T10:32:19.054+08:00| -1.4800133| 7. |2021-03-17T10:32:20.054+08:00| 0.6114087| 8. |2021-03-17T10:32:21.054+08:00| 2.5163336| 9. |2021-03-17T10:32:22.054+08:00| -1.0845392| 10. |2021-03-17T10:32:23.054+08:00| 1.0562582| 11. |2021-03-17T10:32:24.054+08:00| 1.3867859| 12. |2021-03-17T10:32:25.054+08:00| -0.45429882| 13. |2021-03-17T10:32:26.054+08:00| 1.0353678| 14. |2021-03-17T10:32:27.054+08:00| 0.7307929| 15. |2021-03-17T10:32:28.054+08:00| 2.3167255| 16. |2021-03-17T10:32:29.054+08:00| 2.342443| 17. |2021-03-17T10:32:30.054+08:00| 1.5809103| 18. |2021-03-17T10:32:31.054+08:00| 1.4829416| 19. |2021-03-17T10:32:32.054+08:00| 1.5800357| 20. |2021-03-17T10:32:33.054+08:00| 0.7124368| 21. |2021-03-17T10:32:34.054+08:00| -0.78597564| 22. |2021-03-17T10:32:35.054+08:00| 1.2058644| 23. |2021-03-17T1

（本文超出站点单文档体积上限，已截断）