数据质量函数库
- 数据质量
- 数据画像
  - ACF
    - 函数简介
    - 使用示例
  - Distinct
    - 函数简介
    - 使用示例
  - Histogram
    - 函数简介
    - 使用示例
  - Integral
    - 函数简介
    - 使用示例
      - 参数缺省
      - 指定时间单位
  - IntegralAvg
    - 函数简介
    - 使用示例
  - Mad
    - 函数简介
    - 使用示例
      - 精确查询
      - 近似查询
  - Median
    - 函数简介
    - 使用示例
  - MinMax
    - 函数简介
    - 使用示例
      - 全数据计算
  - Mode
    - 函数简介
    - 使用示例
  - MvAvg
    - 函数简介
    - 使用示例
      - 指定窗口长度
  - PACF
    - 函数简介
    - 使用示例
      - 指定滞后阶数

数据质量函数库

数据质量

Completeness

函数简介

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

函数名： 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

函数简介

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

函数名： 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

函数简介

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

函数名： 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

函数简介

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

函数名： 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. +-----------------------------+----------------------------------------+

Accuracy

函数简介

本函数基于主数据计算原始时间序列的准确性。

函数名：Accuracy

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

参数：

omega：算法窗口大小，非负整数（单位为毫秒），在缺省情况下，算法根据不同时间差下的两个元组距离自动估计该参数。
eta：算法距离阈值，正数，在缺省情况下，算法根据窗口中元组的距离分布自动估计该参数。
k：主数据中的近邻数量，正整数，在缺省情况下，算法根据主数据中的k个近邻的元组距离自动估计该参数。

输出序列：输出单个值，类型为DOUBLE，值的范围为[0,1]。

使用示例

输入序列：

1. +-----------------------------+------------+------------+------------+------------+------------+------------+
2. |                         Time|root.test.t1|root.test.t2|root.test.t3|root.test.m1|root.test.m2|root.test.m3|
3. +-----------------------------+------------+------------+------------+------------+------------+------------+
4. |2021-07-01T12:00:01.000+08:00|        1704|     1154.55|       0.195|        1704|     1154.55|       0.195|
5. |2021-07-01T12:00:02.000+08:00|        1702|     1152.30|       0.193|        1702|     1152.30|       0.193|
6. |2021-07-01T12:00:03.000+08:00|        1702|     1148.65|       0.192|        1702|     1148.65|       0.192|
7. |2021-07-01T12:00:04.000+08:00|        1701|     1145.20|       0.194|        1701|     1145.20|       0.194|
8. |2021-07-01T12:00:07.000+08:00|        1703|     1150.55|       0.195|        1703|     1150.55|       0.195|
9. |2021-07-01T12:00:08.000+08:00|        1694|     1151.55|       0.193|        1704|     1151.55|       0.193|
10. |2021-07-01T12:01:09.000+08:00|        1705|     1153.55|       0.194|        1705|     1153.55|       0.194|
11. |2021-07-01T12:01:10.000+08:00|        1706|     1152.30|       0.190|        1706|     1152.30|       0.190|
12. +-----------------------------+------------+------------+------------+------------+------------+------------+

用于查询的 SQL 语句：

1. select Accuracy(t1,t2,t3,m1,m2,m3) from root.test

输出序列：

1. +-----------------------------+---------------------------------------------------------------------------------------+
2. |                         Time|Accuracy(root.test.t1,root.test.t2,root.test.t3,root.test.m1,root.test.m2,root.test.m3)|
3. +-----------------------------+---------------------------------------------------------------------------------------+
4. |2021-07-01T12:00:01.000+08:00|                                                                                  0.875|
5. +-----------------------------+---------------------------------------------------------------------------------------+

数据画像

ACF

函数简介

本函数用于计算时间序列的自相关函数值，即序列与自身之间的互相关函数，详情参见XCorr函数文档。

函数名： ACF

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

输出序列： 输出单个序列，类型为 DOUBLE。序列中共包含2N−12N-12N−1个数据点，每个值的具体含义参见XCorr函数文档。

提示：

序列中的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

函数简介

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

函数名： 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

函数简介

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

函数名： 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

函数简介

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

函数名： 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

函数简介

本函数用于计算时间序列的函数均值，即在相同时间单位下的数值积分除以序列总的时间跨度。更多关于数值积分计算的信息请参考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,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.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-17T10:32:36.054+08:00|   1.4215064|
24. |2021-03-17T10:32:37.054+08:00|   1.2808295|
25. |2021-03-17T10:32:38.054+08:00|  -0.6173715|
26. |2021-03-17T10:32:39.054+08:00|  0.06644377|
27. |2021-03-17T10:32:40.054+08:00|    2.349338|
28. |2021-03-17T10:32:41.054+08:00|   1.7335888|
29. |2021-03-17T10:32:42.054+08:00|   1.5872132|
30. ............
31. Total line number = 10000

用于查询的 SQL 语句：

1. select mad(s0) from root.test

输出序列：

