数据画像
- ACF
  - 函数简介
  - 使用示例
- Distinct
  - 函数简介
  - 使用示例
- Histogram
  - 函数简介
  - 使用示例
- Integral
- IntegralAvg
  - 函数简介
  - 使用示例
- Mad
  - 函数简介
  - 使用示例
    - 精确查询
    - 近似查询
- Median
  - 函数简介
  - 使用示例
- MinMax
  - 函数简介
  - 使用示例
    - 全数据计算
- Mode
  - 函数简介
  - 使用示例
- MvAvg
  - 函数简介
  - 使用示例
    - 指定窗口长度
- PACF
  - 函数简介
  - 使用示例
    - 指定滞后阶数
- Percentile
  - 函数简介
  - 使用示例
- Period
  - 函数简介
  - 使用示例
- QLB
  - 函数简介
  - 使用示例
    - 使用默认参数
- Resample
  - 函数简介
  - 使用示例
- Sample
  - 函数简介
  - 使用示例
    - 蓄水池采样
    - 等距采样
- Segment
  - 函数简介
  - 使用示例
- Skew
  - 函数简介
  - 使用示例
- Spline
  - 函数简介
  - 使用示例
    - 指定插值个数

数据画像

ACF

函数简介

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

函数名： ACF

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

输出序列： 输出单个序列，类型为 DOUBLE。序列中共包含$2N-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)\cdot\frac{max-min}{count}$，数据范围上界为$min+ i \cdot \frac{max-min}{count}$。

提示：

如果某个数据点的数值小于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. +-----------------------------+-------------------------+

其计算公式为： \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

指定时间单位

指定以分钟为时间单位。

输入序列同上，用于查询的 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. +-----------------------------+-------------------------+

其计算公式为： \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

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

其计算公式为： \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

Mad

函数简介

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

