You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by xi...@apache.org on 2021/12/17 03:15:21 UTC
[iotdb] branch groupbyleveldoc created (now 536d290)
This is an automated email from the ASF dual-hosted git repository.
xiangweiwei pushed a change to branch groupbyleveldoc
in repository https://gitbox.apache.org/repos/asf/iotdb.git.
at 536d290 add group by level doc
This branch includes the following new commits:
new 536d290 add group by level doc
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[iotdb] 01/01: add group by level doc
Posted by xi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
xiangweiwei pushed a commit to branch groupbyleveldoc
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 536d2904dc6852c1ef958f8978fa7873c5f5deb5
Author: Alima777 <wx...@gmail.com>
AuthorDate: Fri Dec 17 11:14:18 2021 +0800
add group by level doc
---
.../DML-Data-Manipulation-Language.md | 105 ++--
.../DML-Data-Manipulation-Language.md | 564 +++++++++++++++------
2 files changed, 484 insertions(+), 185 deletions(-)
diff --git a/docs/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md b/docs/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
index 8597e7e..1515880 100644
--- a/docs/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
+++ b/docs/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
@@ -589,69 +589,112 @@ It costs 0.016s
#### Aggregation By Level
-**Aggregation by level statement** is used for aggregating upon specific hierarchical level of timeseries path.
-For all timeseries paths, by convention, "level=0" represents *root* level.
-That is, to tally the points of any measurements under "root.ln", the level should be set to 1.
+Aggregation by level statement is used to group the query result whose name is the same at the given level. Keyword `LEVEL` is used to specify the level that need to be grouped. By convention, `level=0` represents *root* level.
-For example, there are multiple series under "root.ln.wf01", such as "root.ln.wf01.wt01.status","root.ln.wf01.wt02.status","root.ln.wf01.wt03.status".
-To count the number of "status" points of all these series, use query:
+For example：there are multiple series named `status` under different storage groups， like "root.ln.wf01.wt01.status", "root.ln.wf02.wt02.status", and "root.sgcc.wf03.wt01.status". If you need to count the number of data points of the `status` sequence under different storage groups, use the following query:
```sql
-select count(status) from root.ln.wf01.* group by level=2
+select count(status)
+from root.**
+group by level = 1
```
-Result:
+
+Result：
+
+```
++-------------------------+---------------------------+
+|count(root.ln.*.*.status)|count(root.sgcc.*.*.status)|
++-------------------------+---------------------------+
+| 20160| 10080|
++-------------------------+---------------------------+
+Total line number = 1
+It costs 0.003s
+```
+
+Similarly，if you need to count the number of data points under different devices, you can specify level = 3,
+
+```sql
+select count(status)
+from root.**
+group by level = 3
+```
+
+Result：
```
-+----------------------------+
-|COUNT(root.ln.wf01.*.status)|
-+----------------------------+
-| 10080|
-+----------------------------+
++---------------------------+---------------------------+
+|count(root.*.*.wt01.status)|count(root.*.*.wt02.status)|
++---------------------------+---------------------------+
+| 20160| 10080|
++---------------------------+---------------------------+
+Total line number = 1
+It costs 0.003s
+```
+
+Attention，the devices named `wt01` under storage groups `ln` and `sgcc` are grouped together, since they are regarded as devices with the same name. If you need to further count the number of data points in different devices under different storage groups, you can use the following query:
+
+```sql
+select count(status)
+from root.**
+group by level = 1, 3
+```
+
+Result：
+
+```
++----------------------------+----------------------------+------------------------------+
+|count(root.ln.*.wt01.status)|count(root.ln.*.wt02.status)|count(root.sgcc.*.wt01.status)|
++----------------------------+----------------------------+------------------------------+
+| 10080| 10080| 10080|
++----------------------------+----------------------------+------------------------------+
Total line number = 1
It costs 0.003s
```
-Suppose we add another two timeseries, "root.ln.wf01.wt01.temperature" and "root.ln.wf02.wt01.temperature".
-To query the count and the sum of "temperature" under path "root.ln.*.*",
-aggregating on level=2, use following statement:
+
+Assuming that you want to query the maximum value of temperature sensor under all time series, you can use the following query statement:
```sql
-select count(temperature), sum(temperature) from root.ln.*.* group by level=2
+select max_value(temperature)
+from root.**
+group by level = 0
```
+
Result：
```
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
-|count(root.ln.wf02.*.temperature)|count(root.ln.wf01.*.temperature)|sum(root.ln.wf02.*.temperature)|sum(root.ln.wf01.*.temperature)|
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
-| 8| 4| 228.0| 91.83000183105469|
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
++---------------------------------+
+|max_value(root.*.*.*.temperature)|
++---------------------------------+
+| 26.0|
++---------------------------------+
Total line number = 1
It costs 0.013s
```
-To query the count and the sum of path "root.ln.\*.\*.temperature" aggregating on "root.ln" level,
-simply set level=1
+The above queries are for a certain sensor. In particular, **if you want to query the total data points owned by all sensors at a certain level**, you need to explicitly specify `*` is selected.
```sql
-select count(temperature), sum(temperature) from root.ln.*.* group by level=1
+select count(*)
+from root.ln.**
+group by level = 2
```
+
Result：
```
-+------------------------------+----------------------------+
-|count(root.ln.*.*.temperature)|sum(root.ln.*.*.temperature)|
-+------------------------------+----------------------------+
-| 12| 319.8300018310547|
-+------------------------------+----------------------------+
++----------------------+----------------------+
+|count(root.*.wf01.*.*)|count(root.*.wf02.*.*)|
++----------------------+----------------------+
+| 20160| 20160|
++----------------------+----------------------+
Total line number = 1
It costs 0.013s
```
All supported aggregation functions are: count, sum, avg, last_value, first_value, min_time, max_time, min_value, max_value, extreme.
-When using four aggregations: sum, avg, min_value, max_value and extreme please make sure all the aggregated series have exactly the same data type.
-Otherwise, it will generate a syntax error.
+When using four aggregations: sum, avg, min_value, max_value and extreme please make sure all the aggregated series have exactly the same data type. Otherwise, it will generate a syntax error.
#### Down-Frequency Aggregate Query
diff --git a/docs/zh/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md b/docs/zh/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
index db90614..ae35b2c 100644
--- a/docs/zh/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
+++ b/docs/zh/UserGuide/IoTDB-SQL-Language/DML-Data-Manipulation-Language.md
@@ -23,43 +23,54 @@
## 数据写入
-IoTDB 为用户提供多种插入实时数据的方式，例如在 [Cli/Shell 工具](../CLI/Command-Line-Interface.md) 中直接输入插入数据的 INSERT 语句，或使用 Java API（标准 [Java JDBC](../API/Programming-JDBC.md) 接口）单条或批量执行插入数据的 INSERT 语句。
+IoTDB 为用户提供多种插入实时数据的方式，例如在 [Cli/Shell 工具](../CLI/Command-Line-Interface.md) 中直接输入插入数据的 INSERT 语句，或使用
+Java API（标准 [Java JDBC](../API/Programming-JDBC.md) 接口）单条或批量执行插入数据的 INSERT 语句。
-本节主要为您介绍实时数据接入的 INSERT 语句在场景中的实际使用示例，有关 INSERT SQL 语句的详细语法请参见本文 [INSERT 语句](../Appendix/SQL-Reference.md) 节。
+本节主要为您介绍实时数据接入的 INSERT 语句在场景中的实际使用示例，有关 INSERT SQL
+语句的详细语法请参见本文 [INSERT 语句](../Appendix/SQL-Reference.md) 节。
### 使用 INSERT 语句
使用 INSERT 语句可以向指定的已经创建的一条或多条时间序列中插入数据。对于每一条数据，均由一个时间戳类型的时间戳和一个数值或布尔值、字符串类型的传感器采集值组成。
-在本节的场景实例下，以其中的两个时间序列`root.ln.wf02.wt02.status`和`root.ln.wf02.wt02.hardware`为例 ，它们的数据类型分别为 BOOLEAN 和 TEXT。
+在本节的场景实例下，以其中的两个时间序列`root.ln.wf02.wt02.status`和`root.ln.wf02.wt02.hardware`为例 ，它们的数据类型分别为 BOOLEAN 和
+TEXT。
单列数据插入示例代码如下：
```sql
-IoTDB > insert into root.ln.wf02.wt02(timestamp,status) values(1,true)
+IoTDB
+> insert into root.ln.wf02.wt02(timestamp,status) values(1,true)
IoTDB > insert into root.ln.wf02.wt02(timestamp,hardware) values(1, 'v1')
```
-以上示例代码将长整型的 timestamp 以及值为 true 的数据插入到时间序列`root.ln.wf02.wt02.status`中和将长整型的 timestamp 以及值为”v1”的数据插入到时间序列`root.ln.wf02.wt02.hardware`中。执行成功后会返回执行时间，代表数据插入已完成。
+以上示例代码将长整型的 timestamp 以及值为 true 的数据插入到时间序列`root.ln.wf02.wt02.status`中和将长整型的 timestamp
+以及值为”v1”的数据插入到时间序列`root.ln.wf02.wt02.hardware`中。执行成功后会返回执行时间，代表数据插入已完成。
> 注意：在 IoTDB 中，TEXT 类型的数据单双引号都可以来表示，上面的插入语句是用的是双引号表示 TEXT 类型数据，下面的示例将使用单引号表示 TEXT 类型数据。
INSERT 语句还可以支持在同一个时间点下多列数据的插入，同时向 2 时间点插入上述两个时间序列的值，多列数据插入示例代码如下：
```sql
-IoTDB > insert into root.ln.wf02.wt02(timestamp, status, hardware) values (2, false, 'v2')
+IoTDB
+> insert into root.ln.wf02.wt02(timestamp, status, hardware) values (2, false, 'v2')
```
此外，INSERT 语句支持一次性插入多行数据，同时向 2 个不同时间点插入上述时间序列的值，示例代码如下：
```sql
-IoTDB > insert into root.ln.wf02.wt02(timestamp, status, hardware) VALUES (3, false, 'v3'),(4, true, 'v4')
+IoTDB
+> insert into root.ln.wf02.wt02(timestamp, status, hardware) VALUES (3, false, 'v3'),(4, true, 'v4')
```
插入数据后我们可以使用 SELECT 语句简单查询已插入的数据。
```sql
-IoTDB > select * from root.ln.wf02 where time < 5
+IoTDB
+>
+select *
+from root.ln.wf02
+where time < 5
```
结果如图所示。由查询结果可以看出，单列、多列数据的插入操作正确执行。
@@ -81,19 +92,23 @@ It costs 0.170s
### 时间条件过滤查询
-本节主要介绍时间切片查询的相关示例，主要使用的是 [IoTDB SELECT 语句](../Appendix/SQL-Reference.md)。同时，您也可以使用 [Java JDBC](../API/Programming-JDBC.md) 标准接口来执行相关的查询语句。
+本节主要介绍时间切片查询的相关示例，主要使用的是 [IoTDB SELECT 语句](../Appendix/SQL-Reference.md)
+。同时，您也可以使用 [Java JDBC](../API/Programming-JDBC.md) 标准接口来执行相关的查询语句。
#### 根据一个时间区间选择一列数据
SQL 语句为：
```sql
-select temperature from root.ln.wf01.wt01 where time < 2017-11-01T00:08:00.000
+select temperature
+from root.ln.wf01.wt01
+where time < 2017-11-01T00:08:00.000
```
其含义为：
-被选择的设备为 ln 集团 wf01 子站 wt01 设备；被选择的时间序列为温度传感器（temperature）；该语句要求选择出该设备在“2017-11-01T00:08:00.000”（此处可以使用多种时间格式，详情可参看 [2.1 节](../Data-Concept/Data-Model-and-Terminology.md)）时间点以前的所有温度传感器的值。
+被选择的设备为 ln 集团 wf01 子站 wt01 设备；被选择的时间序列为温度传感器（temperature）；该语句要求选择出该设备在“2017-11-01T00:08:
+00.000”（此处可以使用多种时间格式，详情可参看 [2.1 节](../Data-Concept/Data-Model-and-Terminology.md)）时间点以前的所有温度传感器的值。
该 SQL 语句的执行结果如下：
@@ -119,12 +134,15 @@ It costs 0.026s
SQL 语句为：
```sql
-select status, temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000;
+select status, temperature
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000;
```
其含义为：
-被选择的设备为 ln 集团 wf01 子站 wt01 设备；被选择的时间序列为供电状态（status）和温度传感器（temperature）；该语句要求选择出“2017-11-01T00:05:00.000”至“2017-11-01T00:12:00.000”之间的所选时间序列的值。
+被选择的设备为 ln 集团 wf01 子站 wt01 设备；被选择的时间序列为供电状态（status）和温度传感器（temperature）；该语句要求选择出“2017-11-01T00:05:
+00.000”至“2017-11-01T00:12:00.000”之间的所选时间序列的值。
该 SQL 语句的执行结果如下：
@@ -150,12 +168,18 @@ IoTDB 支持在一次查询中指定多个时间区间条件，用户可以根
SQL 语句为：
```sql
-select status,temperature from root.ln.wf01.wt01 where (time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000) or (time >= 2017-11-01T16:35:00.000 and time <= 2017-11-01T16:37:00.000);
+select status, temperature
+from root.ln.wf01.wt01
+where (time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000)
+ or (time >= 2017-11-01T16:35:00.000 and time <= 2017-11-01T16:37:00.000);
```
其含义为：
-被选择的设备为 ln 集团 wf01 子站 wt01 设备；被选择的时间序列为“供电状态（status）”和“温度传感器（temperature）”；该语句指定了两个不同的时间区间，分别为“2017-11-01T00:05:00.000 至 2017-11-01T00:12:00.000”和“2017-11-01T16:35:00.000 至 2017-11-01T16:37:00.000”；该语句要求选择出满足任一时间区间的被选时间序列的值。
+被选择的设备为 ln 集团 wf01 子站 wt01
+设备；被选择的时间序列为“供电状态（status）”和“温度传感器（temperature）”；该语句指定了两个不同的时间区间，分别为“2017-11-01T00:05:00.000 至
+2017-11-01T00:12:00.000”和“2017-11-01T16:35:00.000 至 2017-11-01T16:37:
+00.000”；该语句要求选择出满足任一时间区间的被选时间序列的值。
该 SQL 语句的执行结果如下：
@@ -182,12 +206,17 @@ It costs 0.018s
该系统支持在一次查询中选择任意列的数据，也就是说，被选择的列可以来源于不同的设备。例如，SQL 语句为：
```sql
-select wf01.wt01.status,wf02.wt02.hardware from root.ln where (time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000) or (time >= 2017-11-01T16:35:00.000 and time <= 2017-11-01T16:37:00.000);
+select wf01.wt01.status, wf02.wt02.hardware
+from root.ln
+where (time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000)
+ or (time >= 2017-11-01T16:35:00.000 and time <= 2017-11-01T16:37:00.000);
```
其含义为：
-被选择的时间序列为“ln 集团 wf01 子站 wt01 设备的供电状态”以及“ln 集团 wf02 子站 wt02 设备的硬件版本”；该语句指定了两个时间区间，分别为“2017-11-01T00:05:00.000 至 2017-11-01T00:12:00.000”和“2017-11-01T16:35:00.000 至 2017-11-01T16:37:00.000”；该语句要求选择出满足任意时间区间的被选时间序列的值。
+被选择的时间序列为“ln 集团 wf01 子站 wt01 设备的供电状态”以及“ln 集团 wf02 子站 wt02 设备的硬件版本”；该语句指定了两个时间区间，分别为“2017-11-01T00:
+05:00.000 至 2017-11-01T00:12:00.000”和“2017-11-01T16:35:00.000 至 2017-11-01T16:37:
+00.000”；该语句要求选择出满足任意时间区间的被选时间序列的值。
该 SQL 语句的执行结果如下：
@@ -210,10 +239,14 @@ It costs 0.014s
```
#### 根据时间降序返回结果集
+
IoTDB 在 0.11 版本开始支持 'order by time' 语句，用于对结果按照时间进行降序展示。例如，SQL 语句为：
```sql
-select * from root.ln.** where time > 1 order by time desc limit 10;
+select *
+from root.ln.**
+where time > 1
+order by time desc limit 10;
```
语句执行的结果为：
@@ -264,7 +297,16 @@ It costs 0.016s
例如：
```sql
-select s1, - s1, s2, + s2, s1 + s2, s1 - s2, s1 * s2, s1 / s2, s1 % s2 from root.sg.d1
+select s1,
+ - s1,
+ s2,
+ + s2,
+ s1 + s2,
+ s1 - s2,
+ s1 * s2,
+ s1 / s2,
+ s1 % s2
+from root.sg.d1
```
结果：
@@ -407,8 +449,8 @@ It costs 0.006s
| TIME_DIFFERENCE | INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXT | INT64 | 统计序列中某数据点的时间戳与前一数据点时间戳的差。范围内第一个数据点没有对应的结果输出。 |
| DIFFERENCE | INT32 / INT64 / FLOAT / DOUBLE | 与输入序列的实际类型一致 | 统计序列中某数据点的值与前一数据点的值的差。范围内第一个数据点没有对应的结果输出。 |
| NON_NEGATIVE_DIFFERENCE | INT32 / INT64 / FLOAT / DOUBLE | 与输入序列的实际类型一致 | 统计序列中某数据点的值与前一数据点的值的差的绝对值。范围内第一个数据点没有对应的结果输出。 |
-| DERIVATIVE | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | 统计序列中某数据点相对于前一数据点的变化率，数量上等同于 DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。 |
-| NON_NEGATIVE_DERIVATIVE | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | 统计序列中某数据点相对于前一数据点的变化率的绝对值，数量上等同于 NON_NEGATIVE_DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。 |
+| DERIVATIVE | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | 统计序列中某数据点相对于前一数据点的变化率，数量上等同于 DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。 |
+| NON_NEGATIVE_DERIVATIVE | INT32 / INT64 / FLOAT / DOUBLE | DOUBLE | 统计序列中某数据点相对于前一数据点的变化率的绝对值，数量上等同于 NON_NEGATIVE_DIFFERENCE / TIME_DIFFERENCE。范围内第一个数据点没有对应的结果输出。 |
例如：
@@ -443,8 +485,10 @@ It costs 0.014s
| 函数名 | 必要的属性参数 | 输出序列类型 | 功能描述 |
| ------ | ------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------ |
| CONST | `value`: 输出的数据点的值 <br />`type`: 输出的数据点的类型，只能是 INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXT | 由输入属性参数 `type` 决定 | 根据输入属性 `value` 和 `type` 输出用户指定的常序列。 |
-| PI | 无 | DOUBLE | 常序列的值：`π` 的 `double` 值，圆的周长与其直径的比值，即圆周率，等于 *Java标准库* 中的`Math.PI`。 |
-| E | 无 | DOUBLE | 常序列的值：`e` 的 `double` 值，自然对数的底，它等于 *Java 标准库* 中的 `Math.E`。 |
+| PI | 无 | DOUBLE | 常序列的值：`π` 的 `double` 值，圆的周长与其直径的比值，即圆周率，等于 *
+Java标准库* 中的`Math.PI`。 |
+| E | 无 | DOUBLE | 常序列的值：`e` 的 `double` 值，自然对数的底，它等于 *
+Java 标准库* 中的 `Math.E`。 |
例如：
@@ -471,7 +515,8 @@ It costs 0.005s
#### 数据类型转换函数
-当前IoTDB支持6种数据类型，其中包括INT32、INT64、FLOAT、DOUBLE、BOOLEAN以及TEXT。当我们对数据进行查询或者计算时可能需要进行数据类型的转换， 比如说将TEXT转换为INT32，或者提高数据精度，比如说将FLOAT转换为DOUBLE。所以，IoTDB支持使用cast函数对数据类型进行转换。
+当前IoTDB支持6种数据类型，其中包括INT32、INT64、FLOAT、DOUBLE、BOOLEAN以及TEXT。当我们对数据进行查询或者计算时可能需要进行数据类型的转换，
+比如说将TEXT转换为INT32，或者提高数据精度，比如说将FLOAT转换为DOUBLE。所以，IoTDB支持使用cast函数对数据类型进行转换。
| 函数名 | 必要的属性参数 | 输出序列类型 | 功能类型 |
| ------ | ------------------------------------------------------------ | ------------------------ | ---------------------------------- |
@@ -481,12 +526,15 @@ It costs 0.005s
1.当INT32、INT64类型的值不为0时，FLOAT与DOUBLE类型的值不为0.0时，TEXT类型不为空字符串或者"false"时，转换为BOOLEAN类型时值为true，否则为false。
-2.当BOOLEAN类型的值为true时，转换为INT32与INT64类型的值为1，转换为FLOAT或者DOUBLE类型时值为1.0，转换为TEXT类型时值为"true"。当BOOLEAN类型的值为false时，转换为INT32与INT64类型的值为0，转换为FLOAT或者DOUBLE类型时值为0.0，转换为TEXT类型时值为"false"。
+2.当BOOLEAN类型的值为true时，转换为INT32与INT64类型的值为1，转换为FLOAT或者DOUBLE类型时值为1.0，转换为TEXT类型时值为"true"
+。当BOOLEAN类型的值为false时，转换为INT32与INT64类型的值为0，转换为FLOAT或者DOUBLE类型时值为0.0，转换为TEXT类型时值为"false"。
3.当TEXT类型转换为INT32、INT64、FLOAT类型时，会先将TEXT类型的数据转换为DOUBLE类型，然后再转换为对应的类型，此时可能会存在损失精度的问题。如果无法转换的话则直接跳过。
##### 演示
+
测试数据：
+
```
IoTDB> select text from root.test;
+-----------------------------+--------------+
@@ -498,11 +546,20 @@ IoTDB> select text from root.test;
|1970-01-01T08:00:00.004+08:00| false|
+-----------------------------+--------------+
```
+
SQL语句：
+
```sql
-select cast(text, 'type'='BOOLEAN'), cast(text, 'type'='INT32'), cast(text, 'type'='INT64'), cast(text, 'type'='FLOAT'), cast(text, 'type'='DOUBLE') from root.test;
+select cast(text, 'type' = 'BOOLEAN'),
+ cast(text, 'type' = 'INT32'),
+ cast(text, 'type' = 'INT64'),
+ cast(text, 'type' = 'FLOAT'),
+ cast(text, 'type' = 'DOUBLE')
+from root.test;
```
+
结果：
+
```
+-----------------------------+--------------------------------------+------------------------------------+------------------------------------+------------------------------------+-------------------------------------+
| Time|cast(root.test.text, "type"="BOOLEAN")|cast(root.test.text, "type"="INT32")|cast(root.test.text, "type"="INT64")|cast(root.test.text, "type"="FLOAT")|cast(root.test.text, "type"="DOUBLE")|
@@ -515,6 +572,7 @@ select cast(text, 'type'='BOOLEAN'), cast(text, 'type'='INT32'), cast(text, 'typ
Total line number = 4
It costs 0.078s
```
+
#### 自定义时间序列生成函数
请参考 [UDF （用户定义函数）](../Advanced-Features/UDF-User-Defined-Function.md)。
@@ -533,15 +591,16 @@ IoTDB 支持在 `select` 字句中执行由**数字常量，时间序列、算
```sql
selectClause
- : SELECT resultColumn (',' resultColumn)*
- ;
+:
+SELECT resultColumn(',' resultColumn) *
+;
resultColumn
- : expression (AS ID)?
+: expression (AS ID)?
;
expression
- : '(' expression ')'
+: '(' expression ')'
| '-' expression
| expression ('*' | '/' | '%') expression
| expression ('+' | '-') expression
@@ -580,14 +639,15 @@ It costs 0.170s
### 聚合查询
-本章节主要介绍聚合查询的相关示例，
-主要使用的是 IoTDB SELECT 语句的聚合查询函数。
+本章节主要介绍聚合查询的相关示例， 主要使用的是 IoTDB SELECT 语句的聚合查询函数。
#### 统计总点数
```sql
-select count(status) from root.ln.wf01.wt01;
+select count(status)
+from root.ln.wf01.wt01;
```
+
结果：
```
@@ -602,76 +662,122 @@ It costs 0.016s
#### 路径层级分组聚合
-在时间序列层级结构中，分层聚合查询用于对某一层级进行聚合查询。
-这里使用 LEVEL 来统计指定层级下的聚合范围，该语句约定 root 为第 0 层序列，若统计"root.ln"下所有序列则需指定 level 为 1。
+在时间序列层级结构中，分层聚合查询用于**对某一层级下同名的序列进行聚合查询**。 这里使用 LEVEL 来统计指定需要聚合的层级，该语句约定 root 为第 0 层序列，若统计 "root.ln" 下所有序列则需指定 level 为 1。
+
+例如：不同存储组下均存在名为 status 的序列， 如 "root.ln.wf01.wt01.status", "root.ln.wf02.wt02.status", 以及 "
+root.sgcc.wf03.wt01.status", 如果需要统计不同存储组下 status 序列的数据点个数，使用以下查询：
+
+```sql
+select count(status)
+from root.**
+group by level = 1
+```
+
+运行结果为：
+
+```
++-------------------------+---------------------------+
+|count(root.ln.*.*.status)|count(root.sgcc.*.*.status)|
++-------------------------+---------------------------+
+| 20160| 10080|
++-------------------------+---------------------------+
+Total line number = 1
+It costs 0.003s
+```
+
+同理，如果需要统计不同设备下 status 序列的数据点个数，可以规定 level = 3，
+
+```sql
+select count(status)
+from root.**
+group by level = 3
+```
+
+运行结果为：
+
+```
++---------------------------+---------------------------+
+|count(root.*.*.wt01.status)|count(root.*.*.wt02.status)|
++---------------------------+---------------------------+
+| 20160| 10080|
++---------------------------+---------------------------+
+Total line number = 1
+It costs 0.003s
+```
-例如：在"root.ln.wf01"下存在多个子序列：wt01，wt02，wt03 等均有名为 status 的序列，
-如果需要统计这些子序列的 status 包含的点个数，使用以下查询：
+注意，这时会将存储组 `ln` 和 `sgcc` 下名为 `wt01` 的设备视为同名设备聚合在一起。而如果需要进一步统计不同存储组下的不同设备中 status 序列的数据点个数，可以使用以下查询：
```sql
-select count(status) from root.ln.wf01.* group by level=2
+select count(status)
+from root.**
+group by level = 1, 3
```
运行结果为：
```
-+----------------------------+
-|count(root.ln.wf01.*.status)|
-+----------------------------+
-| 10080|
-+----------------------------+
++----------------------------+----------------------------+------------------------------+
+|count(root.ln.*.wt01.status)|count(root.ln.*.wt02.status)|count(root.sgcc.*.wt01.status)|
++----------------------------+----------------------------+------------------------------+
+| 10080| 10080| 10080|
++----------------------------+----------------------------+------------------------------+
Total line number = 1
It costs 0.003s
```
-假设此时添加两条序列，"root.ln.wf01.wt01.temperature" and "root.ln.wf02.wt01.temperature"。
-需要同时查询"root.ln.\*.\*.temperature"在第二层级的 count 聚合结果和 sum 聚合结果，可以使用下列查询语句：
+
+
+假设需要查询所有序列下温度传感器 temperature 的最大值，可以使用下列查询语句：
```sql
-select count(temperature), sum(temperature) from root.ln.*.* group by level=2
+select max_value(temperature)
+from root.**
+group by level = 0
```
运行结果：
```
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
-|count(root.ln.wf02.*.temperature)|count(root.ln.wf01.*.temperature)|sum(root.ln.wf02.*.temperature)|sum(root.ln.wf01.*.temperature)|
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
-| 8| 4| 228.0| 91.83000183105469|
-+---------------------------------+---------------------------------+-------------------------------+-------------------------------+
++---------------------------------+
+|max_value(root.*.*.*.temperature)|
++---------------------------------+
+| 26.0|
++---------------------------------+
Total line number = 1
It costs 0.013s
```
-若统计"root.ln.\*.\*"下第一层级的 count 聚合结果和 sum 聚合结果，则设置 level=1 即可：
+上面的查询都是针对某一个传感器，特别地，**如果想要查询某一层级下所有传感器拥有的总数据点数，则需要显式规定测点为 `*`**
```sql
-select count(temperature), sum(temperature) from root.ln.*.* group by level=1
+select count(*)
+from root.ln.**
+group by level = 2
```
运行结果：
```
-+------------------------------+----------------------------+
-|count(root.ln.*.*.temperature)|sum(root.ln.*.*.temperature)|
-+------------------------------+----------------------------+
-| 12| 319.8300018310547|
-+------------------------------+----------------------------+
++----------------------+----------------------+
+|count(root.*.wf01.*.*)|count(root.*.wf02.*.*)|
++----------------------+----------------------+
+| 20160| 20160|
++----------------------+----------------------+
Total line number = 1
It costs 0.013s
```
-分层聚合查询也可被用于其他聚合函数，当前所支持的聚合函数为：count, sum, avg, last_value, first_value, min_time, max_time, min_value, max_value, extreme
+分层聚合查询也可被用于其他聚合函数，当前所支持的聚合函数为：count, sum, avg, last_value, first_value, min_time, max_time,
+min_value, max_value, extreme
对于 sum, avg, min_value, max_value, extreme 五种聚合函数，需保证所有聚合的时间序列数据类型相同。其他聚合函数没有此限制。
#### 时间区间分组聚合
-本章节主要介绍时间区间分组聚合查询的相关示例，
-主要使用的是 IoTDB SELECT 语句的 [GROUP BY 子句](../Appendix/SQL-Reference.md)，
-该子句是 IoTDB 中用于根据用户给定划分条件对结果集进行划分，并对已划分的结果集进行聚合计算的语句。
-IoTDB 支持根据时间间隔和自定义的滑动步长（默认值与时间间隔相同，自定义的值必须大于等于时间间隔）对结果集进行划分，默认结果按照时间升序排列。
-同时，您也可以使用 Java JDBC 标准接口来执行相关的查询语句。
+本章节主要介绍时间区间分组聚合查询的相关示例， 主要使用的是 IoTDB SELECT 语句的 [GROUP BY 子句](../Appendix/SQL-Reference.md)， 该子句是
+IoTDB 中用于根据用户给定划分条件对结果集进行划分，并对已划分的结果集进行聚合计算的语句。 IoTDB
+支持根据时间间隔和自定义的滑动步长（默认值与时间间隔相同，自定义的值必须大于等于时间间隔）对结果集进行划分，默认结果按照时间升序排列。 同时，您也可以使用 Java JDBC
+标准接口来执行相关的查询语句。
GROUP BY 语句为用户提供三类指定参数：
@@ -679,11 +785,7 @@ GROUP BY 语句为用户提供三类指定参数：
* 参数 2：划分时间轴的时间间隔参数（必须为正数）
* 参数 3：滑动步长（可选参数，默认值与时间间隔相同，自定义的值必须大于等于时间间隔）
-三类参数的实际含义已经在下图中指出，这三类参数里，第三个参数是可选的。
-接下来，我们将给出三种典型的降频聚合查询的例子：
-滑动步长未指定，
-指定滑动步长，
-带值过滤条件。
+三类参数的实际含义已经在下图中指出，这三类参数里，第三个参数是可选的。 接下来，我们将给出三种典型的降频聚合查询的例子： 滑动步长未指定， 指定滑动步长， 带值过滤条件。
<img style="width:100%; max-width:800px; max-height:600px; margin-left:auto; margin-right:auto; display:block;" src="https://user-images.githubusercontent.com/16079446/69109512-f808bc80-0ab2-11ea-9e4d-b2b2f58fb474.png">
@@ -692,17 +794,23 @@ GROUP BY 语句为用户提供三类指定参数：
对应的 SQL 语句是：
```sql
-select count(status), max_value(temperature) from root.ln.wf01.wt01 group by ([2017-11-01T00:00:00, 2017-11-07T23:00:00),1d);
+select count(status), max_value(temperature)
+from root.ln.wf01.wt01
+group by ([2017-11-01T00:00:00, 2017 - 11 - 07T23:00:00), 1d);
```
+
这条查询的含义是：
由于用户没有指定滑动步长，滑动步长将会被默认设置为跟时间间隔参数相同，也就是`1d`。
上面这个例子的第一个参数是显示窗口参数，决定了最终的显示范围是 [2017-11-01T00:00:00, 2017-11-07T23:00:00)。
-上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1d`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[0,1d), [1d, 2d), [2d, 3d) 等等。
+上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1d`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[0,1d), [1d, 2d), [2d, 3d)
+等等。
-然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:00, 2017-11-07 T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到 2017-11-07T23:00:00:00 的每一天）
+然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:
+00, 2017-11-07 T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到
+2017-11-07T23:00:00:00 的每一天）
每个时间间隔窗口内都有数据，SQL 执行后的结果集如下所示：
@@ -727,7 +835,9 @@ It costs 0.024s
对应的 SQL 语句是：
```sql
-select count(status), max_value(temperature) from root.ln.wf01.wt01 group by ([2017-11-01 00:00:00, 2017-11-07 23:00:00), 3h, 1d);
+select count(status), max_value(temperature)
+from root.ln.wf01.wt01
+group by ([2017-11-01 00:00:00, 2017 - 11 - 07 23:00:00), 3h, 1d);
```
这条查询的含义是：
@@ -738,11 +848,15 @@ select count(status), max_value(temperature) from root.ln.wf01.wt01 group by ([2
上面这个例子的第一个参数是显示窗口参数，决定了最终的显示范围是 [2017-11-01T00:00:00, 2017-11-07T23:00:00)。
-上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`3h`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-11-01T00:00:00, 2017-11-01T03:00:00), [2017-11-02T00:00:00, 2017-11-02T03:00:00), [2017-11-03T00:00:00, 2017-11-03T03:00:00) 等等。
+上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`3h`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-11-01T00:00:00,
+2017-11-01T03:00:00), [2017-11-02T00:00:00, 2017-11-02T03:00:00), [2017-11-03T00:00:00,
+2017-11-03T03:00:00) 等等。
上面这个例子的第三个参数是每次时间间隔的滑动步长。
-然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:00, 2017-11-07 T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到 2017-11-07T23:00:00:00 的每一天的凌晨 0 点到凌晨 3 点）
+然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:
+00, 2017-11-07 T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到
+2017-11-07T23:00:00:00 的每一天的凌晨 0 点到凌晨 3 点）
每个时间间隔窗口内都有数据，SQL 执行后的结果集如下所示：
@@ -767,7 +881,10 @@ It costs 0.006s
对应的 SQL 语句是：
```sql
-select count(status) from root.ln.wf01.wt01 where time > 2017-11-01T01:00:00 group by([2017-11-01T00:00:00, 2019-11-07T23:00:00), 1mo, 2mo);
+select count(status)
+from root.ln.wf01.wt01
+where time > 2017-11-01T01:00:00
+group by([2017-11-01T00:00:00, 2019-11-07T23:00:00), 1mo, 2mo);
```
这条查询的含义是：
@@ -780,11 +897,15 @@ select count(status) from root.ln.wf01.wt01 where time > 2017-11-01T01:00:00 gro
起始时间为 2017-11-01T00:00:00，滑动步长将会以起始时间作为标准按月递增，取当月的 1 号作为时间间隔的起始时间。
-上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1mo`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-11-01T00:00:00, 2017-12-01T00:00:00), [2018-02-01T00:00:00, 2018-03-01T00:00:00), [2018-05-03T00:00:00, 2018-06-01T00:00:00) 等等。
+上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1mo`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-11-01T00:00:00,
+2017-12-01T00:00:00), [2018-02-01T00:00:00, 2018-03-01T00:00:00), [2018-05-03T00:00:00,
+2018-06-01T00:00:00) 等等。
上面这个例子的第三个参数是每次时间间隔的滑动步长。
-然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:00, 2019-11-07T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到 2019-11-07T23:00:00:00 的每两个自然月的第一个月）
+然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-11-01T00:00:
+00, 2019-11-07T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-11-01T00:00:00 到 2019-11-07T23:
+00:00:00 的每两个自然月的第一个月）
每个时间间隔窗口内都有数据，SQL 执行后的结果集如下所示：
@@ -811,7 +932,9 @@ select count(status) from root.ln.wf01.wt01 where time > 2017-11-01T01:00:00 gro
对应的 SQL 语句是：
```sql
-select count(status) from root.ln.wf01.wt01 group by([2017-10-31T00:00:00, 2019-11-07T23:00:00), 1mo, 2mo);
+select count(status)
+from root.ln.wf01.wt01
+group by([2017-10-31T00:00:00, 2019 - 11 - 07T23:00:00), 1mo, 2mo);
```
这条查询的含义是：
@@ -820,15 +943,20 @@ select count(status) from root.ln.wf01.wt01 group by([2017-10-31T00:00:00, 2019-
也就意味着，我们想要取从 2017-10-31 到 2019-11-07 每 2 个自然月的第一个月的数据。
-与上述示例不同的是起始时间为 2017-10-31T00:00:00，滑动步长将会以起始时间作为标准按月递增，取当月的 31 号（即最后一天）作为时间间隔的起始时间。若起始时间设置为 30 号，滑动步长会将时间间隔的起始时间设置为当月 30 号，若不存在则为最后一天。
+与上述示例不同的是起始时间为 2017-10-31T00:00:00，滑动步长将会以起始时间作为标准按月递增，取当月的 31 号（即最后一天）作为时间间隔的起始时间。若起始时间设置为 30
+号，滑动步长会将时间间隔的起始时间设置为当月 30 号，若不存在则为最后一天。
上面这个例子的第一个参数是显示窗口参数，决定了最终的显示范围是 [2017-10-31T00:00:00, 2019-11-07T23:00:00)。
-上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1mo`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-10-31T00:00:00, 2017-11-31T00:00:00), [2018-02-31T00:00:00, 2018-03-31T00:00:00), [2018-05-31T00:00:00, 2018-06-31T00:00:00) 等等。
+上面这个例子的第二个参数是划分时间轴的时间间隔参数，将`1mo`当作划分间隔，显示窗口参数的起始时间当作分割原点，时间轴即被划分为连续的时间间隔：[2017-10-31T00:00:00,
+2017-11-31T00:00:00), [2018-02-31T00:00:00, 2018-03-31T00:00:00), [2018-05-31T00:00:00,
+2018-06-31T00:00:00) 等等。
上面这个例子的第三个参数是每次时间间隔的滑动步长。
-然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-10-31T00:00:00, 2019-11-07T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-10-31T00:00:00 到 2019-11-07T23:00:00:00 的每两个自然月的第一个月）
+然后系统将会用 WHERE 子句中的时间和值过滤条件以及 GROUP BY 语句中的第一个参数作为数据的联合过滤条件，获得满足所有过滤条件的数据（在这个例子里是在 [2017-10-31T00:00:
+00, 2019-11-07T23:00:00) 这个时间范围的数据），并把这些数据映射到之前分割好的时间轴中（这个例子里是从 2017-10-31T00:00:00 到 2019-11-07T23:
+00:00:00 的每两个自然月的第一个月）
每个时间间隔窗口内都有数据，SQL 执行后的结果集如下所示：
@@ -857,7 +985,9 @@ select count(status) from root.ln.wf01.wt01 group by([2017-10-31T00:00:00, 2019-
每个区间的结果时间戳为区间右端点，对应的 SQL 语句是：
```sql
-select count(status) from root.ln.wf01.wt01 group by ((2017-11-01T00:00:00, 2017-11-07T23:00:00],1d);
+select count(status)
+from root.ln.wf01.wt01
+group by ((2017 - 11 - 01T00:00:00, 2017 - 11 - 07T23:00:00], 1d);
```
这条查询语句的时间区间是左开右闭的，结果中不会包含时间点 2017-11-01 的数据，但是会包含时间点 2017-11-07 的数据。
@@ -914,8 +1044,12 @@ root.ln.wf01.wt01.temperature 最早时间和值是 2017-11-07T23:49:00 和 23.7
SQL 示例：
```sql
-SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (PREVIOUSUNTILLAST);
-SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (PREVIOUS);
+SELECT last_value(temperature)
+FROM root.ln.wf01.wt01
+GROUP BY([2017-11-07T23:50:00, 2017 - 11 - 07T23:59:00), 1m) FILL (PREVIOUSUNTILLAST);
+SELECT last_value(temperature)
+FROM root.ln.wf01.wt01
+GROUP BY([2017-11-07T23:50:00, 2017 - 11 - 07T23:59:00), 1m) FILL (PREVIOUS);
```
结果：
@@ -960,13 +1094,17 @@ It costs 0.006s
使用 PREVIOUSUNTILLAST 将不会填充 2017-11-07T23:57:00 以后的值。
-此外，第一个时间区间 [2017-11-07T23:50:00, 2017-11-07T23:51:00) 内没有任何数据，上一个有数据的时间区间是 [2017-11-01T23:49:00, 2017-11-07T23:50:00)，可以通过设置 PREVIOUS 填充向前查询参数 beforeRange 来填充第一个区间的数据，示例如下：
+此外，第一个时间区间 [2017-11-07T23:50:00, 2017-11-07T23:51:00) 内没有任何数据，上一个有数据的时间区间是 [2017-11-01T23:49:00,
+2017-11-07T23:50:00)，可以通过设置 PREVIOUS 填充向前查询参数 beforeRange 来填充第一个区间的数据，示例如下：
```sql
-SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (PREVIOUS, 1m);
+SELECT last_value(temperature)
+FROM root.ln.wf01.wt01
+GROUP BY([2017-11-07T23:50:00, 2017 - 11 - 07T23:59:00), 1m) FILL (PREVIOUS, 1m);
```
结果：
+
```
IoTDB> SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (PREVIOUS, 1m);
+-----------------------------+-----------------------------------------+
@@ -988,16 +1126,22 @@ It costs 0.005s
解释：
-因为 beforeRange 参数同时设定了向前查询的最大值，而时间区间 [2017-11-07T23:55:00, 2017-11-07T23:57:00) 内均没有数据，所以不填充 [2017-11-07T23:56:00, 2017-11-07T23:57:00)。在不指定 beforeRange 时，前值填充默认使用查询范围内上一个非空值
+因为 beforeRange 参数同时设定了向前查询的最大值，而时间区间 [2017-11-07T23:55:00, 2017-11-07T23:57:00) 内均没有数据，所以不填充 [
+2017-11-07T23:56:00, 2017-11-07T23:57:00)。在不指定 beforeRange 时，前值填充默认使用查询范围内上一个非空值
时间区间分组聚合查询结果也支持使用 VALUE 和 LINEAR 方式进行填充，示例如下：
```sql
-SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (10.0);
-SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (LINEAR, 5m, 5m);
+SELECT last_value(temperature)
+FROM root.ln.wf01.wt01
+GROUP BY([2017-11-07T23:50:00, 2017 - 11 - 07T23:59:00), 1m) FILL (10.0);
+SELECT last_value(temperature)
+FROM root.ln.wf01.wt01
+GROUP BY([2017-11-07T23:50:00, 2017 - 11 - 07T23:59:00), 1m) FILL (LINEAR, 5m, 5m);
```
结果：
+
```
IoTDB> SELECT last_value(temperature) FROM root.ln.wf01.wt01 GROUP BY([2017-11-07T23:50:00, 2017-11-07T23:59:00),1m) FILL (10.0);
+-----------------------------+-----------------------------------------+
@@ -1047,7 +1191,9 @@ It costs 0.008s
统计降采样后的数据点个数
```sql
-select count(status) from root.ln.wf01.wt01 group by ((2017-11-01T00:00:00, 2017-11-07T23:00:00],1d), level=1;
+select count(status)
+from root.ln.wf01.wt01
+group by ((2017 - 11 - 01T00:00:00, 2017 - 11 - 07T23:00:00], 1d), level = 1;
```
结果：
@@ -1071,7 +1217,9 @@ It costs 0.006s
加上滑动 Step 的降采样后的结果也可以汇总
```sql
-select count(status) from root.ln.wf01.wt01 group by ([0,20),2ms,3ms), level=1;
+select count(status)
+from root.ln.wf01.wt01
+group by ([0,20), 2ms, 3ms), level=1;
```
```
@@ -1089,6 +1237,7 @@ select count(status) from root.ln.wf01.wt01 group by ([0,20),2ms,3ms), level=1;
Total line number = 7
It costs 0.004s
```
+
#### 聚合查询嵌套表达式
IoTDB 支持在 `SELECT` 字句中执行由聚合查询和其他运算组成的任意嵌套表达式。
@@ -1190,7 +1339,8 @@ It costs 0.012s
### 空值填充
-在 IoTDB 的实际使用中，当进行时间序列的查询操作时，可能会出现在某些时间点值为 null 的情况，这会妨碍用户进行进一步的分析。 为了更好地反映数据更改的程度，用户希望可以自动填充缺失值。 因此，IoTDB 系统引入了自动填充功能。
+在 IoTDB 的实际使用中，当进行时间序列的查询操作时，可能会出现在某些时间点值为 null 的情况，这会妨碍用户进行进一步的分析。 为了更好地反映数据更改的程度，用户希望可以自动填充缺失值。
+因此，IoTDB 系统引入了自动填充功能。
自动填充功能是指对单列或多列执行时间序列查询时，根据用户指定的方法和有效时间范围填充空值。 如果查询点的值不为 null，则填充功能将不起作用。
@@ -1201,7 +1351,9 @@ It costs 0.012s
当查询的时间戳值为空时，将使用前一个时间戳的值来填充空白。 形式化的先前方法如下（有关详细语法，请参见第 7.1.3.6 节）：
```sql
-select <path> from <prefixPath> where time = <T> fill(previous(, <before_range>)?)
+select < path >
+from <prefixPath>
+where time = <T> fill(previous(, <before_range>)?)
```
表 3-4 给出了所有参数的详细说明。
@@ -1221,14 +1373,18 @@ select <path> from <prefixPath> where time = <T> fill(previous(, <before_range>)
在这里，我们举一个使用先前方法填充空值的示例。 SQL 语句如下：
```sql
-select temperature from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill(previous, 1m)
+select temperature
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill(previous, 1m)
```
意思是：
-由于时间根目录 root.sgcc.wf03.wt01.temperature 在 2017-11-01T16：37：50.000 为空，因此系统使用以前的时间戳 2017-11-01T16：37：00.000（且时间戳位于 [2017-11-01T16:36:50.000, 2017-11-01T16:37:50.000] 范围）进行填充和显示。
+由于时间根目录 root.sgcc.wf03.wt01.temperature 在 2017-11-01T16：37：50.000 为空，因此系统使用以前的时间戳
+2017-11-01T16：37：00.000（且时间戳位于 [2017-11-01T16:36:50.000, 2017-11-01T16:37:50.000] 范围）进行填充和显示。
-在 [样例数据中](https://github.com/thulab/iotdb/files/4438687/OtherMaterial-Sample.Data.txt), 该语句的执行结果如下所示：
+在 [样例数据中](https://github.com/thulab/iotdb/files/4438687/OtherMaterial-Sample.Data.txt),
+该语句的执行结果如下所示：
```
+-----------------------------+-------------------------------+
@@ -1258,7 +1414,9 @@ It costs 0.004s
当查询的时间戳值为空时，将使用前一个和下一个时间戳的值来填充空白。 形式化线性方法如下：
```sql
-select <path> from <prefixPath> where time = <T> fill(linear(, <before_range>, <after_range>)?)
+select < path >
+from <prefixPath>
+where time = <T > fill(linear(, <before_range >, <after_range >)?)
```
表 3-5 中给出了所有参数的详细说明。
@@ -1275,18 +1433,23 @@ select <path> from <prefixPath> where time = <T> fill(linear(, <before_range>, <
</center>
-需要注意的是一旦时间序列在查询时间戳 T 时刻存在有效值，线性填充就会使用这个值作为结果返回。
-除此之外，如果在 [T-before_range，T] 或 [T, T + after_range] 两个范围中任意一个范围内不存在有效填充值，则线性填充返回 null 值。
+需要注意的是一旦时间序列在查询时间戳 T 时刻存在有效值，线性填充就会使用这个值作为结果返回。 除此之外，如果在 [T-before_range，T] 或 [T, T + after_range]
+两个范围中任意一个范围内不存在有效填充值，则线性填充返回 null 值。
在这里，我们举一个使用线性方法填充空值的示例。 SQL 语句如下：
```sql
-select temperature from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill(linear, 1m, 1m)
+select temperature
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill(linear, 1m, 1m)
```
意思是：
-由于时间根目录 root.sgcc.wf03.wt01.temperature 在 2017-11-01T16：37：50.000 为空，因此系统使用以前的时间戳 2017-11-01T16：37：00.000（且时间戳位于 [2017- 11-01T16：36：50.000，2017-11-01T16：37：50.000] 时间范围）及其值 21.927326，下一个时间戳记 2017-11-01T16：38：00.000（且时间戳记位于 [2017-11-11] 01T16：37：50.000、2017-11-01T16：38：50.000] 时间范围）及其值 25.311783 以执行线性拟合计算：
+由于时间根目录 root.sgcc.wf03.wt01.temperature 在 2017-11-01T16：37：50.000 为空，因此系统使用以前的时间戳
+2017-11-01T16：37：00.000（且时间戳位于 [2017- 11-01T16：36：50.000，2017-11-01T16：37：50.000] 时间范围）及其值
+21.927326，下一个时间戳记 2017-11-01T16：38：00.000（且时间戳记位于 [2017-11-11]
+01T16：37：50.000、2017-11-01T16：38：50.000] 时间范围）及其值 25.311783 以执行线性拟合计算：
21.927326 +（25.311783-21.927326）/ 60s * 50s = 24.747707
@@ -1307,7 +1470,9 @@ It costs 0.017s
当查询的时间戳值为空时，将使用给定的值来填充空白。 特定值填充方法如下：
```sql
-select <path> from <prefixPath> where time = <T> fill(constant)
+select < path >
+from <prefixPath>
+where time = <T> fill(constant)
```
表3-6中给出了所有参数的详细说明。
@@ -1326,11 +1491,12 @@ select <path> from <prefixPath> where time = <T> fill(constant)
需要注意的是一旦时间序列在查询时间戳T时刻存在有效值，特定值填充就会使用这个值作为结果返回。
-
在这里，我们举一个使用特定值方法填充空值的示例。 SQL语句如下：
```sql
-select temperature from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill(2.0)
+select temperature
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill(2.0)
```
意思是：
@@ -1352,11 +1518,15 @@ It costs 0.007s
在使用 VALUE 方法填充时需要注意，如果查询结果的数据类型与输入常量值不同，IoTDB 将不进行填充
示例：
+
```sql
-select temperature from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill('test')
+select temperature
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill('test')
```
结果：
+
```
+-----------------------------+-------------------------------+
| Time|root.sgcc.wf03.wt01.temperature|
@@ -1393,7 +1563,8 @@ It costs 0.007s
SQL 语法：
```sql
-select last <Path> [COMMA <Path>]* from < PrefixPath > [COMMA < PrefixPath >]* <WhereClause>
+select last < Path > [COMMA < Path >]*
+from < PrefixPath > [COMMA < PrefixPath >]* <WhereClause>
```
其含义是：查询时间序列 prefixPath.path 中最近时间戳的数据
@@ -1515,12 +1686,14 @@ It costs 0.002s
### 别名
-由于 IoTDB 独特的数据模型，在每个传感器前都附带有设备等诸多额外信息。有时，我们只针对某个具体设备查询，而这些前缀信息频繁显示造成了冗余，影响了结果集的显示与分析。这时我们可以使用 IoTDB 提供的 AS 函数，将查询中出现的时间序列给定一个别名。
+由于 IoTDB 独特的数据模型，在每个传感器前都附带有设备等诸多额外信息。有时，我们只针对某个具体设备查询，而这些前缀信息频繁显示造成了冗余，影响了结果集的显示与分析。这时我们可以使用 IoTDB
+提供的 AS 函数，将查询中出现的时间序列给定一个别名。
例如：
```sql
-select s1 as temperature, s2 as speed from root.ln.wf01.wt01;
+select s1 as temperature, s2 as speed
+from root.ln.wf01.wt01;
```
则结果集将显示为：
@@ -1531,8 +1704,9 @@ select s1 as temperature, s2 as speed from root.ln.wf01.wt01;
### 结果集行列输出控制 (LIMIT & OFFSET)
-IoTDB 提供 [LIMIT/SLIMIT](../Appendix/SQL-Reference.md) 子句和 [OFFSET/SOFFSET](../Appendix/SQL-Reference.md) 子句，以使用户可以更好地控制查询结果。使用 LIMIT 和 SLIMIT 子句可让用户控制查询结果的行数和列数，
-并且使用 OFFSET 和 SOFSET 子句允许用户设置结果显示的起始位置。
+IoTDB 提供 [LIMIT/SLIMIT](../Appendix/SQL-Reference.md)
+子句和 [OFFSET/SOFFSET](../Appendix/SQL-Reference.md) 子句，以使用户可以更好地控制查询结果。使用 LIMIT 和 SLIMIT
+子句可让用户控制查询结果的行数和列数， 并且使用 OFFSET 和 SOFSET 子句允许用户设置结果显示的起始位置。
请注意，按组查询不支持 LIMIT 和 OFFSET。
@@ -1547,7 +1721,8 @@ IoTDB 提供 [LIMIT/SLIMIT](../Appendix/SQL-Reference.md) 子句和 [OFFSET/SOFF
SQL 语句是：
```sql
-select status, temperature from root.ln.wf01.wt01 limit 10
+select status, temperature
+from root.ln.wf01.wt01 limit 10
```
意思是：
@@ -1580,7 +1755,9 @@ It costs 0.000s
SQL 语句是：
```sql
-select status, temperature from root.ln.wf01.wt01 limit 5 offset 3
+select status, temperature
+from root.ln.wf01.wt01 limit 5
+offset 3
```
意思是：
@@ -1608,12 +1785,16 @@ It costs 0.342s
SQL 语句是：
```sql
-select status,temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time< 2017-11-01T00:12:00.000 limit 5 offset 3
+select status, temperature
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 5
+offset 3
```
意思是：
-所选设备为 ln 组 wf01 工厂 wt01 设备； 选择的时间序列是“状态”和“温度”。 SQL 语句要求返回时间“ 2017-11-01T00：05：00.000”和“ 2017-11-01T00：12：00.000”之间的状态和温度传感器值的第 3 至 4 行（第一行） 编号为第 0 行）。
+所选设备为 ln 组 wf01 工厂 wt01 设备； 选择的时间序列是“状态”和“温度”。 SQL 语句要求返回时间“ 2017-11-01T00：05：00.000”和“
+2017-11-01T00：12：00.000”之间的状态和温度传感器值的第 3 至 4 行（第一行） 编号为第 0 行）。
结果如下所示：
@@ -1636,7 +1817,10 @@ It costs 0.000s
SQL 语句是：
```sql
-select count(status), max_value(temperature) from root.ln.wf01.wt01 group by ([2017-11-01T00:00:00, 2017-11-07T23:00:00),1d) limit 4 offset 3
+select count(status), max_value(temperature)
+from root.ln.wf01.wt01
+group by ([2017-11-01T00:00:00, 2017 - 11 - 07T23:00:00), 1d) limit 4
+offset 3
```
意思是：
@@ -1658,10 +1842,13 @@ Total line number = 4
It costs 0.016s
```
-值得注意的是，由于当前的 FILL 子句只能在某个时间点填充时间序列的缺失值，也就是说，FILL 子句的执行结果恰好是一行，因此 LIMIT 和 OFFSET 不会是 与 FILL 子句结合使用，否则将提示错误。 例如，执行以下 SQL 语句：
+值得注意的是，由于当前的 FILL 子句只能在某个时间点填充时间序列的缺失值，也就是说，FILL 子句的执行结果恰好是一行，因此 LIMIT 和 OFFSET 不会是 与 FILL
+子句结合使用，否则将提示错误。 例如，执行以下 SQL 语句：
```sql
-select temperature from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill(float[previous, 1m]) limit 10
+select temperature
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill(float [previous, 1m]) limit 10
```
SQL 语句将不会执行，并且相应的错误提示如下：
@@ -1679,12 +1866,15 @@ Msg: 401: Error occured while parsing SQL to physical plan: line 1:101 mismatche
SQL 语句是：
```sql
-select * from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 slimit 1
+select *
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 slimit 1
```
意思是：
-所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是该设备下的第二列，即温度。 SQL 语句要求在"2017-11-01T00:05:00.000"和"2017-11-01T00:12:00.000"的时间点之间选择温度传感器值。
+所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是该设备下的第二列，即温度。 SQL 语句要求在"2017-11-01T00:05:00.000"和"2017-11-01T00:
+12:00.000"的时间点之间选择温度传感器值。
结果如下所示：
@@ -1708,12 +1898,15 @@ It costs 0.000s
SQL 语句是：
```sql
-select * from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 slimit 1 soffset 1
+select *
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 slimit 1 soffset 1
```
意思是：
-所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是该设备下的第一列，即电源状态。 SQL 语句要求在" 2017-11-01T00:05:00.000"和"2017-11-01T00:12:00.000"的时间点之间选择状态传感器值。
+所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是该设备下的第一列，即电源状态。 SQL 语句要求在" 2017-11-01T00:05:00.000"和"
+2017-11-01T00:12:00.000"的时间点之间选择状态传感器值。
结果如下所示：
@@ -1737,7 +1930,9 @@ It costs 0.003s
SQL 语句是：
```sql
-select max_value(*) from root.ln.wf01.wt01 group by ([2017-11-01T00:00:00, 2017-11-07T23:00:00),1d) slimit 1 soffset 1
+select max_value(*)
+from root.ln.wf01.wt01
+group by ([2017-11-01T00:00:00, 2017 - 11 - 07T23:00:00), 1d) slimit 1 soffset 1
```
结果如下所示：
@@ -1763,7 +1958,9 @@ It costs 0.000s
SQL 语句是：
```sql
-select * from root.sgcc.wf03.wt01 where time = 2017-11-01T16:37:50.000 fill(float[previous, 1m]) slimit 1 soffset 1
+select *
+from root.sgcc.wf03.wt01
+where time = 2017-11-01T16:37:50.000 fill(float [previous, 1m]) slimit 1 soffset 1
```
结果如下所示：
@@ -1785,12 +1982,15 @@ It costs 0.007s
SQL 语句是：
```sql
-select * from root.ln.wf01.wt01 limit 10 offset 100 slimit 2 soffset 0
+select *
+from root.ln.wf01.wt01 limit 10
+offset 100 slimit 2 soffset 0
```
意思是：
-所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是此设备下的第 0 列至第 1 列（第一列编号为第 0 列）。 SQL 语句子句要求返回查询结果的第 100 至 109 行（第一行编号为 0 行）。
+所选设备为 ln 组 wf01 工厂 wt01 设备； 所选时间序列是此设备下的第 0 列至第 1 列（第一列编号为第 0 列）。 SQL 语句子句要求返回查询结果的第 100 至 109
+行（第一行编号为 0 行）。
结果如下所示：
@@ -1815,10 +2015,13 @@ It costs 0.009s
#### 错误处理
-当 LIMIT / SLIMIT 的参数 N / SN 超过结果集的大小时，IoTDB 将按预期返回所有结果。 例如，原始 SQL 语句的查询结果由六行组成，我们通过 LIMIT 子句选择前 100 行：
+当 LIMIT / SLIMIT 的参数 N / SN 超过结果集的大小时，IoTDB 将按预期返回所有结果。 例如，原始 SQL 语句的查询结果由六行组成，我们通过 LIMIT 子句选择前 100
+行：
```sql
-select status,temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 100
+select status, temperature
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 100
```
结果如下所示：
@@ -1841,7 +2044,12 @@ It costs 0.005s
当 LIMIT / SLIMIT 子句的参数 N / SN 超过允许的最大值（N / SN 的类型为 int32）时，系统将提示错误。 例如，执行以下 SQL 语句：
```sql
-select status,temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 1234567890123456789
+select status, temperature
+from root.ln.wf01.wt01
+where time
+ > 2017-11-01T00:05:00.000
+ and time
+ < 2017-11-01T00:12:00.000 limit 1234567890123456789
```
SQL 语句将不会执行，并且相应的错误提示如下：
@@ -1853,7 +2061,9 @@ Msg: 303: check metadata error: Out of range. LIMIT <N>: N should be Int32.
当 LIMIT / LIMIT 子句的参数 N / SN 不是正整数时，系统将提示错误。 例如，执行以下 SQL 语句：
```sql
-select status,temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 13.1
+select status, temperature
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 13.1
```
SQL 语句将不会执行，并且相应的错误提示如下：
@@ -1865,7 +2075,10 @@ Msg: 401: line 1:129 mismatched input '.' expecting {<EOF>, ';'}
当 LIMIT 子句的参数 OFFSET 超过结果集的大小时，IoTDB 将返回空结果集。 例如，执行以下 SQL 语句：
```sql
-select status,temperature from root.ln.wf01.wt01 where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 2 offset 6
+select status, temperature
+from root.ln.wf01.wt01
+where time > 2017-11-01T00:05:00.000 and time < 2017-11-01T00:12:00.000 limit 2
+offset 6
```
结果如下所示：
@@ -1883,13 +2096,17 @@ It costs 0.005s
* 如果结果集中，任意一列为 null，则过滤掉该行；即获得的结果集不包含任何空值
```sql
-select * from root.ln.** where time <= 2017-11-01T00:01:00 WITHOUT NULL ANY
+select *
+from root.ln.**
+where time <= 2017-11-01T00:01:00 WITHOUT NULL ANY
```
* 在降采样查询中，如果结果集的某一行所有列都为 null，则过滤掉该行；即获得的结果集不包含所有值都为 null 的行
```sql
-select * from root.ln.** where time <= 2017-11-01T00:01:00 WITHOUT NULL ALL
+select *
+from root.ln.**
+where time <= 2017-11-01T00:01:00 WITHOUT NULL ALL
```
### 其他对齐方式的结果集
@@ -1901,7 +2118,9 @@ IoTDB 支持另外两种结果返回形式：按设备时间对齐 'align by dev
'align by device' 对齐方式下，设备 ID 会单独作为一列出现。在 select 子句中写了多少列，最终结果就会有该列数+2 （时间列和设备名字列）。SQL 形如：
```sql
-select * from root.ln.** where time <= 2017-11-01T00:01:00 align by device
+select *
+from root.ln.**
+where time <= 2017-11-01T00:01:00 align by device
```
结果如下：
@@ -1923,12 +2142,15 @@ It costs 0.012s
#### disable align
-'disable align' 意味着每条时序就有 2 列存在。Disable Align 只能用于查询语句句尾，不能用于聚合查询、Fill 语句、Group by 或 Group by device 语句，但可用于 Limit 语句。结果显示若无数据显示为空白。
+'disable align' 意味着每条时序就有 2 列存在。Disable Align 只能用于查询语句句尾，不能用于聚合查询、Fill 语句、Group by 或 Group by device
+语句，但可用于 Limit 语句。结果显示若无数据显示为空白。
SQL 形如：
```sql
-select * from root.ln.** where time <= 2017-11-01T00:01:00 disable align
+select *
+from root.ln.**
+where time <= 2017-11-01T00:01:00 disable align
```
结果如下：
@@ -1950,7 +2172,8 @@ It costs 0.018s
## 数据删除
-用户使用 [DELETE 语句](../Appendix/SQL-Reference.md) 可以删除指定的时间序列中符合时间删除条件的数据。在删除数据时，用户可以选择需要删除的一个或多个时间序列、时间序列的前缀、时间序列带、*路径对某一个时间区间内的数据进行删除。
+用户使用 [DELETE 语句](../Appendix/SQL-Reference.md)
+可以删除指定的时间序列中符合时间删除条件的数据。在删除数据时，用户可以选择需要删除的一个或多个时间序列、时间序列的前缀、时间序列带、*路径对某一个时间区间内的数据进行删除。
在 JAVA 编程环境中，您可以使用 JDBC API 单条或批量执行 DELETE 语句。
@@ -1958,29 +2181,51 @@ It costs 0.018s
以测控 ln 集团为例，存在这样的使用场景：
-wf02 子站的 wt02 设备在 2017-11-01 16:26:00 之前的供电状态出现多段错误，且无法分析其正确数据，错误数据影响了与其他设备的关联分析。此时，需要将此时间段前的数据删除。进行此操作的 SQL 语句为：
+wf02 子站的 wt02 设备在 2017-11-01 16:26:00
+之前的供电状态出现多段错误，且无法分析其正确数据，错误数据影响了与其他设备的关联分析。此时，需要将此时间段前的数据删除。进行此操作的 SQL 语句为：
```sql
-delete from root.ln.wf02.wt02.status where time<=2017-11-01T16:26:00;
+delete
+from root.ln.wf02.wt02.status
+where time<=2017-11-01T16:26:00;
```
如果我们仅仅想要删除 2017 年内的在 2017-11-01 16:26:00 之前的数据，可以使用以下 SQL:
+
```sql
-delete from root.ln.wf02.wt02.status where time>=2017-01-01T00:00:00 and time<=2017-11-01T16:26:00;
+delete
+from root.ln.wf02.wt02.status
+where time>=2017-01-01T00:00:00 and time<=2017-11-01T16:26:00;
```
IoTDB 支持删除一个时间序列任何一个时间范围内的所有时序点，用户可以使用以下 SQL 语句指定需要删除的时间范围：
+
```sql
-delete from root.ln.wf02.wt02.status where time < 10
-delete from root.ln.wf02.wt02.status where time <= 10
-delete from root.ln.wf02.wt02.status where time < 20 and time > 10
-delete from root.ln.wf02.wt02.status where time <= 20 and time >= 10
-delete from root.ln.wf02.wt02.status where time > 20
-delete from root.ln.wf02.wt02.status where time >= 20
-delete from root.ln.wf02.wt02.status where time = 20
+delete
+from root.ln.wf02.wt02.status
+where time < 10
+delete
+from root.ln.wf02.wt02.status
+where time <= 10
+delete
+from root.ln.wf02.wt02.status
+where time < 20 and time > 10
+delete
+from root.ln.wf02.wt02.status
+where time <= 20 and time >= 10
+delete
+from root.ln.wf02.wt02.status
+where time > 20
+delete
+from root.ln.wf02.wt02.status
+where time >= 20
+delete
+from root.ln.wf02.wt02.status
+where time = 20
```
需要注意，当前的删除语句不支持 where 子句后的时间范围为多个由 OR 连接成的时间区间。如下删除语句将会解析出错：
+
```
delete from root.ln.wf02.wt02.status where time > 4 or time < 0
Msg: 303: Check metadata error: For delete statement, where clause can only contain atomic
@@ -1988,31 +2233,42 @@ expressions like : time > XXX, time <= XXX, or two atomic expressions connected
```
如果 delete 语句中未指定 where 子句，则会删除时间序列中的所有数据。
+
```sql
-delete from root.ln.wf02.status
+delete
+from root.ln.wf02.status
```
-### 多传感器时间序列值删除
-
-当 ln 集团 wf02 子站的 wt02 设备在 2017-11-01 16:26:00 之前的供电状态和设备硬件版本都需要删除，此时可以使用含义更广的 [路径模式（Path Pattern）](../Data-Concept/Data-Model-and-Terminology.md) 进行删除操作，进行此操作的 SQL 语句为：
+### 多传感器时间序列值删除
+当 ln 集团 wf02 子站的 wt02 设备在 2017-11-01 16:26:00
+之前的供电状态和设备硬件版本都需要删除，此时可以使用含义更广的 [路径模式（Path Pattern）](../Data-Concept/Data-Model-and-Terminology.md)
+进行删除操作，进行此操作的 SQL 语句为：
```sql
-delete from root.ln.wf02.wt02.* where time <= 2017-11-01T16:26:00;
+delete
+from root.ln.wf02.wt02.*
+where time <= 2017-11-01T16:26:00;
```
需要注意的是，当删除的路径不存在时，IoTDB 不会提示路径不存在，而是显示执行成功，因为 SQL 是一种声明式的编程方式，除非是语法错误、权限不足等，否则都不认为是错误，如下所示。
```sql
-IoTDB> delete from root.ln.wf03.wt02.status where time < now()
+IoTDB
+>
+delete
+from root.ln.wf03.wt02.status
+where time < now()
Msg: TimeSeries does not exist and its data cannot be deleted
```
### 删除时间分区 （实验性功能）
+
您可以通过如下语句来删除某一个存储组下的指定时间分区：
```sql
-DELETE PARTITION root.ln 0,1,2
+DELETE
+PARTITION root.ln 0,1,2
```
上例中的 0,1,2 为待删除时间分区的 id，您可以通过查看 IoTDB 的数据文件夹找到它，或者可以通过计算`timestamp / partitionInterval`（向下取整）,