数据质量

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. +-----------------------------+---------------------------------------------------------------------------------------+