如有数据集${1,3,3,5,5,6,7,8,9}$，其中位数为5，所有数值与中位数的偏移量的绝对值为${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 \le b \le 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(10\log_{10}n,n-1)$，$n$表示数据点个数。

输出序列：输出单个序列，类型为 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-12-27T00:00:00.000+08:00|                          1.0|
5. |2019-12-27T00:05:00.000+08:00|           0.3528915091942786|
6. |2019-12-27T00:10:00.000+08:00|           0.1761346122516304|
7. |2019-12-27T00:15:00.000+08:00|           0.1492391973294682|
8. |2019-12-27T00:20:00.000+08:00|          0.03560059645868398|
9. |2019-12-27T00:25:00.000+08:00|           0.0366222998995286|
10. +-----------------------------+-----------------------------+

Percentile

函数简介

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

函数名： 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-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 percentile(s0, "rank"="0.2", "error"="0.01") from root.test

输出序列：

1. +-----------------------------+------------------------------------------------------+
2. |                         Time|percentile(root.test.s0, "rank"="0.2", "error"="0.01")|
3. +-----------------------------+------------------------------------------------------+
4. |2021-03-17T10:35:02.054+08:00|                                    0.1801469624042511|
5. +-----------------------------+------------------------------------------------------+

Period

函数简介

本函数用于计算单列数值型数据的周期。

函数名： PERIOD

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

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

使用示例

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d3.s1|
3. +-----------------------------+---------------+
4. |1970-01-01T08:00:00.001+08:00|            1.0|
5. |1970-01-01T08:00:00.002+08:00|            2.0|
6. |1970-01-01T08:00:00.003+08:00|            3.0|
7. |1970-01-01T08:00:00.004+08:00|            1.0|
8. |1970-01-01T08:00:00.005+08:00|            2.0|
9. |1970-01-01T08:00:00.006+08:00|            3.0|
10. |1970-01-01T08:00:00.007+08:00|            1.0|
11. |1970-01-01T08:00:00.008+08:00|            2.0|
12. |1970-01-01T08:00:00.009+08:00|            3.0|
13. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select period(s1) from root.test.d3

输出序列：

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

QLB

函数简介

本函数对输入序列计算$Q_{LB} $统计量，并计算对应的p值。p值越小表明序列越有可能为非平稳序列。

函数名： QLB

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

参数：

lag：计算时用到的最大延迟阶数，取值应为 1 至 n-2 之间的整数，n 为序列采样总数。默认取 n-2。

输出序列： 输出单个序列，类型为 DOUBLE。该序列是$Q_{LB} $统计量对应的 p 值，时间标签代表偏移阶数。

提示： $Q_{LB} $统计量由自相关系数求得，如需得到统计量而非 p 值，可以使用 ACF 函数。

使用示例

使用默认参数

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |1970-01-01T00:00:00.100+08:00|           1.22|
5. |1970-01-01T00:00:00.200+08:00|          -2.78|
6. |1970-01-01T00:00:00.300+08:00|           1.53|
7. |1970-01-01T00:00:00.400+08:00|           0.70|
8. |1970-01-01T00:00:00.500+08:00|           0.75|
9. |1970-01-01T00:00:00.600+08:00|          -0.72|
10. |1970-01-01T00:00:00.700+08:00|          -0.22|
11. |1970-01-01T00:00:00.800+08:00|           0.28|
12. |1970-01-01T00:00:00.900+08:00|           0.57|
13. |1970-01-01T00:00:01.000+08:00|          -0.22|
14. |1970-01-01T00:00:01.100+08:00|          -0.72|
15. |1970-01-01T00:00:01.200+08:00|           1.34|
16. |1970-01-01T00:00:01.300+08:00|          -0.25|
17. |1970-01-01T00:00:01.400+08:00|           0.17|
18. |1970-01-01T00:00:01.500+08:00|           2.51|
19. |1970-01-01T00:00:01.600+08:00|           1.42|
20. |1970-01-01T00:00:01.700+08:00|          -1.34|
21. |1970-01-01T00:00:01.800+08:00|          -0.01|
22. |1970-01-01T00:00:01.900+08:00|          -0.49|
23. |1970-01-01T00:00:02.000+08:00|           1.63|
24. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select QLB(s1) from root.test.d1

输出序列：

1. +-----------------------------+--------------------+
2. |                         Time|QLB(root.test.d1.s1)|
3. +-----------------------------+--------------------+
4. |1970-01-01T00:00:00.001+08:00|  0.2168702295315677|
5. |1970-01-01T00:00:00.002+08:00|  0.3068948509261751|
6. |1970-01-01T00:00:00.003+08:00|  0.4217859150918444|
7. |1970-01-01T00:00:00.004+08:00|  0.5114539874276656|
8. |1970-01-01T00:00:00.005+08:00|  0.6560619525616759|
9. |1970-01-01T00:00:00.006+08:00|  0.7722398654053280|
10. |1970-01-01T00:00:00.007+08:00|  0.8532491661465290|
11. |1970-01-01T00:00:00.008+08:00|  0.9028575017542528|
12. |1970-01-01T00:00:00.009+08:00|  0.9434989988192729|
13. |1970-01-01T00:00:00.010+08:00|  0.8950280161464689|
14. |1970-01-01T00:00:00.011+08:00|  0.7701048398839656|
15. |1970-01-01T00:00:00.012+08:00|  0.7845536060001281|
16. |1970-01-01T00:00:00.013+08:00|  0.5943030981705825|
17. |1970-01-01T00:00:00.014+08:00|  0.4618413512531093|
18. |1970-01-01T00:00:00.015+08:00|  0.2645948244673964|
19. |1970-01-01T00:00:00.016+08:00|  0.3167530476666645|
20. |1970-01-01T00:00:00.017+08:00|  0.2330010780351453|
21. |1970-01-01T00:00:00.018+08:00|  0.0666611237622325|
22. +-----------------------------+--------------------+

Resample

函数简介

本函数对输入序列按照指定的频率进行重采样，包括上采样和下采样。目前，本函数支持的上采样方法包括NaN填充法 (NaN)、前值填充法 (FFill)、后值填充法 (BFill) 以及线性插值法 (Linear)；本函数支持的下采样方法为分组聚合，聚合方法包括最大值 (Max)、最小值 (Min)、首值 (First)、末值 (Last)、平均值 (Mean)和中位数 (Median)。

函数名： RESAMPLE

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

参数：

every：重采样频率，是一个有单位的正数。目前支持五种单位，分别是 ‘ms’（毫秒）、’s’（秒）、’m’（分钟）、’h’（小时）和’d’（天）。该参数不允许缺省。
interp：上采样的插值方法，取值为 ‘NaN’、’FFill’、’BFill’ 或 ‘Linear’。在缺省情况下，使用NaN填充法。
aggr：下采样的聚合方法，取值为 ‘Max’、’Min’、’First’、’Last’、’Mean’ 或 ‘Median’。在缺省情况下，使用平均数聚合。
start：重采样的起始时间（包含），是一个格式为 ‘yyyy-MM-dd HH:mm:ss’ 的时间字符串。在缺省情况下，使用第一个有效数据点的时间戳。
end：重采样的结束时间（不包含），是一个格式为 ‘yyyy-MM-dd HH:mm:ss’ 的时间字符串。在缺省情况下，使用最后一个有效数据点的时间戳。

输出序列： 输出单个序列，类型为 DOUBLE。该序列按照重采样频率严格等间隔分布。

提示： 数据中的NaN将会被忽略。

使用示例

上采样

当重采样频率高于数据原始频率时，将会进行上采样。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2021-03-06T16:00:00.000+08:00|           3.09|
5. |2021-03-06T16:15:00.000+08:00|           3.53|
6. |2021-03-06T16:30:00.000+08:00|            3.5|
7. |2021-03-06T16:45:00.000+08:00|           3.51|
8. |2021-03-06T17:00:00.000+08:00|           3.41|
9. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select resample(s1,'every'='5m','interp'='linear') from root.test.d1

输出序列：

1. +-----------------------------+----------------------------------------------------------+
2. |                         Time|resample(root.test.d1.s1, "every"="5m", "interp"="linear")|
3. +-----------------------------+----------------------------------------------------------+
4. |2021-03-06T16:00:00.000+08:00|                                        3.0899999141693115|
5. |2021-03-06T16:05:00.000+08:00|                                        3.2366665999094644|
6. |2021-03-06T16:10:00.000+08:00|                                        3.3833332856496177|
7. |2021-03-06T16:15:00.000+08:00|                                        3.5299999713897705|
8. |2021-03-06T16:20:00.000+08:00|                                        3.5199999809265137|
9. |2021-03-06T16:25:00.000+08:00|                                         3.509999990463257|
10. |2021-03-06T16:30:00.000+08:00|                                                       3.5|
11. |2021-03-06T16:35:00.000+08:00|                                         3.503333330154419|
12. |2021-03-06T16:40:00.000+08:00|                                         3.506666660308838|
13. |2021-03-06T16:45:00.000+08:00|                                         3.509999990463257|
14. |2021-03-06T16:50:00.000+08:00|                                        3.4766666889190674|
15. |2021-03-06T16:55:00.000+08:00|                                         3.443333387374878|
16. |2021-03-06T17:00:00.000+08:00|                                        3.4100000858306885|
17. +-----------------------------+----------------------------------------------------------+

下采样

当重采样频率低于数据原始频率时，将会进行下采样。

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

1. select resample(s1,'every'='30m','aggr'='first') from root.test.d1

输出序列：

1. +-----------------------------+--------------------------------------------------------+
2. |                         Time|resample(root.test.d1.s1, "every"="30m", "aggr"="first")|
3. +-----------------------------+--------------------------------------------------------+
4. |2021-03-06T16:00:00.000+08:00|                                      3.0899999141693115|
5. |2021-03-06T16:30:00.000+08:00|                                                     3.5|
6. |2021-03-06T17:00:00.000+08:00|                                      3.4100000858306885|
7. +-----------------------------+--------------------------------------------------------+

指定重采样时间段

可以使用start和end两个参数指定重采样的时间段，超出实际时间范围的部分会被插值填补。

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

1. select resample(s1,'every'='30m','start'='2021-03-06 15:00:00') from root.test.d1

输出序列：

1. +-----------------------------+-----------------------------------------------------------------------+
2. |                         Time|resample(root.test.d1.s1, "every"="30m", "start"="2021-03-06 15:00:00")|
3. +-----------------------------+-----------------------------------------------------------------------+
4. |2021-03-06T15:00:00.000+08:00|                                                                    NaN|
5. |2021-03-06T15:30:00.000+08:00|                                                                    NaN|
6. |2021-03-06T16:00:00.000+08:00|                                                      3.309999942779541|
7. |2021-03-06T16:30:00.000+08:00|                                                     3.5049999952316284|
8. |2021-03-06T17:00:00.000+08:00|                                                     3.4100000858306885|
9. +-----------------------------+-----------------------------------------------------------------------+

Sample

函数简介

本函数对输入序列进行采样，即从输入序列中选取指定数量的数据点并输出。目前，本函数支持两种采样方法：蓄水池采样法 (reservoir sampling) 对数据进行随机采样，所有数据点被采样的概率相同；等距采样法 (isometric sampling) 按照相等的索引间隔对数据进行采样。

函数名： SAMPLE

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

参数：

method：采样方法，取值为 ‘reservoir’ 或’ isometric’。在缺省情况下，采用蓄水池采样法。
k：采样数，它是一个正整数，在缺省情况下为 1。

输出序列： 输出单个序列，类型与输入序列相同。该序列的长度为采样数，序列中的每一个数据点都来自于输入序列。

提示： 如果采样数大于序列长度，那么输入序列中所有的数据点都会被输出。

使用示例

蓄水池采样

当method参数为 ‘reservoir’ 或缺省时，采用蓄水池采样法对输入序列进行采样。由于该采样方法具有随机性，下面展示的输出序列只是一种可能的结果。

输入序列：

1. +-----------------------------+---------------+
2. |                         Time|root.test.d1.s1|
3. +-----------------------------+---------------+
4. |2020-01-01T00:00:01.000+08:00|            1.0|
5. |2020-01-01T00:00:02.000+08:00|            2.0|
6. |2020-01-01T00:00:03.000+08:00|            3.0|
7. |2020-01-01T00:00:04.000+08:00|            4.0|
8. |2020-01-01T00:00:05.000+08:00|            5.0|
9. |2020-01-01T00:00:06.000+08:00|            6.0|
10. |2020-01-01T00:00:07.000+08:00|            7.0|
11. |2020-01-01T00:00:08.000+08:00|            8.0|
12. |2020-01-01T00:00:09.000+08:00|            9.0|
13. |2020-01-01T00:00:10.000+08:00|           10.0|
14. +-----------------------------+---------------+

用于查询的 SQL 语句：

1. select sample(s1,'method'='reservoir','k'='5') from root.test.d1

输出序列：

1. +-----------------------------+------------------------------------------------------+
2. |                         Time|sample(root.test.d1.s1, "method"="reservoir", "k"="5")|
3. +-----------------------------+------------------------------------------------------+
4. |2020-01-01T00:00:02.000+08:00|                                                   2.0|
5. |2020-01-01T00:00:03.000+08:00|                                                   3.0|
6. |2020-01-01T00:00:05.000+08:00|                                                   5.0|
7. |2020-01-01T00:00:08.000+08:00|                                                   8.0|
8. |2020-01-01T00:00:10.000+08:00|                                                  10.0|
9. +-----------------------------+------------------------------------------------------+

等距采样

当method参数为 ‘isometric’ 时，采用等距采样法对输入序列进行采样。

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

1. select sample(s1,'method'='isometric','k'='5') from root.test.d1

输出序列：

1. +-----------------------------+------------------------------------------------------+
2. |                         Time|sample(root.test.d1.s1, "method"="isometric", "k"="5")|
3. +-----------------------------+------------------------------------------------------+
4. |2020-01-01T00:00:01.000+08:00|                                                   1.0|
5. |2020-01-01T00:00:03.000+08:00|                                                   3.0|
6. |2020-01-01T00:00:05.000+08:00|                                                   5.0|
7. |2020-01-01T00:00:07.000+08:00|                                                   7.0|
8. |2020-01-01T00:00:09.000+08:00|                                                   9.0|
9. +-----------------------------+------------------------------------------------------+

Segment

函数简介

本函数按照数据的线性变化趋势将数据划分为多个子序列，返回分段直线拟合后的子序列首值或所有拟合值。

函数名： SEGMENT

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

参数：

output：”all” 输出所有拟合值；”first” 输出子序列起点拟合值。默认为 “first”。
error：判定存在线性趋势的误差允许阈值。误差的定义为子序列进行线性拟合的误差的绝对值的均值。默认为 0.1.

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

提示： 函数默认所有数据等时间间隔分布。函数读取所有数据，若原始数据过多，请先进行降采样处理。拟合采用自底向上方法，子序列的尾值可能会被认作子序列首值输出。

使用示例

输入序列：

1. +-----------------------------+------------+
2. |                         Time|root.test.s1|
3. +-----------------------------+------------+
4. |1970-01-01T08:00:00.000+08:00|         5.0|
5. |1970-01-01T08:00:00.100+08:00|         0.0|
6. |1970-01-01T08:00:00.200+08:00|         1.0|
7. |1970-01-01T08:00:00.300+08:00|         2.0|
8. |1970-01-01T08:00:00.400+08:00|         3.0|
9. |1970-01-01T08:00:00.500+08:00|         4.0|
10. |1970-01-01T08:00:00.600+08:00|         5.0|
11. |1970-01-01T08:00:00.700+08:00|         6.0|
12. |1970-01-01T08:00:00.800+08:00|         7.0|
13. |1970-01-01T08:00:00.900+08:00|         8.0|
14. |1970-01-01T08:00:01.000+08:00|         9.0|
15. |1970-01-01T08:00:01.100+08:00|         9.1|
16. |1970-01-01T08:00:01.200+08:00|         9.2|
17. |1970-01-01T08:00:01.300+08:00|         9.3|
18. |1970-01-01T08:00:01.400+08:00|         9.4|
19. |1970-01-01T08:00:01.500+08:00|         9.5|
20. |1970-01-01T08:00:01.600+08:00|         9.6|
21. |1970-01-01T08:00:01.700+08:00|         9.7|
22. |1970-01-01T08:00:01.800+08:00|         9.8|
23. |1970-01-01T08:00:01.900+08:00|         9.9|
24. |1970-01-01T08:00:02.000+08:00|        10.0|
25. |1970-01-01T08:00:02.100+08:00|         8.0|
26. |1970-01-01T08:00:02.200+08:00|         6.0|
27. |1970-01-01T08:00:02.300+08:00|         4.0|
28. |1970-01-01T08:00:02.400+08:00|         2.0|
29. |1970-01-01T08:00:02.500+08:00|         0.0|
30. |1970-01-01T08:00:02.600+08:00|        -2.0|
31. |1970-01-01T08:00:02.700+08:00|        -4.0|
32. |1970-01-01T08:00:02.800+08:00|        -6.0|
33. |1970-01-01T08:00:02.900+08:00|        -8.0|
34. |1970-01-01T08:00:03.000+08:00|       -10.0|
35. |1970-01-01T08:00:03.100+08:00|        10.0|
36. |1970-01-01T08:00:03.200+08:00|        10.0|
37. |1970-01-01T08:00:03.300+08:00|        10.0|
38. |1970-01-01T08:00:03.400+08:00|        10.0|
39. |1970-01-01T08:00:03.500+08:00|        10.0|
40. |1970-01-01T08:00:03.600+08:00|        10.0|
41. |1970-01-01T08:00:03.700+08:00|        10.0|
42. |1970-01-01T08:00:03.800+08:00|        10.0|
43. |1970-01-01T08:00:03.900+08:00|        10.0|
44. +-----------------------------+------------+

用于查询的 SQL 语句：

1. select segment(s1,"error"="0.1") from root.test

输出序列：

1. +-----------------------------+------------------------------------+
2. |                         Time|segment(root.test.s1, "error"="0.1")|
3. +-----------------------------+------------------------------------+
4. |1970-01-01T08:00:00.000+08:00|                                 5.0|
5. |1970-01-01T08:00:00.200+08:00|                                 1.0|
6. |1970-01-01T08:00:01.000+08:00|                                 9.0|
7. |1970-01-01T08:00:02.000+08:00|                                10.0|
8. |1970-01-01T08:00:03.000+08:00|                               -10.0|
9. |1970-01-01T08:00:03.200+08:00|                                10.0|
10. +-----------------------------+------------------------------------+

Skew

函数简介

本函数用于计算单列数值型数据的总体偏度

函数名： SKEW

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

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

提示： 数据中的空值、缺失值和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|           10.0|
15. |2020-01-01T00:00:11.000+08:00|           10.0|
16. |2020-01-01T00:00:12.000+08:00|           10.0|
17. |2020-01-01T00:00:13.000+08:00|           10.0|
18. |2020-01-01T00:00:14.000+08:00|           10.0|
19. |2020-01-01T00:00:15.000+08:00|           10.0|
20. |2020-01-01T00:00:16.000+08:00|           10.0|
21. |2020-01-01T00:00:17.000+08:00|           10.0|
22. |2020-01-01T00:00:18.000+08:00|           10.0|
23. |2020-01-01T00:00:19.000+08:00|           10.0|
24. +-----------------------------+---------------+

用于查询的SQL语句：

1. select skew(s1) from root.test.d1

输出序列：

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

Spline

函数简介

本函数提供对原始序列进行三次样条曲线拟合后的插值重采样。

函数名： SPLINE

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

参数：

points：重采样个数。

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

提示：输出序列保留输入序列的首尾值，等时间间隔采样。仅当输入点个数不少于 4 个时才计算插值。

使用示例

指定插值个数

输入序列：

``` 1. +-----------------------------+------------+ 2. |

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