1. +-----------------------------+------------------+
2. |                         Time| mad(root.test.s0)|
3. +-----------------------------+------------------+
4. |1970-01-01T08:00:00.000+08:00|0.6806197166442871|
5. +-----------------------------+------------------+

近似查询

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

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

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

输出序列：

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

Median

函数简介

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

函数名： 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.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-17T10:32:36.054+08:00|   1.4215064|
24. |2021-03-17T10:32:37.054+08:00|   1.2808295|
25. |2021-03-17T10:32:38.054+08:00|  -0.6173715|
26. |2021-03-17T10:32:39.054+08:00|  0.06644377|
27. |2021-03-17T10:32:40.054+08:00|    2.349338|
28. |2021-03-17T10:32:41.054+08:00|   1.7335888|
29. |2021-03-17T10:32:42.054+08:00|   1.5872132|
30. ............
31. Total line number = 10000

用于查询的 SQL 语句：

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

输出序列：

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

MinMax

函数简介

本函数将输入序列使用 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. +-----------------------------+--------------------+

Mode

函数简介

本函数用于计算时间序列的众数，即出现次数最多的元素。

函数名： MODE

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

输出序列： 输出单个序列，类型与输入相同，序列仅包含一个时间戳为众数第一次出现的时间戳、值为众数的数据点。

提示：

如果有多个出现次数最多的元素，将会输出任意一个。
数据中的空值和缺失值将会被忽略，但NaN不会被忽略。

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|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|          Hello|
7. |1970-01-01T08:00:00.004+08:00|          World|
8. |1970-01-01T08:00:00.005+08:00|          World|
9. |1970-01-01T08:00:01.600+08:00|          World|
10. |1970-01-15T09:37:34.451+08:00|          Hello|
11. |1970-01-15T09:37:34.452+08:00|          hello|
12. |1970-01-15T09:37:34.453+08:00|          Hello|
13. |1970-01-15T09:37:34.454+08:00|          World|
14. |1970-01-15T09:37:34.455+08:00|          World|
15. +-----------------------------+---------------+

用于查询的 SQL 语句：

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

输出序列：

1. +-----------------------------+---------------------+
2. |                         Time|mode(root.test.d2.s2)|
3. +-----------------------------+---------------------+
4. |1970-01-01T08:00:00.004+08:00|                World|
5. +-----------------------------+---------------------+

MvAvg

函数简介

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

函数名： 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

函数简介

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

函数名： PACF

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

参数：

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

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

使用示例

指定滞后阶数

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |2019-12-27T00:00:00.000+08:00|         5.0|
5. |2019-12-27T00:05:00.000+08:00|         5.0|
6. |2019-12-27T00:10:00.000+08:00|         5.0|
7. |2019-12-27T00:15:00.000+08:00|         5.0|
8. |2019-12-27T00:20:00.000+08:00|         6.0|
9. |2019-12-27T00:25:00.000+08:00|         5.0|
10. |2019-12-27T00:30:00.000+08:00|         6.0|
11. |2019-12-27T00:35:00.000+08:00|         6.0|
12. |2019-12-27T00:40:00.000+08:00|         6.0|
13. |2019-12-27T00:45:00.000+08:00|         6.0|
14. |2019-12-27T00:50:00.000+08:00|         6.0|
15. |2019-12-27T00:55:00.000+08:00|    5.982609|
16. |2019-12-27T01:00:00.000+08:00|   5.9652176|
17. |2019-12-27T01:05:00.000+08:00|    5.947826|
18. |2019-12-27T01:10:00.000+08:00|   5.9304347|
19. |2019-12-27T01:15:00.000+08:00|   5.9130435|
20. |2019-12-27T01:20:00.000+08:00|   5.8956523|
21. |2019-12-27T01:25:00.000+08:00|    5.878261|
22. |2019-12-27T01:30:00.000+08:00|   5.8608694|
23. |2019-12-27T01:35:00.000+08:00|    5.843478|
24. ............
25. Total line number = 18066

用于查询的 SQL 语句：

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

输出序列：

``` 1. +-----------------------------+-----------------------------+ 2. | Time|pacf(root.test.s1, "lag"="5")| 3. +-----------------------------+-----------------------------+ 4. |2019-

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

UDF 函数库

数据质量函数库

数据质量

Completeness

函数简介

使用示例

参数缺省

指定窗口大小

Consistency

函数简介

使用示例

参数缺省

指定窗口大小

Timeliness

函数简介

使用示例

参数缺省

指定窗口大小

Validity

函数简介

使用示例

参数缺省

指定窗口大小

Accuracy

函数简介

使用示例

数据画像

ACF

函数简介

使用示例

Distinct

函数简介

使用示例

Histogram

函数简介

使用示例

Integral

函数简介

使用示例

参数缺省

指定时间单位

IntegralAvg

函数简介

使用示例

Mad

函数简介

使用示例

精确查询

近似查询

Median

函数简介

使用示例

MinMax

函数简介

使用示例

全数据计算

Mode

函数简介

使用示例

MvAvg

函数简介

使用示例

指定窗口长度

PACF

函数简介

使用示例

指定滞后阶数