Merge branch '3.0' into feature/3_liaohj

docs/en/07-develop/01-connect/index.md

@@ -68,7 +68,7 @@ After the above installation and configuration are done and making sure TDengine
 
 <Tabs groupId="lang">
 <TabItem label="Java" value="java">
-  
+
 If `maven` is used to manage the projects, what needs to be done is only adding below dependency in `pom.xml`.
 
 ```xml
@@ -138,19 +138,19 @@ Node.js connector provides different ways of establishing connections by providi
 
 1. Install Node.js Native Connector
 
-  ```
-  npm install @tdengine/client
-  ```
+```
+npm install @tdengine/client
+```
 
 :::note
 It's recommend to use Node whose version is between `node-v12.8.0` and `node-v13.0.0`.
-::: 
-  
+:::
+
 2. Install Node.js REST Connector
 
-  ```
-  npm install @tdengine/rest
-  ```
+```
+npm install @tdengine/rest
+```
 
 </TabItem>
 <TabItem label="C#" value="csharp">

docs/en/07-develop/02-model/index.mdx

@@ -2,12 +2,10 @@
 title: Data Model
 ---
 
-The data model employed by TDengine is similar to that of a relational database. You have to create databases and tables. You must design the data model based on your own business and application requirements. You should design the [STable](/concept/#super-table-stable) (an abbreviation for super table) schema to fit your data. This chapter will explain the big picture without getting into syntactical details. 
+The data model employed by TDengine is similar to that of a relational database. You have to create databases and tables. You must design the data model based on your own business and application requirements. You should design the [STable](/concept/#super-table-stable) (an abbreviation for super table) schema to fit your data. This chapter will explain the big picture without getting into syntactical details.
 
 Note: before you read this chapter, please make sure you have already read through [Key Concepts](/concept/), since TDengine introduces new concepts like "one table for one [data collection point](/concept/#data-collection-point)" and "[super table](/concept/#super-table-stable)".
 
-
-
 ## Create Database
 
 The characteristics of time-series data from different data collection points may be different. Characteristics include collection frequency, retention policy and others which determine how you create and configure the database. For e.g. days to keep, number of replicas, data block size, whether data updates are allowed and other configurable parameters would be determined by the characteristics of your data and your business requirements. For TDengine to operate with the best performance, we strongly recommend that you create and configure different databases for data with different characteristics. This allows you, for example, to set up different storage and retention policies. When creating a database, there are a lot of parameters that can be configured such as, the days to keep data, the number of replicas, the size of the cache, time precision, the minimum and maximum number of rows in each data block, whether compression is enabled, the time range of the data in single data file and so on. An example is shown as follows:
@@ -17,10 +15,11 @@ CREATE DATABASE power KEEP 365 DURATION 10 BUFFER 16 WAL_LEVEL 1;
 ```
 
 In the above SQL statement:
+
 - a database named "power" is created
 - the data in it is retained for 365 days, which means that data older than 365 days will be deleted automatically
 - a new data file will be created every 10 days
-- the size of the write cache pool on each vnode is 16 MB
+- the size of the write cache pool on each VNode is 16 MB
 - the number of vgroups is 100
 - WAL is enabled but fsync is disabled For more details please refer to [Database](/taos-sql/database).
 

docs/en/07-develop/03-insert-data/02-influxdb-line.mdx

@@ -24,7 +24,7 @@ measurement,tag_set field_set timestamp
 - `measurement` will be used as the name of the STable Enter a comma (,) between `measurement` and `tag_set`.
 - `tag_set` will be used as tags, with format like `<tag_key>=<tag_value>,<tag_key>=<tag_value>` Enter a space between `tag_set` and `field_set`.
 - `field_set`will be used as data columns, with format like `<field_key>=<field_value>,<field_key>=<field_value>` Enter a space between `field_set` and `timestamp`.
-- `timestamp`  is the primary key timestamp corresponding to this row of data
+- `timestamp` is the primary key timestamp corresponding to this row of data
 
 For example:
 
@@ -34,12 +34,12 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
 
 :::note
 
-- All the data in `tag_set` will be converted to nchar type automatically .
+- All the data in `tag_set` will be converted to NCHAR type automatically .
 - Each data in `field_set` must be self-descriptive for its data type. For example 1.2f32 means a value 1.2 of float type. Without the "f" type suffix, it will be treated as type double.
 - Multiple kinds of precision can be used for the `timestamp` field. Time precision can be from nanosecond (ns) to hour (h).
 - You can configure smlChildTableName in taos.cfg to specify table names, for example, `smlChildTableName=tname`. You can insert `st,tname=cpul,t1=4 c1=3 1626006833639000000` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
 - It is assumed that the order of field_set in a supertable is consistent, meaning that the first record contains all fields and subsequent records store fields in the same order. If the order is not consistent, set smlDataFormat in taos.cfg to false. Otherwise, data will be written out of order and a database error will occur.(smlDataFormat in taos.cfg default to false after version of 3.0.1.3)
-:::
+  :::
 
 For more details please refer to [InfluxDB Line Protocol](https://docs.influxdata.com/influxdb/v2.0/reference/syntax/line-protocol/) and [TDengine Schemaless](/reference/schemaless/#Schemaless-Line-Protocol)
 
@@ -67,5 +67,9 @@ For more details please refer to [InfluxDB Line Protocol](https://docs.influxdat
 </Tabs>
 
 ## Query Examples
-If you want query the data of `location=California.LosAngeles,groupid=2`，here is the query sql：
-select * from `meters.voltage` where location="California.LosAngeles" and groupid=2
+
+If you want query the data of `location=California.LosAngeles,groupid=2`，here is the query SQL:
+
+```sql
+SELECT * FROM meters WHERE location = "California.LosAngeles" AND groupid = 2;
+```

docs/en/07-develop/03-insert-data/03-opentsdb-telnet.mdx

@@ -24,15 +24,16 @@ A single line of text is used in OpenTSDB line protocol to represent one row of
 - `metric` will be used as the STable name.
 - `timestamp` is the timestamp of current row of data. The time precision will be determined automatically based on the length of the timestamp. Second and millisecond time precision are supported.
 - `value` is a metric which must be a numeric value, The corresponding column name is "value".
-- The last part is the tag set separated by spaces, all tags will be converted to nchar type automatically.
+- The last part is the tag set separated by spaces, all tags will be converted to NCHAR type automatically.
 
 For example:
 
 ```txt
 meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
 ```
-- The defult child table name is generated by rules.You can configure smlChildTableName in taos.cfg to specify chile table names, for example, `smlChildTableName=tname`. You can insert `meters.current 1648432611250 11.3 tname=cpu1 location=California.LosAngeles groupid=3` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
-Please refer to [OpenTSDB Telnet API](http://opentsdb.net/docs/build/html/api_telnet/put.html) for more details.
+
+- The defult child table name is generated by rules.You can configure smlChildTableName in taos.cfg to specify child table names, for example, `smlChildTableName=tname`. You can insert `meters.current 1648432611250 11.3 tname=cpu1 location=California.LosAngeles groupid=3` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
+  Please refer to [OpenTSDB Telnet API](http://opentsdb.net/docs/build/html/api_telnet/put.html) for more details.
 
 ## Examples
 
@@ -79,6 +80,11 @@ taos> select tbname, * from `meters.current`;
  t_7e7b26dd860280242c6492a16... | 2022-03-28 09:56:51.250 |              12.600000000 | 2       | California.SanFrancisco               |
 Query OK, 4 row(s) in set (0.005399s)
 ```
+
 ## Query Examples
-If you want query the data of `location=California.LosAngeles groupid=3`，here is the query sql：
-select * from `meters.voltage` where location="California.LosAngeles" and groupid=3
+
+If you want query the data of `location=California.LosAngeles groupid=3`，here is the query SQL:
+
+```sql
+SELECT * FROM `meters.current` WHERE location = "California.LosAngeles" AND groupid = 3;
+```

docs/en/07-develop/03-insert-data/04-opentsdb-json.mdx

@@ -46,10 +46,10 @@ Please refer to [OpenTSDB HTTP API](http://opentsdb.net/docs/build/html/api_http
 
 :::note
 
-- In JSON protocol, strings will be converted to nchar type and numeric values will be converted to double type.
+- In JSON protocol, strings will be converted to NCHAR type and numeric values will be converted to double type.
 - Only data in array format is accepted and so an array must be used even if there is only one row.
-- The defult child table name is generated by rules.You can configure smlChildTableName in taos.cfg to specify chile table names, for example, `smlChildTableName=tname`. You can insert `"tags": { "host": "web02","dc": "lga","tname":"cpu1"}` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
-:::
+- The defult child table name is generated by rules.You can configure smlChildTableName in taos.cfg to specify child table names, for example, `smlChildTableName=tname`. You can insert `"tags": { "host": "web02","dc": "lga","tname":"cpu1"}` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
+  :::
 
 ## Examples
 
@@ -94,6 +94,11 @@ taos> select * from `meters.current`;
  2022-03-28 09:56:51.250 |              12.600000000 |               2.000000000 | California.SanFrancisco               |
 Query OK, 2 row(s) in set (0.004076s)
 ```
+
 ## Query Examples
-If you want query the data of "tags": {"location": "California.LosAngeles", "groupid": 1}，here is the query sql：
-select * from `meters.voltage` where location="California.LosAngeles" and groupid=1
+
+If you want query the data of "tags": {"location": "California.LosAngeles", "groupid": 1}，here is the query SQL:
+
+```sql
+SELECT * FROM `meters.current` WHERE location = "California.LosAngeles" AND groupid = 3;
+```

docs/en/07-develop/03-insert-data/05-high-volume.md

@@ -16,16 +16,16 @@ To achieve high performance writing, there are a few aspects to consider. In the
 
 From the perspective of application program, you need to consider:
 
-1. The data size of each single write, also known as batch size. Generally speaking, higher batch size generates better writing performance. However, once the batch size is over a specific value, you will not get any additional benefit anymore. When using SQL to write into TDengine, it's better to put as much as possible data in single SQL. The maximum SQL length supported by TDengine is 1,048,576 bytes, i.e. 1 MB. 
+1. The data size of each single write, also known as batch size. Generally speaking, higher batch size generates better writing performance. However, once the batch size is over a specific value, you will not get any additional benefit anymore. When using SQL to write into TDengine, it's better to put as much as possible data in single SQL. The maximum SQL length supported by TDengine is 1,048,576 bytes, i.e. 1 MB.
 
 2. The number of concurrent connections. Normally more connections can get better result. However, once the number of connections exceeds the processing ability of the server side, the performance may downgrade.
 
 3. The distribution of data to be written across tables or sub-tables. Writing to single table in one batch is more efficient than writing to multiple tables in one batch.
 
 4. Data Writing Protocol.
-   - Prameter binding mode is more efficient than SQL because it doesn't have the cost of parsing SQL.
-   - Writing to known existing tables is more efficient than wirting to uncertain tables in automatic creating mode because the later needs to check whether the table exists or not before actually writing data into it
-   - Writing in SQL is more efficient than writing in schemaless mode because schemaless writing creats table automatically and may alter table schema
+   - Parameter binding mode is more efficient than SQL because it doesn't have the cost of parsing SQL.
+   - Writing to known existing tables is more efficient than writing to uncertain tables in automatic creating mode because the later needs to check whether the table exists or not before actually writing data into it.
+   - Writing in SQL is more efficient than writing in schemaless mode because schemaless writing creates table automatically and may alter table schema.
 
 Application programs need to take care of the above factors and try to take advantage of them. The application progam should write to single table in each write batch. The batch size needs to be tuned to a proper value on a specific system. The number of concurrent connections needs to be tuned to a proper value too to achieve the best writing throughput.
 
@@ -37,7 +37,7 @@ Application programs need to read data from data source then write into TDengine
 2. The speed of data generation from single data source is much higher than the speed of single writing thread. The purpose of message queue in this case is to provide buffer so that data is not lost and multiple writing threads can get data from the buffer.
 3. The data for single table are from multiple data source. In this case the purpose of message queues is to combine the data for single table together to improve the write efficiency.
 
-If the data source is Kafka, then the appication program is a consumer of Kafka, you can benefit from some kafka features to achieve high performance writing:
+If the data source is Kafka, then the application program is a consumer of Kafka, you can benefit from some kafka features to achieve high performance writing:
 
 1. Put the data for a table in single partition of single topic so that it's easier to put the data for each table together and write in batch
 2. Subscribe multiple topics to accumulate data together.
@@ -56,7 +56,7 @@ This section will introduce the sample programs to demonstrate how to write into
 
 ### Scenario
 
-Below are the scenario for the sample programs of high performance wrting.
+Below are the scenario for the sample programs of high performance writing.
 
 - Application program reads data from data source, the sample program simulates a data source by generating data
 - The speed of single writing thread is much slower than the speed of generating data, so the program starts multiple writing threads while each thread establish a connection to TDengine and each thread has a message queue of fixed size.
@@ -80,7 +80,7 @@ The sample programs assume the source data is for all the different sub tables i
 | ---------------- | ----------------------------------------------------------------------------------------------------- |
 | FastWriteExample | Main Program                                                                                          |
 | ReadTask         | Read data from simulated data source and put into a queue according to the hash value of table name   |
-| WriteTask        | Read data from Queue, compose a wirte batch and write into TDengine                                   |
+| WriteTask        | Read data from Queue, compose a write batch and write into TDengine                                   |
 | MockDataSource   | Generate data for some sub tables of super table meters                                               |
 | SQLWriter        | WriteTask uses this class to compose SQL, create table automatically, check SQL length and write data |
 | StmtWriter       | Write in Parameter binding mode (Not finished yet)                                                    |
@@ -95,16 +95,16 @@ The main Program is responsible for:
 1. Create message queues
 2. Start writing threads
 3. Start reading threads
-4. Otuput writing speed every 10 seconds
+4. Output writing speed every 10 seconds
 
 The main program provides 4 parameters for tuning：
 
 1. The number of reading threads, default value is 1
-2. The number of writing threads, default alue is 2
+2. The number of writing threads, default value is 2
 3. The total number of tables in the generated data, default value is 1000. These tables are distributed evenly across all writing threads. If the number of tables is very big, it will cost much time to firstly create these tables.
 4. The batch size of single write, default value is 3,000
 
-The capacity of message queue also impacts performance and can be tuned by modifying program. Normally it's always better to have a larger message queue. A larger message queue means lower possibility of being blocked when enqueueing and higher throughput. But a larger message queue consumes more memory space. The default value used in the sample programs is already big enoug.
+The capacity of message queue also impacts performance and can be tuned by modifying program. Normally it's always better to have a larger message queue. A larger message queue means lower possibility of being blocked when enqueueing and higher throughput. But a larger message queue consumes more memory space. The default value used in the sample programs is already big enough.
 
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/highvolume/FastWriteExample.java}}
@@ -179,7 +179,7 @@ TDENGINE_JDBC_URL="jdbc:TAOS://localhost:6030?user=root&password=taosdata"
 
 **Launch in IDE**
 
-1. Clone TDengine repolitory
+1. Clone TDengine repository
    ```
    git clone git@github.com:taosdata/TDengine.git --depth 1
    ```
@@ -282,7 +282,7 @@ Sample programs in Python uses multi-process and cross-process message queues.
 | run_read_task Function       | Read data and distribute to message queues                                  |
 | MockDataSource Class         | Simulate data source, return next 1,000 rows of each table                  |
 | run_write_task Function      | Read as much as possible data from message queue and write in batch         |
-| SQLWriter Class              | Write in SQL and create table utomatically                                  |
+| SQLWriter Class              | Write in SQL and create table automatically                                 |
 | StmtWriter Class             | Write in parameter binding mode (not finished yet)                          |
 
 <details>
@@ -292,7 +292,7 @@ Sample programs in Python uses multi-process and cross-process message queues.
 
 1. Monitoring process, initializes database and calculating writing speed
 2. Reading process (n), reads data from data source
-3. Writing process (m), wirtes data into TDengine
+3. Writing process (m), writes data into TDengine
 
 `main` function provides 5 parameters:
 
@@ -311,7 +311,7 @@ Sample programs in Python uses multi-process and cross-process message queues.
 <details>
 <summary>run_monitor_process</summary>
 
-Monitoring process initilizes database and monitoring writing speed.
+Monitoring process initializes database and monitoring writing speed.
 
 ```python
 {{#include docs/examples/python/fast_write_example.py:monitor}}
@@ -356,7 +356,7 @@ Writing process tries to read as much as possible data from message queue and wr
 
 <details>
 
-SQLWriter class encapsulates the logic of composing SQL and writing data. Please be noted that the tables have not been created before writing, but are created automatically when catching the exception of table doesn't exist. For other exceptions caught, the SQL which caused the exception are logged for you to debug. This class also checks the SQL length, and passes the maximum SQL length by parameter maxSQLLength according to actual TDengine limit. 
+SQLWriter class encapsulates the logic of composing SQL and writing data. Please be noted that the tables have not been created before writing, but are created automatically when catching the exception of table doesn't exist. For other exceptions caught, the SQL which caused the exception are logged for you to debug. This class also checks the SQL length, and passes the maximum SQL length by parameter maxSQLLength according to actual TDengine limit.
 
 <summary>SQLWriter</summary>
 
@@ -372,7 +372,7 @@ SQLWriter class encapsulates the logic of composing SQL and writing data. Please
 
 <summary>Launch Sample Program in Python</summary>
 
-1. Prerequisities
+1. Prerequisites
 
    - TDengine client driver has been installed
    - Python3 has been installed, the the version >= 3.8

docs/en/07-develop/index.md

@@ -3,6 +3,7 @@ title: Developer Guide
 ---
 
 Before creating an application to process time-series data with TDengine, consider the following:
+
 1. Choose the method to connect to TDengine. TDengine offers a REST API that can be used with any programming language. It also has connectors for a variety of languages.
 2. Design the data model based on your own use cases. Consider the main [concepts](/concept/) of TDengine, including "one table per data collection point" and the supertable. Learn about static labels, collected metrics, and subtables. Depending on the characteristics of your data and your requirements, you decide to create one or more databases and design a supertable schema that fit your data.
 3. Decide how you will insert data. TDengine supports writing using standard SQL, but also supports schemaless writing, so that data can be written directly without creating tables manually.

docs/zh/07-develop/01-connect/index.md

@@ -32,7 +32,7 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 
 关键不同点在于：
 
-1. 使用 REST 连接，用户无需安装客户端驱动程序 taosc，具有跨平台易用的优势，但性能要下降 30%左右。
+1. 使用 REST 连接，用户无需安装客户端驱动程序 taosc，具有跨平台易用的优势，但性能要下降 30% 左右。
 2. 使用原生连接可以体验 TDengine 的全部功能，如[参数绑定接口](../../connector/cpp/#参数绑定-api)、[订阅](../../connector/cpp/#订阅和消费-api)等等。
 
 ## 安装客户端驱动 taosc
@@ -67,8 +67,8 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 
 <Tabs groupId="lang">
 <TabItem label="Java" value="java">
-  
-如果使用 maven 管理项目，只需在 pom.xml 中加入以下依赖。
+
+如果使用 Maven 管理项目，只需在 pom.xml 中加入以下依赖。
 
 ```xml
 <dependency>
@@ -107,7 +107,7 @@ require github.com/taosdata/driver-go/v3 latest
 ```
 
 :::note
-driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 gcc 编译 C 的源码。因此需要确保你的系统上有 gcc。
+driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 GCC 编译 C 的源码。因此需要确保你的系统上有 GCC。
 
 :::
 
@@ -137,19 +137,19 @@ Node.js 连接器通过不同的包提供不同的连接方式。
 
 1. 安装 Node.js 原生连接器
 
-  ```
-  npm install @tdengine/client
-  ```
+```
+npm install @tdengine/client
+```
 
 :::note
 推荐 Node 版本大于等于 `node-v12.8.0` 小于 `node-v13.0.0`
-::: 
-  
+:::
+
 2. 安装 Node.js REST 连接器
 
-  ```
-  npm install @tdengine/rest
-  ```
+```
+npm install @tdengine/rest
+```
 
 </TabItem>
 <TabItem label="C#" value="csharp">

docs/zh/07-develop/02-model/index.mdx

@@ -10,13 +10,13 @@ TDengine 采用类关系型数据模型，需要建库、建表。因此对于
 
 ## 创建库
 
-不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，还可以指定保留时长、副本数、缓存大小、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
+不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能以最大效率工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，还可以指定保留时长、副本数、缓存大小、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
 
 ```sql
 CREATE DATABASE power KEEP 365 DURATION 10 BUFFER 16 WAL_LEVEL 1;
 ```
 
-上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，每个 VNODE 的写入内存池的大小为 16 MB，对该数据库入会写 WAL 但不执行 FSYNC。详细的语法及参数请见 [数据库管理](/taos-sql/database) 章节。
+上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，每个 VNode 的写入内存池的大小为 16 MB，对该数据库入会写 WAL 但不执行 FSYNC。详细的语法及参数请见 [数据库管理](/taos-sql/database) 章节。
 
 创建库之后，需要使用 SQL 命令 `USE` 将当前库切换过来，例如：
 
@@ -35,39 +35,39 @@ USE power;
 
 ## 创建超级表
 
-一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用 TDengine, 需要对每个类型的数据采集点创建一个超级表。以[表 1](/tdinternal/arch#model_table1) 中的智能电表为例，可以使用如下的 SQL 命令创建超级表：
+一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用 TDengine, 需要对每个类型的数据采集点创建一个超级表。以 [表 1](/concept) 中的智能电表为例，可以使用如下的 SQL 命令创建超级表：
 
 ```sql
 CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
 ```
 
-与创建普通表一样，创建超级表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts)，其他列为采集的物理量（示例中为 current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 schema (示例中为 location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TDengine SQL 的超级表管理](/taos-sql/stable) 章节。
+与创建普通表一样，创建超级表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts），其他列为采集的物理量（示例中为 current, voltage, phase），数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 Schema （示例中为 location, groupId），标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 Schema 可以事后增加、删除、修改。具体定义以及细节请见 [TDengine SQL 的超级表管理](/taos-sql/stable) 章节。
 
 每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。
 
-一张超级表最多容许 4096 列，如果一个采集点采集的物理量个数超过 4096，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。
+一张超级表最多容许 4096 列，如果一个采集点采集的物理量个数超过 4096，需要建多张超级表来处理。一个系统可以有多个 Database，一个 Database 里可以有一到多个超级表。
 
 ## 创建表
 
-TDengine 对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以[表 1](/tdinternal/arch#model_table1)中的智能电表为例，可以使用如下的 SQL 命令建表：
+TDengine 对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以 [表 1](/concept) 中的智能电表为例，可以使用如下的 SQL 命令建表：
 
 ```sql
 CREATE TABLE d1001 USING meters TAGS ("California.SanFrancisco", 2);
 ```
 
-其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值 "California.SanFrancisco"，标签 groupId 的具体标签值 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TDengine SQL 的表管理](/taos-sql/table) 章节。
+其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值为 "California.SanFrancisco"，标签 groupId 的具体标签值为 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TDengine SQL 的表管理](/taos-sql/table) 章节。
 
-TDengine 建议将数据采集点的全局唯一 ID 作为表名(比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。
+TDengine 建议将数据采集点的全局唯一 ID 作为表名（比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。
 
 ### 自动建表
 
 在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表且后面的 USING 语句被忽略。比如：
 
 ```sql
-INSERT INTO d1001 USING meters TAGS ("California.SanFrancisco", 2) VALUES (now, 10.2, 219, 0.32);
+INSERT INTO d1001 USING meters TAGS ("California.SanFrancisco", 2) VALUES (NOW, 10.2, 219, 0.32);
 ```
 
-上述 SQL 语句将记录`(now, 10.2, 219, 0.32)`插入表 d1001。如果表 d1001 还未创建，则使用超级表 meters 做模板自动创建，同时打上标签值 `"California.SanFrancisco", 2`。
+上述 SQL 语句将记录`(NOW, 10.2, 219, 0.32)`插入表 d1001。如果表 d1001 还未创建，则使用超级表 meters 做模板自动创建，同时打上标签值 `"California.SanFrancisco", 2`。
 
 关于自动建表的详细语法请参见 [插入记录时自动建表](/taos-sql/insert#插入记录时自动建表) 章节。
 

docs/zh/07-develop/03-insert-data/01-sql-writing.mdx

@@ -53,15 +53,15 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 
 :::info
 
-- 要提高写入效率，需要批量写入。一般来说一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48K，一条 SQL 语句总长度不能超过 1M 。
-- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开多个同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，会带来额外开销，合适的线程数量与服务端的处理能力，服务端的具体配置，数据库的参数，数据定义的 Schema，写入数据的 Batch Size 等很多因素相关。一般来说，服务端和客户端处理能力越强，所能支持的并发写入的线程可以越多；数据库配置时的 vgroups 越多（但仍然要在服务端的处理能力以内）则所能支持的并发写入越多；数据定义的 Schema 越简单，所能支持的并发写入越多。
+- 要提高写入效率，需要批量写入。一般来说一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48KB，一条 SQL 语句总长度不能超过 1MB。
+- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开多个同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，会带来额外开销，合适的线程数量与服务端的处理能力，服务端的具体配置，数据库的参数，数据定义的 Schema，写入数据的 Batch Size 等很多因素相关。一般来说，服务端和客户端处理能力越强，所能支持的并发写入的线程可以越多；数据库配置时的 vgroups 参数值越多（但仍然要在服务端的处理能力以内）则所能支持的并发写入越多；数据定义的 Schema 越简单，所能支持的并发写入越多。
 
 :::
 
 :::warning
 
 - 对同一张表，如果新插入记录的时间戳已经存在，则指定了新值的列会用新值覆盖旧值，而没有指定新值的列则不受影响。
-- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 duration。如果 duration 为 2，那么无法写入比当前时间还晚 2 天的数据。
+- 写入的数据的时间戳必须大于当前时间减去数据库配置参数 KEEP 的时间。如果 KEEP 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 DURATION。如果 DURATION 为 2，那么无法写入比当前时间还晚 2 天的数据。
 
 :::
 
@@ -99,7 +99,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 :::note
 
 1. 无论 RESTful 方式建立连接还是本地驱动方式建立连接，以上示例代码都能正常工作。
-2. 唯一需要注意的是：由于 RESTful 接口无状态， 不能使用 `use db` 语句来切换数据库, 所以在上面示例中使用了`dbName.tbName`指定表名。
+2. 唯一需要注意的是：由于 RESTful 接口无状态， 不能使用 `USE db;` 语句来切换数据库, 所以在上面示例中使用了`dbName.tbName`指定表名。
 
 :::
 

docs/zh/07-develop/03-insert-data/02-influxdb-line.mdx

@@ -34,13 +34,13 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
 
 :::note
 
-- tag_set 中的所有的数据自动转化为 nchar 数据类型;
-- field_set 中的每个数据项都需要对自身的数据类型进行描述, 比如 1.2f32 代表 float 类型的数值 1.2, 如果不带类型后缀会被当作 double 处理;
+- tag_set 中的所有的数据自动转化为 NCHAR 数据类型;
+- field_set 中的每个数据项都需要对自身的数据类型进行描述, 比如 1.2f32 代表 FLOAT 类型的数值 1.2, 如果不带类型后缀会被当作 DOUBLE 处理;
 - timestamp 支持多种时间精度。写入数据的时候需要用参数指定时间精度，支持从小时到纳秒的 6 种时间精度。
-- 为了提高写入的效率，默认假设同一个超级表中 field_set 的顺序是一样的（第一条数据包含所有的 field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数 smlDataFormat 为 false，否则，数据写入按照相同顺序写入，库中数据会异常。（3.0.1.3之后的版本 smlDataFormat 默认为 false） [TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
-- 默认生产的子表名是根据规则生成的唯一ID值。为了让用户可以指定生成的表名，可以通过在taos.cfg里配置 smlChildTableName 参数来指定。
-举例如下：配置 smlChildTableName=tname 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
-:::
+- 为了提高写入的效率，默认假设同一个超级表中 field_set 的顺序是一样的（第一条数据包含所有的 field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数 smlDataFormat 为 false，否则，数据写入按照相同顺序写入，库中数据会异常。（3.0.1.3 之后的版本 smlDataFormat 默认为 false） [TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
+- 默认生产的子表名是根据规则生成的唯一 ID 值。为了让用户可以指定生成的表名，可以通过在 taos.cfg 里配置 smlChildTableName 参数来指定。
+  举例如下：配置 smlChildTableName=tname 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
+  :::
 
 要了解更多可参考：[InfluxDB Line 协议官方文档](https://docs.influxdata.com/influxdb/v2.0/reference/syntax/line-protocol/) 和 [TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
 
@@ -67,10 +67,12 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
   </TabItem>
 </Tabs>
 
-## SQL查询示例
-- meters 是插入数据的超级表名
-- 可以通过超级表的tag来过滤数据，比如查询 `location=California.LosAngeles,groupid=2` 可以通过如下sql：
+## SQL 查询示例
 
-``` cmd
-select * from meters where location="California.LosAngeles" and groupid=2
+`meters` 是插入数据的超级表名。
+
+可以通过超级表的 TAG 来过滤数据，比如查询 `location=California.LosAngeles,groupid=2` 可以通过如下 SQL：
+
+```sql
+SELECT * FROM meters WHERE location = "California.LosAngeles" AND groupid = 2;
 ```

docs/zh/07-develop/03-insert-data/03-opentsdb-telnet.mdx

@@ -21,10 +21,10 @@ OpenTSDB 行协议同样采用一行字符串来表示一行数据。OpenTSDB
 <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
 ```
 
-- metric 将作为超级表名。
-- timestamp 本行数据对应的时间戳。根据时间戳的长度自动识别时间精度。支持秒和毫秒两种时间精度
-- value 度量值，必须为一个数值。对应的列名是 “_value”。
-- 最后一部分是标签集， 用空格分隔不同标签， 所有标签自动转化为 nchar 数据类型;
+- metric 将作为超级表名；
+- timestamp 本行数据对应的时间戳。根据时间戳的长度自动识别时间精度。支持秒和毫秒两种时间精度；
+- value 度量值，必须为一个数值。对应的列名是 “\_value”；
+- 最后一部分是标签集， 用空格分隔不同标签， 所有标签自动转化为 NCHAR 数据类型。
 
 例如：
 
@@ -32,9 +32,9 @@ OpenTSDB 行协议同样采用一行字符串来表示一行数据。OpenTSDB
 meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
 ```
 
-- 默认生产的子表名是根据规则生成的唯一ID值。为了让用户可以指定生成的表名，可以通过在taos.cfg里配置 smlChildTableName 参数来指定。
-举例如下：配置 smlChildTableName=tname 插入数据为 meters.current 1648432611250 11.3 tname=cpu1 location=California.LosAngeles groupid=3 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
-参考[OpenTSDB Telnet API 文档](http://opentsdb.net/docs/build/html/api_telnet/put.html)。
+- 默认生产的子表名是根据规则生成的唯一 ID 值。为了让用户可以指定生成的表名，可以通过在 taos.cfg 里配置 smlChildTableName 参数来指定。
+  举例如下：配置 smlChildTableName=tname 插入数据为 meters.current 1648432611250 11.3 tname=cpu1 location=California.LosAngeles groupid=3 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
+  参考 [OpenTSDB Telnet API 文档](http://opentsdb.net/docs/build/html/api_telnet/put.html)。
 
 ## 示例代码
 
@@ -62,17 +62,17 @@ meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
 以上示例代码会自动创建 2 个超级表， 每个超级表有 4 条数据。
 
 ```cmd
-taos> use test;
+taos> USE test;
 Database changed.
 
-taos> show stables;
+taos> SHOW STABLES;
               name              |
 =================================
  meters.current                 |
  meters.voltage                 |
 Query OK, 2 row(s) in set (0.002544s)
 
-taos> select tbname, * from `meters.current`;
+taos> SELECT TBNAME, * FROM `meters.current`;
              tbname             |           _ts            |           _value           | groupid |            location            |
 ==================================================================================================================================
  t_0e7bcfa21a02331c06764f275... | 2022-03-28 09:56:51.249 |              10.800000000 | 3       | California.LosAngeles                |
@@ -82,9 +82,12 @@ taos> select tbname, * from `meters.current`;
 Query OK, 4 row(s) in set (0.005399s)
 ```
 
-## SQL查询示例
-- `meters.current` 是插入数据的超级表名
-- 可以通过超级表的tag来过滤数据，比如查询 `location=California.LosAngeles groupid=3` 可以通过如下sql：
-``` cmd
-select * from `meters.current` where location="California.LosAngeles" and groupid=3
+## SQL 查询示例
+
+`meters.current` 是插入数据的超级表名。
+
+可以通过超级表的 TAG 来过滤数据，比如查询 `location=California.LosAngeles groupid=3` 可以通过如下 SQL：
+
+```sql
+SELECT * FROM `meters.current` WHERE location = "California.LosAngeles" AND groupid = 3;
 ```

docs/zh/07-develop/03-insert-data/04-opentsdb-json.mdx

@@ -46,11 +46,11 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
 
 :::note
 
-- 对于 JSON 格式协议，TDengine 并不会自动把所有标签转成 nchar 类型， 字符串将将转为 nchar 类型， 数值将同样转换为 double 类型。
+- 对于 JSON 格式协议，TDengine 并不会自动把所有标签转成 NCHAR 类型， 字符串将将转为 NCHAR 类型， 数值将同样转换为 DOUBLE 类型。
 - TDengine 只接收 JSON **数组格式**的字符串，即使一行数据也需要转换成数组形式。
-- 默认生产的子表名是根据规则生成的唯一ID值。为了让用户可以指定生成的表名，可以通过在taos.cfg里配置 smlChildTableName 参数来指定。
-举例如下：配置 smlChildTableName=tname 插入数据为 "tags": { "host": "web02","dc": "lga","tname":"cpu1"} 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
-:::
+- 默认生产的子表名是根据规则生成的唯一 ID 值。为了让用户可以指定生成的表名，可以通过在 taos.cfg 里配置 smlChildTableName 参数来指定。
+  举例如下：配置 smlChildTableName=tname 插入数据为 `"tags": { "host": "web02","dc": "lga","tname":"cpu1"}` 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
+  :::
 
 ## 示例代码
 
@@ -78,17 +78,17 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
 以上示例代码会自动创建 2 个超级表， 每个超级表有 2 条数据。
 
 ```cmd
-taos> use test;
+taos> USE test;
 Database changed.
 
-taos> show stables;
+taos> SHOW STABLES;
               name              |
 =================================
  meters.current                 |
  meters.voltage                 |
 Query OK, 2 row(s) in set (0.001954s)
 
-taos> select * from `meters.current`;
+taos> SELECT * FROM `meters.current`;
            _ts            |           _value           |          groupid          |            location            |
 ===================================================================================================================
  2022-03-28 09:56:51.249 |              10.300000000 |               2.000000000 | California.SanFrancisco               |
@@ -96,9 +96,12 @@ taos> select * from `meters.current`;
 Query OK, 2 row(s) in set (0.004076s)
 ```
 
-## SQL查询示例
-- `meters.voltage` 是插入数据的超级表名
-- 可以通过超级表的tag来过滤数据，比如查询 `location=California.LosAngeles groupid=1` 可以通过如下sql：
-``` cmd
-select * from `meters.voltage` where location="California.LosAngeles" and groupid=1
+## SQL 查询示例
+
+`meters.voltage` 是插入数据的超级表名。
+
+可以通过超级表的 TAG 来过滤数据，比如查询 `location=California.LosAngeles groupid=1` 可以通过如下 SQL：
+
+```sql
+SELECT * FROM `meters.current` WHERE location = "California.LosAngeles" AND groupid = 3;
 ```

docs/zh/07-develop/03-insert-data/05-high-volume.md

@@ -11,11 +11,11 @@ import TabItem from "@theme/TabItem";
 
 从客户端程序的角度来说，高效写入数据要考虑以下几个因素：
 
-1. 单次写入的数据量。一般来讲，每批次写入的数据量越大越高效（但超过一定阈值其优势会消失）。使用 SQL 写入 TDengine 时，尽量在一条 SQL 中拼接更多数据。目前，TDengine 支持的一条 SQL 的最大长度为 1,048,576（1M）个字符。
-2. 并发连接数。一般来讲，同时写入数据的并发连接数越多写入越高效（但超过一定阈值反而会下降，取决于服务端处理能力）。
-3. 数据在不同表（或子表）之间的分布，即要写入数据的相邻性。一般来说，每批次只向同一张表（或子表）写入数据比向多张表（或子表）写入数据要更高效；
+1. 单次写入的数据量。一般来讲，每批次写入的数据量越大越高效（但超过一定阈值其优势会消失）。使用 SQL 写入 TDengine 时，尽量在一条 SQL 中拼接更多数据。目前，TDengine 支持的一条 SQL 的最大长度为 1,048,576（1MB）个字符
+2. 并发连接数。一般来讲，同时写入数据的并发连接数越多写入越高效（但超过一定阈值反而会下降，取决于服务端处理能力）
+3. 数据在不同表（或子表）之间的分布，即要写入数据的相邻性。一般来说，每批次只向同一张表（或子表）写入数据比向多张表（或子表）写入数据要更高效
 4. 写入方式。一般来讲：
-   - 参数绑定写入比 SQL 写入更高效。因参数绑定方式避免了 SQL 解析。（但增加了 C 接口的调用次数，对于连接器也有性能损耗）。
+   - 参数绑定写入比 SQL 写入更高效。因参数绑定方式避免了 SQL 解析。（但增加了 C 接口的调用次数，对于连接器也有性能损耗）
    - SQL 写入不自动建表比自动建表更高效。因自动建表要频繁检查表是否存在
    - SQL 写入比无模式写入更高效。因无模式写入会自动建表且支持动态更改表结构
 
@@ -34,7 +34,7 @@ import TabItem from "@theme/TabItem";
 1. 将同一张表的数据写到同一个 Topic 的同一个 Partition，增加数据的相邻性
 2. 通过订阅多个 Topic 实现数据汇聚
 3. 通过增加 Consumer 线程数增加写入的并发度
-4. 通过增加每次 fetch 的最大数据量来增加单次写入的最大数据量
+4. 通过增加每次 Fetch 的最大数据量来增加单次写入的最大数据量
 
 ### 服务器配置的角度 {#setting-view}
 
@@ -59,7 +59,7 @@ import TabItem from "@theme/TabItem";
 
 这一部分是针对以上场景的示例代码。对于其它场景高效写入原理相同，不过代码需要适当修改。
 
-本示例代码假设源数据属于同一张超级表(meters)的不同子表。程序在开始写入数据之前已经在 test 库创建了这个超级表。对于子表，将根据收到的数据，由应用程序自动创建。如果实际场景是多个超级表，只需修改写任务自动建表的代码。
+本示例代码假设源数据属于同一张超级表（meters）的不同子表。程序在开始写入数据之前已经在 test 库创建了这个超级表。对于子表，将根据收到的数据，由应用程序自动创建。如果实际场景是多个超级表，只需修改写任务自动建表的代码。
 
 <Tabs defaultValue="java" groupId="lang">
 <TabItem label="Java" value="java">
@@ -69,14 +69,13 @@ import TabItem from "@theme/TabItem";
 | 类名             | 功能说明                                                                    |
 | ---------------- | --------------------------------------------------------------------------- |
 | FastWriteExample | 主程序                                                                      |
-| ReadTask         | 从模拟源中读取数据，将表名经过 hash 后得到 Queue 的 index，写入对应的 Queue |
+| ReadTask         | 从模拟源中读取数据，将表名经过 Hash 后得到 Queue 的 Index，写入对应的 Queue |
 | WriteTask        | 从 Queue 中获取数据，组成一个 Batch，写入 TDengine                          |
 | MockDataSource   | 模拟生成一定数量 meters 子表的数据                                          |
 | SQLWriter        | WriteTask 依赖这个类完成 SQL 拼接、自动建表、 SQL 写入、SQL 长度检查        |
 | StmtWriter       | 实现参数绑定方式批量写入（暂未完成）                                        |
 | DataBaseMonitor  | 统计写入速度，并每隔 10 秒把当前写入速度打印到控制台                        |
 
-
 以下是各类的完整代码和更详细的功能说明。
 
 <details>
@@ -92,10 +91,10 @@ import TabItem from "@theme/TabItem";
 
 1. 读线程个数。默认为 1。
 2. 写线程个数。默认为 3。
-3. 模拟生成的总表数。默认为 1000。将会平分给各个读线程。如果总表数较大，建表需要花费较长，开始统计的写入速度可能较慢。
-4. 每批最多写入记录数量。默认为 3000。
+3. 模拟生成的总表数。默认为 1,000。将会平分给各个读线程。如果总表数较大，建表需要花费较长，开始统计的写入速度可能较慢。
+4. 每批最多写入记录数量。默认为 3,000。
 
-队列容量(taskQueueCapacity)也是与性能有关的参数，可通过修改程序调节。一般来讲，队列容量越大，入队被阻塞的概率越小，队列的吞吐量越大，但是内存占用也会越大。 示例程序默认值已经设置地足够大。
+队列容量（taskQueueCapacity）也是与性能有关的参数，可通过修改程序调节。一般来讲，队列容量越大，入队被阻塞的概率越小，队列的吞吐量越大，但是内存占用也会越大。示例程序默认值已经设置地足够大。
 
 ```java
 {{#include docs/examples/java/src/main/java/com/taos/example/highvolume/FastWriteExample.java}}
@@ -208,14 +207,14 @@ TDENGINE_JDBC_URL="jdbc:TAOS://localhost:6030?user=root&password=taosdata"
 
    以上使用的是本地部署 TDengine Server 时默认的 JDBC URL。你需要根据自己的实际情况更改。
 
-5. 用 java 命令启动示例程序，命令模板：
+5. 用 Java 命令启动示例程序，命令模板：
 
    ```
    java -classpath lib/*:javaexample-1.0.jar  com.taos.example.highvolume.FastWriteExample <read_thread_count>  <white_thread_count> <total_table_count> <max_batch_size>
    ```
 
 6. 结束测试程序。测试程序不会自动结束，在获取到当前配置下稳定的写入速度后，按 <kbd>CTRL</kbd> + <kbd>C</kbd> 结束程序。
-   下面是一次实际运行的日志输出，机器配置 16核 + 64G + 固态硬盘。
+   下面是一次实际运行的日志输出，机器配置 16 核 + 64G + 固态硬盘。
 
    ```
    root@vm85$ java -classpath lib/*:javaexample-1.0.jar  com.taos.example.highvolume.FastWriteExample 2 12
@@ -271,12 +270,11 @@ Python 示例程序中采用了多进程的架构，并使用了跨进程的消
 | main 函数                | 程序入口， 创建各个子进程和消息队列                                  |
 | run_monitor_process 函数 | 创建数据库，超级表，统计写入速度并定时打印到控制台                   |
 | run_read_task 函数       | 读进程主要逻辑，负责从其它数据系统读数据，并分发数据到为之分配的队列 |
-| MockDataSource 类        | 模拟数据源, 实现迭代器接口，每次批量返回每张表的接下来 1000 条数据   |
+| MockDataSource 类        | 模拟数据源, 实现迭代器接口，每次批量返回每张表的接下来 1,000 条数据  |
 | run_write_task 函数      | 写进程主要逻辑。每次从队列中取出尽量多的数据，并批量写入             |
-| SQLWriter类              | SQL 写入和自动建表                                                   |
+| SQLWriter 类             | SQL 写入和自动建表                                                   |
 | StmtWriter 类            | 实现参数绑定方式批量写入（暂未完成）                                 |
 
-
 <details>
 <summary>main 函数</summary>
 
@@ -290,9 +288,9 @@ main 函数可以接收 5 个启动参数，依次是：
 
 1. 读任务（进程）数, 默认为 1
 2. 写任务（进程）数, 默认为 1
-3. 模拟生成的总表数，默认为 1000
-4. 队列大小（单位字节），默认为 1000000
-5. 每批最多写入记录数量， 默认为 3000
+3. 模拟生成的总表数，默认为 1,000
+4. 队列大小（单位字节），默认为 1,000,000
+5. 每批最多写入记录数量， 默认为 3,000
 
 ```python
 {{#include docs/examples/python/fast_write_example.py:main}}
@@ -348,7 +346,7 @@ main 函数可以接收 5 个启动参数，依次是：
 
 <details>
 
-SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提前创建，而是在发生表不存在错误的时候，再以超级表为模板批量建表，然后重新执行 INSERT 语句。对于其它错误会记录当时执行的 SQL， 以便排查错误和故障恢复。这个类也对 SQL 是否超过最大长度限制做了检查，根据 TDengine 3.0 的限制由输入参数 maxSQLLength 传入了支持的最大 SQL 长度，即 1048576 。
+SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提前创建，而是在发生表不存在错误的时候，再以超级表为模板批量建表，然后重新执行 INSERT 语句。对于其它错误会记录当时执行的 SQL， 以便排查错误和故障恢复。这个类也对 SQL 是否超过最大长度限制做了检查，根据 TDengine 3.0 的限制由输入参数 maxSQLLength 传入了支持的最大 SQL 长度，即 1,048,576 。
 
 <summary>SQLWriter</summary>
 
@@ -384,7 +382,7 @@ SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提
    python3  fast_write_example.py <READ_TASK_COUNT> <WRITE_TASK_COUNT> <TABLE_COUNT> <QUEUE_SIZE> <MAX_BATCH_SIZE>
    ```
 
-   下面是一次实际运行的输出, 机器配置 16核 + 64G + 固态硬盘。
+   下面是一次实际运行的输出, 机器配置 16 核 + 64G + 固态硬盘。
 
    ```
    root@vm85$ python3 fast_write_example.py  8 8
@@ -432,5 +430,3 @@ SQLWriter 类封装了拼 SQL 和写数据的逻辑。所有的表都没有提
 
 </TabItem>
 </Tabs>
-
-

docs/zh/07-develop/index.md

@@ -4,19 +4,20 @@ sidebar_label: 开发指南
 description: 让开发者能够快速上手的指南
 ---
 
-开发一个应用，如果你准备采用TDengine作为时序数据处理的工具，那么有如下几个事情要做：
-1. 确定应用到TDengine的链接方式。无论你使用何种编程语言，你总可以使用REST接口, 但也可以使用每种编程语言独有的连接器方便的进行链接。
+开发一个应用，如果你准备采用 TDengine 作为时序数据处理的工具，那么有如下几个事情要做：
+
+1. 确定应用到 TDengine 的连接方式。无论你使用何种编程语言，你总是可以使用 REST 接口, 但也可以使用每种编程语言独有的连接器进行方便的连接。
 2. 根据自己的应用场景，确定数据模型。根据数据特征，决定建立一个还是多个库；分清静态标签、采集量，建立正确的超级表，建立子表。
-3. 决定插入数据的方式。TDengine支持使用标准的SQL写入，但同时也支持schemaless模式写入，这样不用手工建表，可以将数据直接写入。
-4. 根据业务要求，看需要撰写哪些SQL查询语句。
+3. 决定插入数据的方式。TDengine 支持使用标准的 SQL 写入，但同时也支持 Schemaless 模式写入，这样不用手工建表，可以将数据直接写入。
+4. 根据业务要求，看需要撰写哪些 SQL 查询语句。
 5. 如果你要基于时序数据做轻量级的实时统计分析，包括各种监测看板，那么建议你采用 TDengine 3.0 的流式计算功能，而不用额外部署 Spark, Flink 等复杂的流式计算系统。
-6. 如果你的应用有模块需要消费插入的数据，希望有新的数据插入时，就能获取通知，那么建议你采用TDengine提供的数据订阅功能，而无需专门部署Kafka或其他消息队列软件。
-7. 在很多场景下(如车辆管理)，应用需要获取每个数据采集点的最新状态，那么建议你采用TDengine的cache功能，而不用单独部署Redis等缓存软件。
-8. 如果你发现TDengine的函数无法满足你的要求，那么你可以使用用户自定义函数来解决问题。
+6. 如果你的应用有模块需要消费插入的数据，希望有新的数据插入时，就能获取通知，那么建议你采用 TDengine 提供的数据订阅功能，而无需专门部署 Kafka 或其他消息队列软件。
+7. 在很多场景下（如车辆管理），应用需要获取每个数据采集点的最新状态，那么建议你采用 TDengine 的 Cache 功能，而不用单独部署 Redis 等缓存软件。
+8. 如果你发现 TDengine 的函数无法满足你的要求，那么你可以使用用户自定义函数（UDF）来解决问题。
 
-本部分内容就是按照上述的顺序组织的。为便于理解，TDengine为每个功能为每个支持的编程语言都提供了示例代码。如果你希望深入了解SQL的使用，需要查看[SQL手册](/taos-sql/)。如果想更深入地了解各连接器的使用，请阅读[连接器参考指南](../connector/)。如果还希望想将TDengine与第三方系统集成起来，比如Grafana, 请参考[第三方工具](../third-party/)。
+本部分内容就是按照上述顺序组织的。为便于理解，TDengine 为每个功能和每个支持的编程语言都提供了示例代码。如果你希望深入了解 SQL 的使用，需要查看[SQL 手册](/taos-sql/)。如果想更深入地了解各连接器的使用，请阅读[连接器参考指南](../connector/)。如果还希望想将 TDengine 与第三方系统集成起来，比如 Grafana, 请参考[第三方工具](../third-party/)。
 
-如果在开发过程中遇到任何问题，请点击每个页面下方的["反馈问题"](https://github.com/taosdata/TDengine/issues/new/choose), 在GitHub上直接递交issue。
+如果在开发过程中遇到任何问题，请点击每个页面下方的["反馈问题"](https://github.com/taosdata/TDengine/issues/new/choose), 在 GitHub 上直接递交 Issue。
 
 ```mdx-code-block
 import DocCardList from '@theme/DocCardList';

docs/zh/21-tdinternal/01-arch.md

@@ -137,7 +137,7 @@ Leader Vnode 遵循下面的写入流程：
 <center> 图 3 TDengine Leader 写入流程  </center>
 
 1. leader vnode 收到应用的数据插入请求，验证 OK，进入下一步；
-2. vnode 将该请求的原始数据包写入数据库日志文件 WAL。如果 walLevel 设置为 2，而且 fsync 设置为 0，TDengine 还将 WAL 数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失；
+2. vnode 将该请求的原始数据包写入数据库日志文件 WAL。如果 `wal_level` 设置为 2，而且 `wal_fsync_period` 设置为 0，TDengine 还将 WAL 数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失；
 3. 如果有多个副本，vnode 将把数据包转发给同一虚拟节点组内的 follower vnodes，该转发包带有数据的版本号（version）；
 4. 写入内存，并将记录加入到 skip list。但如果未达成一致，会触发回滚操作；
 5. leader vnode 返回确认信息给应用，表示写入成功；
@@ -152,7 +152,7 @@ Leader Vnode 遵循下面的写入流程：
 <center> 图 4 TDengine Follower 写入流程  </center>
 
 1. follower vnode 收到 leader vnode 转发了的数据插入请求。
-2. vnode 将把该请求的原始数据包写入数据库日志文件 WAL。如果 walLevel 设置为 2，而且 fsync 设置为 0，TDengine 还将 WAL 数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失。
+2. vnode 将把该请求的原始数据包写入数据库日志文件 WAL。如果 `wal_level` 设置为 2，而且 `wal_fsync_period` 设置为 0，TDengine 还将 WAL 数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失。
 3. 写入内存，更新内存中的 skip list。
 
 与 leader vnode 相比，follower vnode 不存在转发环节，也不存在回复确认环节，少了两步。但写内存与 WAL 是完全一样的。
@@ -165,7 +165,7 @@ Vnode 会保持一个数据版本号（version），对内存数据进行持久
 
 ### 同步复制
 
-对于数据一致性要求更高的场景，异步数据复制提供的最终一致性无法满足要求。因此 TDengine 提供同步复制的机制供用户选择。在创建数据库时，除指定副本数 replica 之外，用户还需要指定新的参数 strict。如果 strict 等于 1，它表示每次 leader 转发给副本时，需要等待半数以上副本达成一致后，才能通知应用，数据在 follower 已经写入成功。如果在一定的时间内，得不到半数以上副本的确认，leader vnode 将返回错误给应用。
+对于数据一致性要求更高的场景，异步数据复制提供的最终一致性无法满足要求。因此 TDengine 提供同步复制的机制供用户选择。在创建数据库时，除指定副本数 `replica` 之外，用户还需要指定新的参数 `strict`。如果 `strict` 等于 1，它表示每次 leader 转发给副本时，需要等待半数以上副本达成一致后，才能通知应用，数据在 follower 已经写入成功。如果在一定的时间内，得不到半数以上副本的确认，leader vnode 将返回错误给应用。
 
 采用同步复制，系统的性能会有所下降，而且 latency 会增加。因为元数据要强一致，mnode 之间的数据同步缺省就是采用的同步复制。
 
@@ -183,11 +183,11 @@ TDengine 通过查询函数向用户提供毫秒级的数据获取能力。直
 
 TDengine 采用数据驱动的方式让缓存中的数据写入硬盘进行持久化存储。当 vnode 中缓存的数据达到一定规模时，为了不阻塞后续数据的写入，TDengine 也会拉起落盘线程将缓存的数据写入持久化存储。TDengine 在数据落盘时会打开新的数据库日志文件，在落盘成功后则会删除老的数据库日志文件，避免日志文件无限制地增长。
 
-为充分利用时序数据特点，TDengine 将一个 vnode 保存在持久化存储的数据切分成多个文件，每个文件只保存固定天数的数据，这个天数由系统配置参数 days 决定。切分成多个文件后，给定查询的起止日期，无需任何索引，就可以立即定位需要打开哪些数据文件，大大加快读取速度。
+为充分利用时序数据特点，TDengine 将一个 vnode 保存在持久化存储的数据切分成多个文件，每个文件只保存固定天数的数据，这个天数由系统配置参数 `duration` 决定。切分成多个文件后，给定查询的起止日期，无需任何索引，就可以立即定位需要打开哪些数据文件，大大加快读取速度。
 
-对于采集的数据，一般有保留时长，这个时长由系统配置参数 keep 决定。超过这个设置天数的数据文件，将被系统自动删除，释放存储空间。
+对于采集的数据，一般有保留时长，这个时长由系统配置参数 `keep` 决定。超过这个设置天数的数据文件，将被系统自动删除，释放存储空间。
 
-给定 days 与 keep 两个参数，一个典型工作状态的 vnode 中总的数据文件数为：向上取整 `(keep/days)+1` 个。总的数据文件个数不宜过大，也不宜过小。10 到 100 以内合适。基于这个原则，可以设置合理的 days。目前的版本，参数 keep 可以修改，但对于参数 days，一旦设置后，不可修改。
+给定 `duration` 与 `keep` 两个参数，一个典型工作状态的 vnode 中总的数据文件数为：向上取整 `(keep/duration)+1` 个。总的数据文件个数不宜过大，也不宜过小。10 到 100 以内合适。基于这个原则，可以设置合理的 `duration`。目前的版本，参数 `keep` 可以修改，但对于参数 `duration`，一旦设置后，不可修改。
 
 在每个数据文件里，一张表的数据是一块一块存储的。一张表可以有一到多个数据文件块。在一个文件块里，数据是列式存储的，占用的是一片连续的存储空间，这样大大提高读取速度。文件块的大小由系统参数 maxRows （每块最大记录条数）决定，缺省值为 4096。这个值不宜过大，也不宜过小。过大，定位具体时间段的数据的搜索时间会变长，影响读取速度；过小，数据块的索引太大，压缩效率偏低，也影响读取速度。
 

include/common/systable.h

@@ -47,14 +47,14 @@ extern "C" {
 #define TSDB_INS_TABLE_TOPICS            "ins_topics"
 #define TSDB_INS_TABLE_STREAMS           "ins_streams"
 
-#define TSDB_PERFORMANCE_SCHEMA_DB     "performance_schema"
-#define TSDB_PERFS_TABLE_SMAS          "perf_smas"
-#define TSDB_PERFS_TABLE_CONNECTIONS   "perf_connections"
-#define TSDB_PERFS_TABLE_QUERIES       "perf_queries"
-#define TSDB_PERFS_TABLE_CONSUMERS     "perf_consumers"
-#define TSDB_PERFS_TABLE_OFFSETS       "perf_offsets"
-#define TSDB_PERFS_TABLE_TRANS         "perf_trans"
-#define TSDB_PERFS_TABLE_APPS          "perf_apps"
+#define TSDB_PERFORMANCE_SCHEMA_DB   "performance_schema"
+#define TSDB_PERFS_TABLE_SMAS        "perf_smas"
+#define TSDB_PERFS_TABLE_CONNECTIONS "perf_connections"
+#define TSDB_PERFS_TABLE_QUERIES     "perf_queries"
+#define TSDB_PERFS_TABLE_CONSUMERS   "perf_consumers"
+#define TSDB_PERFS_TABLE_OFFSETS     "perf_offsets"
+#define TSDB_PERFS_TABLE_TRANS       "perf_trans"
+#define TSDB_PERFS_TABLE_APPS        "perf_apps"
 
 typedef struct SSysDbTableSchema {
   const char*   name;

include/common/tglobal.h

@@ -140,7 +140,7 @@ extern int32_t tsTtlPushInterval;
 extern int32_t tsGrantHBInterval;
 extern int32_t tsUptimeInterval;
 
-#define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
+//#define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
 int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char **envCmd,
                       const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc);

include/common/tgrant.h

@@ -47,22 +47,23 @@ typedef enum {
 int32_t grantCheck(EGrantType grant);
 
 #ifndef GRANTS_CFG
-#define GRANTS_SCHEMA static const SSysDbTableSchema grantsSchema[] = {                          \
-    {.name = "version", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
-    {.name = "expire_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
-    {.name = "expired", .bytes = 5 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
-    {.name = "storage", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
-    {.name = "timeseries", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
-    {.name = "databases", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},     \
-    {.name = "users", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},         \
-    {.name = "accounts", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
-    {.name = "dnodes", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
-    {.name = "connections", .bytes = 11 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
-    {.name = "streams", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
-    {.name = "cpu_cores", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
-    {.name = "speed", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},          \
-    {.name = "querytime", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
-}
+#define GRANTS_SCHEMA                                                                            \
+  static const SSysDbTableSchema grantsSchema[] = {                                              \
+      {.name = "version", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
+      {.name = "expire_time", .bytes = 19 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, \
+      {.name = "expired", .bytes = 5 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
+      {.name = "storage", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},     \
+      {.name = "timeseries", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},  \
+      {.name = "databases", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},   \
+      {.name = "users", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},       \
+      {.name = "accounts", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
+      {.name = "dnodes", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
+      {.name = "connections", .bytes = 11 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, \
+      {.name = "streams", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},      \
+      {.name = "cpu_cores", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
+      {.name = "speed", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},        \
+      {.name = "querytime", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},    \
+  }
 #define GRANT_CFG_ADD
 #define GRANT_CFG_SET
 #define GRANT_CFG_GET

include/common/tmsgtype.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+// clang-format off
+
 // sql type
 
 #ifdef TSDB_SQL_C
@@ -103,8 +105,10 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MAX, "max" )
 };
 
+// clang-format on
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /*_TD_COMMON_SQLMSGTYPE_H_*/
+#endif /*_TD_COMMON_SQLMSGTYPE_H_*/

include/common/tname.h

@@ -49,7 +49,7 @@ bool tNameIsValid(const SName* name);
 
 const char* tNameGetTableName(const SName* name);
 
-int32_t tNameGetDbName(const SName* name, char* dst);
+int32_t     tNameGetDbName(const SName* name, char* dst);
 const char* tNameGetDbNameP(const SName* name);
 
 int32_t tNameGetFullDbName(const SName* name, char* dst);

include/common/trow.h

@@ -285,11 +285,11 @@ static FORCE_INLINE void tdSRowInit(SRowBuilder *pBuilder, int16_t sver) {
   pBuilder->rowType = TD_ROW_TP;  // default STpRow
   pBuilder->sver = sver;
 }
-int32_t tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen);
-int32_t tdSRowSetTpInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t flen);
-int32_t tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen,
-                              int32_t allNullLen, int32_t boundNullLen);
-int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf);
+int32_t                  tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen);
+int32_t                  tdSRowSetTpInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t flen);
+int32_t                  tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen,
+                                               int32_t allNullLen, int32_t boundNullLen);
+int32_t                  tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf);
 static FORCE_INLINE void tdSRowEnd(SRowBuilder *pBuilder) {
   STSRow *pRow = (STSRow *)pBuilder->pBuf;
   if (pBuilder->hasNull || pBuilder->hasNone) {

include/common/ttime.h

@@ -59,11 +59,11 @@ static FORCE_INLINE int64_t taosGetTimestamp(int32_t precision) {
  *    precision == TSDB_TIME_PRECISION_NANO,  it returns timestamp in nanosecond.
  */
 static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
-  int64_t    factor = (precision == TSDB_TIME_PRECISION_MILLI)   ? 1000
-                      : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000000
-                                                                 : 1000000000;
-  time_t     t = taosTime(NULL);
-  struct tm  tm;
+  int64_t   factor = (precision == TSDB_TIME_PRECISION_MILLI)   ? 1000
+                     : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000000
+                                                                : 1000000000;
+  time_t    t = taosTime(NULL);
+  struct tm tm;
   taosLocalTime(&t, &tm);
   tm.tm_hour = 0;
   tm.tm_min = 0;

include/common/ttokendef.h

@@ -152,166 +152,166 @@
 #define TK_TABLES               134
 #define TK_STABLES              135
 #define TK_MNODES               136
-#define TK_MODULES              137
-#define TK_QNODES               138
-#define TK_FUNCTIONS            139
-#define TK_INDEXES              140
-#define TK_ACCOUNTS             141
-#define TK_APPS                 142
-#define TK_CONNECTIONS          143
-#define TK_LICENCES             144
-#define TK_GRANTS               145
-#define TK_QUERIES              146
-#define TK_SCORES               147
-#define TK_TOPICS               148
-#define TK_VARIABLES            149
-#define TK_BNODES               150
-#define TK_SNODES               151
-#define TK_CLUSTER              152
-#define TK_TRANSACTIONS         153
-#define TK_DISTRIBUTED          154
-#define TK_CONSUMERS            155
-#define TK_SUBSCRIPTIONS        156
-#define TK_VNODES               157
-#define TK_LIKE                 158
-#define TK_INDEX                159
-#define TK_FUNCTION             160
-#define TK_INTERVAL             161
-#define TK_TOPIC                162
-#define TK_AS                   163
-#define TK_WITH                 164
-#define TK_META                 165
-#define TK_CONSUMER             166
-#define TK_GROUP                167
-#define TK_DESC                 168
-#define TK_DESCRIBE             169
-#define TK_RESET                170
-#define TK_QUERY                171
-#define TK_CACHE                172
-#define TK_EXPLAIN              173
-#define TK_ANALYZE              174
-#define TK_VERBOSE              175
-#define TK_NK_BOOL              176
-#define TK_RATIO                177
-#define TK_NK_FLOAT             178
-#define TK_OUTPUTTYPE           179
-#define TK_AGGREGATE            180
-#define TK_BUFSIZE              181
-#define TK_STREAM               182
-#define TK_INTO                 183
-#define TK_TRIGGER              184
-#define TK_AT_ONCE              185
-#define TK_WINDOW_CLOSE         186
-#define TK_IGNORE               187
-#define TK_EXPIRED              188
-#define TK_SUBTABLE             189
-#define TK_KILL                 190
-#define TK_CONNECTION           191
-#define TK_TRANSACTION          192
-#define TK_BALANCE              193
-#define TK_VGROUP               194
-#define TK_MERGE                195
-#define TK_REDISTRIBUTE         196
-#define TK_SPLIT                197
-#define TK_DELETE               198
-#define TK_INSERT               199
-#define TK_NULL                 200
-#define TK_NK_QUESTION          201
-#define TK_NK_ARROW             202
-#define TK_ROWTS                203
-#define TK_TBNAME               204
-#define TK_QSTART               205
-#define TK_QEND                 206
-#define TK_QDURATION            207
-#define TK_WSTART               208
-#define TK_WEND                 209
-#define TK_WDURATION            210
-#define TK_IROWTS               211
-#define TK_QTAGS                212
-#define TK_CAST                 213
-#define TK_NOW                  214
-#define TK_TODAY                215
-#define TK_TIMEZONE             216
-#define TK_CLIENT_VERSION       217
-#define TK_SERVER_VERSION       218
-#define TK_SERVER_STATUS        219
-#define TK_CURRENT_USER         220
-#define TK_COUNT                221
-#define TK_LAST_ROW             222
-#define TK_CASE                 223
-#define TK_END                  224
-#define TK_WHEN                 225
-#define TK_THEN                 226
-#define TK_ELSE                 227
-#define TK_BETWEEN              228
-#define TK_IS                   229
-#define TK_NK_LT                230
-#define TK_NK_GT                231
-#define TK_NK_LE                232
-#define TK_NK_GE                233
-#define TK_NK_NE                234
-#define TK_MATCH                235
-#define TK_NMATCH               236
-#define TK_CONTAINS             237
-#define TK_IN                   238
-#define TK_JOIN                 239
-#define TK_INNER                240
-#define TK_SELECT               241
-#define TK_DISTINCT             242
-#define TK_WHERE                243
-#define TK_PARTITION            244
-#define TK_BY                   245
-#define TK_SESSION              246
-#define TK_STATE_WINDOW         247
-#define TK_SLIDING              248
-#define TK_FILL                 249
-#define TK_VALUE                250
-#define TK_NONE                 251
-#define TK_PREV                 252
-#define TK_LINEAR               253
-#define TK_NEXT                 254
-#define TK_HAVING               255
-#define TK_RANGE                256
-#define TK_EVERY                257
-#define TK_ORDER                258
-#define TK_SLIMIT               259
-#define TK_SOFFSET              260
-#define TK_LIMIT                261
-#define TK_OFFSET               262
-#define TK_ASC                  263
-#define TK_NULLS                264
-#define TK_ABORT                265
-#define TK_AFTER                266
-#define TK_ATTACH               267
-#define TK_BEFORE               268
-#define TK_BEGIN                269
-#define TK_BITAND               270
-#define TK_BITNOT               271
-#define TK_BITOR                272
-#define TK_BLOCKS               273
-#define TK_CHANGE               274
-#define TK_COMMA                275
-#define TK_COMPACT              276
-#define TK_CONCAT               277
-#define TK_CONFLICT             278
-#define TK_COPY                 279
-#define TK_DEFERRED             280
-#define TK_DELIMITERS           281
-#define TK_DETACH               282
-#define TK_DIVIDE               283
-#define TK_DOT                  284
-#define TK_EACH                 285
-#define TK_FAIL                 286
-#define TK_FILE                 287
-#define TK_FOR                  288
-#define TK_GLOB                 289
-#define TK_ID                   290
-#define TK_IMMEDIATE            291
-#define TK_IMPORT               292
-#define TK_INITIALLY            293
-#define TK_INSTEAD              294
-#define TK_ISNULL               295
-#define TK_KEY                  296
+#define TK_QNODES               137
+#define TK_FUNCTIONS            138
+#define TK_INDEXES              139
+#define TK_ACCOUNTS             140
+#define TK_APPS                 141
+#define TK_CONNECTIONS          142
+#define TK_LICENCES             143
+#define TK_GRANTS               144
+#define TK_QUERIES              145
+#define TK_SCORES               146
+#define TK_TOPICS               147
+#define TK_VARIABLES            148
+#define TK_BNODES               149
+#define TK_SNODES               150
+#define TK_CLUSTER              151
+#define TK_TRANSACTIONS         152
+#define TK_DISTRIBUTED          153
+#define TK_CONSUMERS            154
+#define TK_SUBSCRIPTIONS        155
+#define TK_VNODES               156
+#define TK_LIKE                 157
+#define TK_INDEX                158
+#define TK_FUNCTION             159
+#define TK_INTERVAL             160
+#define TK_TOPIC                161
+#define TK_AS                   162
+#define TK_WITH                 163
+#define TK_META                 164
+#define TK_CONSUMER             165
+#define TK_GROUP                166
+#define TK_DESC                 167
+#define TK_DESCRIBE             168
+#define TK_RESET                169
+#define TK_QUERY                170
+#define TK_CACHE                171
+#define TK_EXPLAIN              172
+#define TK_ANALYZE              173
+#define TK_VERBOSE              174
+#define TK_NK_BOOL              175
+#define TK_RATIO                176
+#define TK_NK_FLOAT             177
+#define TK_OUTPUTTYPE           178
+#define TK_AGGREGATE            179
+#define TK_BUFSIZE              180
+#define TK_STREAM               181
+#define TK_INTO                 182
+#define TK_TRIGGER              183
+#define TK_AT_ONCE              184
+#define TK_WINDOW_CLOSE         185
+#define TK_IGNORE               186
+#define TK_EXPIRED              187
+#define TK_SUBTABLE             188
+#define TK_KILL                 189
+#define TK_CONNECTION           190
+#define TK_TRANSACTION          191
+#define TK_BALANCE              192
+#define TK_VGROUP               193
+#define TK_MERGE                194
+#define TK_REDISTRIBUTE         195
+#define TK_SPLIT                196
+#define TK_DELETE               197
+#define TK_INSERT               198
+#define TK_NULL                 199
+#define TK_NK_QUESTION          200
+#define TK_NK_ARROW             201
+#define TK_ROWTS                202
+#define TK_TBNAME               203
+#define TK_QSTART               204
+#define TK_QEND                 205
+#define TK_QDURATION            206
+#define TK_WSTART               207
+#define TK_WEND                 208
+#define TK_WDURATION            209
+#define TK_IROWTS               210
+#define TK_QTAGS                211
+#define TK_CAST                 212
+#define TK_NOW                  213
+#define TK_TODAY                214
+#define TK_TIMEZONE             215
+#define TK_CLIENT_VERSION       216
+#define TK_SERVER_VERSION       217
+#define TK_SERVER_STATUS        218
+#define TK_CURRENT_USER         219
+#define TK_COUNT                220
+#define TK_LAST_ROW             221
+#define TK_CASE                 222
+#define TK_END                  223
+#define TK_WHEN                 224
+#define TK_THEN                 225
+#define TK_ELSE                 226
+#define TK_BETWEEN              227
+#define TK_IS                   228
+#define TK_NK_LT                229
+#define TK_NK_GT                230
+#define TK_NK_LE                231
+#define TK_NK_GE                232
+#define TK_NK_NE                233
+#define TK_MATCH                234
+#define TK_NMATCH               235
+#define TK_CONTAINS             236
+#define TK_IN                   237
+#define TK_JOIN                 238
+#define TK_INNER                239
+#define TK_SELECT               240
+#define TK_DISTINCT             241
+#define TK_WHERE                242
+#define TK_PARTITION            243
+#define TK_BY                   244
+#define TK_SESSION              245
+#define TK_STATE_WINDOW         246
+#define TK_SLIDING              247
+#define TK_FILL                 248
+#define TK_VALUE                249
+#define TK_NONE                 250
+#define TK_PREV                 251
+#define TK_LINEAR               252
+#define TK_NEXT                 253
+#define TK_HAVING               254
+#define TK_RANGE                255
+#define TK_EVERY                256
+#define TK_ORDER                257
+#define TK_SLIMIT               258
+#define TK_SOFFSET              259
+#define TK_LIMIT                260
+#define TK_OFFSET               261
+#define TK_ASC                  262
+#define TK_NULLS                263
+#define TK_ABORT                264
+#define TK_AFTER                265
+#define TK_ATTACH               266
+#define TK_BEFORE               267
+#define TK_BEGIN                268
+#define TK_BITAND               269
+#define TK_BITNOT               270
+#define TK_BITOR                271
+#define TK_BLOCKS               272
+#define TK_CHANGE               273
+#define TK_COMMA                274
+#define TK_COMPACT              275
+#define TK_CONCAT               276
+#define TK_CONFLICT             277
+#define TK_COPY                 278
+#define TK_DEFERRED             279
+#define TK_DELIMITERS           280
+#define TK_DETACH               281
+#define TK_DIVIDE               282
+#define TK_DOT                  283
+#define TK_EACH                 284
+#define TK_FAIL                 285
+#define TK_FILE                 286
+#define TK_FOR                  287
+#define TK_GLOB                 288
+#define TK_ID                   289
+#define TK_IMMEDIATE            290
+#define TK_IMPORT               291
+#define TK_INITIALLY            292
+#define TK_INSTEAD              293
+#define TK_ISNULL               294
+#define TK_KEY                  295
+#define TK_MODULES              296
 #define TK_NK_BITNOT            297
 #define TK_NK_SEMI              298
 #define TK_NOTNULL              299

include/common/ttszip.h

@@ -144,4 +144,4 @@ bool tsBufIsValidElem(STSElem* pElem);
 }
 #endif
 
-#endif  /*_TD_COMMON_TTSZIP_H_*/
+#endif /*_TD_COMMON_TTSZIP_H_*/

include/libs/catalog/catalog.h

@@ -115,7 +115,7 @@ typedef struct SSTableVersion {
   uint64_t dbId;
   uint64_t suid;
   int16_t  sversion;
-  int16_t  tversion;  
+  int16_t  tversion;
   int32_t  smaVer;
 } SSTableVersion;
 
@@ -182,7 +182,8 @@ int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId,
  * @param pTableMeta(output, table meta data, NEED to free it by calller)
  * @return error code
  */
-int32_t catalogGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName, STableMeta** pTableMeta);
+int32_t catalogGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName,
+                            STableMeta** pTableMeta);
 
 /**
  * Get a super table's meta data.
@@ -193,9 +194,10 @@ int32_t catalogGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const S
  * @param pTableMeta(output, table meta data, NEED to free it by calller)
  * @return error code
  */
-int32_t catalogGetSTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName, STableMeta** pTableMeta);
+int32_t catalogGetSTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName,
+                             STableMeta** pTableMeta);
 
-int32_t catalogUpdateTableMeta(SCatalog* pCatalog, STableMetaRsp *rspMsg);
+int32_t catalogUpdateTableMeta(SCatalog* pCatalog, STableMetaRsp* rspMsg);
 
 int32_t catalogUpdateTableMeta(SCatalog* pCatalog, STableMetaRsp* rspMsg);
 
@@ -232,7 +234,8 @@ int32_t catalogRefreshTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, con
  * @param isSTable (input, is super table or not, 1:supposed to be stable, 0: supposed not to be stable, -1:not sure)
  * @return error code
  */
-int32_t catalogRefreshGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName, STableMeta** pTableMeta, int32_t isSTable);
+int32_t catalogRefreshGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName,
+                                   STableMeta** pTableMeta, int32_t isSTable);
 
 /**
  * Get a table's actual vgroup, for stable it's all possible vgroup list.
@@ -243,7 +246,8 @@ int32_t catalogRefreshGetTableMeta(SCatalog* pCatalog, SRequestConnInfo* pConn,
  * @param pVgroupList (output, vgroup info list, element is SVgroupInfo, NEED to simply free the array by caller)
  * @return error code
  */
-int32_t catalogGetTableDistVgInfo(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName, SArray** pVgroupList);
+int32_t catalogGetTableDistVgInfo(SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName,
+                                  SArray** pVgroupList);
 
 /**
  * Get a table's vgroup from its name's hash value.
@@ -267,13 +271,14 @@ int32_t catalogGetTableHashVgroup(SCatalog* pCatalog, SRequestConnInfo* pConn, c
  */
 int32_t catalogGetAllMeta(SCatalog* pCatalog, SRequestConnInfo* pConn, const SCatalogReq* pReq, SMetaData* pRsp);
 
-int32_t catalogAsyncGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SCatalogReq* pReq, catalogCallback fp, void* param, int64_t* jobId);
+int32_t catalogAsyncGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SCatalogReq* pReq, catalogCallback fp,
+                               void* param, int64_t* jobId);
 
 int32_t catalogGetQnodeList(SCatalog* pCatalog, SRequestConnInfo* pConn, SArray* pQnodeList);
 
 int32_t catalogGetDnodeList(SCatalog* pCatalog, SRequestConnInfo* pConn, SArray** pDnodeList);
 
-int32_t catalogGetExpiredSTables(SCatalog* pCatalog, SSTableVersion **stables, uint32_t *num);
+int32_t catalogGetExpiredSTables(SCatalog* pCatalog, SSTableVersion** stables, uint32_t* num);
 
 int32_t catalogGetExpiredDBs(SCatalog* pCatalog, SDbVgVersion** dbs, uint32_t* num);
 
@@ -285,19 +290,20 @@ int32_t catalogGetIndexMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const char*
 
 int32_t catalogGetTableIndex(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName, SArray** pRes);
 
-int32_t catalogRefreshGetTableCfg(SCatalog* pCtg, SRequestConnInfo *pConn, const SName* pTableName, STableCfg** pCfg);
+int32_t catalogRefreshGetTableCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName, STableCfg** pCfg);
 
-int32_t catalogUpdateTableIndex(SCatalog* pCtg, STableIndexRsp *pRsp);
+int32_t catalogUpdateTableIndex(SCatalog* pCtg, STableIndexRsp* pRsp);
 
 int32_t catalogGetUdfInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const char* funcName, SFuncInfo* pInfo);
 
-int32_t catalogChkAuth(SCatalog* pCtg, SRequestConnInfo* pConn, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass);
+int32_t catalogChkAuth(SCatalog* pCtg, SRequestConnInfo* pConn, const char* user, const char* dbFName, AUTH_TYPE type,
+                       bool* pass);
 
 int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth);
 
-int32_t catalogUpdateVgEpSet(SCatalog* pCtg, const char* dbFName, int32_t vgId, SEpSet *epSet);
+int32_t catalogUpdateVgEpSet(SCatalog* pCtg, const char* dbFName, int32_t vgId, SEpSet* epSet);
 
-int32_t catalogGetServerVersion(SCatalog* pCtg, SRequestConnInfo *pConn, char** pVersion);
+int32_t catalogGetServerVersion(SCatalog* pCtg, SRequestConnInfo* pConn, char** pVersion);
 
 int32_t ctgdLaunchAsyncCall(SCatalog* pCtg, SRequestConnInfo* pConn, uint64_t reqId, bool forceUpdate);
 

include/libs/executor/dataSinkMgt.h

@@ -20,10 +20,10 @@
 extern "C" {
 #endif
 
-#include "os.h"
-#include "thash.h"
 #include "executor.h"
+#include "os.h"
 #include "plannodes.h"
+#include "thash.h"
 
 #define DS_BUF_LOW   1
 #define DS_BUF_FULL  2
@@ -56,11 +56,11 @@ typedef struct SDataSinkStat {
 } SDataSinkStat;
 
 typedef struct SDataSinkMgtCfg {
-  uint32_t maxDataBlockNum;           // todo: this should be numOfRows?
+  uint32_t maxDataBlockNum;  // todo: this should be numOfRows?
   uint32_t maxDataBlockNumPerQuery;
 } SDataSinkMgtCfg;
 
-int32_t dsDataSinkMgtInit(SDataSinkMgtCfg *cfg);
+int32_t dsDataSinkMgtInit(SDataSinkMgtCfg* cfg);
 
 typedef struct SInputData {
   const struct SSDataBlock* pData;
@@ -79,14 +79,14 @@ typedef struct SOutputData {
 } SOutputData;
 
 /**
- * Create a subplan's datasinker handle for all later operations. 
+ * Create a subplan's datasinker handle for all later operations.
  * @param pDataSink
  * @param pHandle output
  * @return error code
  */
 int32_t dsCreateDataSinker(const SDataSinkNode* pDataSink, DataSinkHandle* pHandle, void* pParam);
 
-int32_t dsDataSinkGetCacheSize(SDataSinkStat *pStat);
+int32_t dsDataSinkGetCacheSize(SDataSinkStat* pStat);
 
 /**
  * Put the result set returned by the executor into datasinker.
@@ -114,7 +114,7 @@ void dsGetDataLength(DataSinkHandle handle, int64_t* pLen, bool* pQueryEnd);
  */
 int32_t dsGetDataBlock(DataSinkHandle handle, SOutputData* pOutput);
 
-int32_t dsGetCacheSize(DataSinkHandle handle, uint64_t *pSize);
+int32_t dsGetCacheSize(DataSinkHandle handle, uint64_t* pSize);
 
 /**
  * After dsGetStatus returns DS_NEED_SCHEDULE, the caller need to put this into the work queue.

include/libs/function/function.h

@@ -176,9 +176,9 @@ struct SScalarParam {
   SColumnInfoData *columnData;
   SHashObj        *pHashFilter;
   int32_t          hashValueType;
-  void            *param; // other parameter, such as meta handle from vnode, to extract table name/tag value
+  void            *param;  // other parameter, such as meta handle from vnode, to extract table name/tag value
   int32_t          numOfRows;
-  int32_t          numOfQualified; // number of qualified elements in the final results
+  int32_t          numOfQualified;  // number of qualified elements in the final results
 };
 
 void    cleanupResultRowEntry(struct SResultRowEntryInfo *pCell);

include/libs/function/taosudf.h

 /*
-* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
-*
-* This program is free software: you can use, redistribute, and/or modify
-* it under the terms of the GNU Affero General Public License, version 3
-* or later ("AGPL"), as published by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful, but WITHOUT
-* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-* FITNESS FOR A PARTICULAR PURPOSE.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #ifndef TDENGINE_TAOSUDF_H
 #define TDENGINE_TAOSUDF_H
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -52,16 +52,15 @@ typedef struct SUdfColumnData {
     } fixLenCol;
 
     struct {
-      int32_t varOffsetsLen;
-      int32_t   *varOffsets;
-      int32_t payloadLen;
-      char   *payload;
-      int32_t payloadAllocLen;
+      int32_t  varOffsetsLen;
+      int32_t *varOffsets;
+      int32_t  payloadLen;
+      char    *payload;
+      int32_t  payloadAllocLen;
     } varLenCol;
   };
 } SUdfColumnData;
 
-
 typedef struct SUdfColumn {
   SUdfColumnMeta colMeta;
   bool           hasNull;
@@ -69,15 +68,15 @@ typedef struct SUdfColumn {
 } SUdfColumn;
 
 typedef struct SUdfDataBlock {
-  int32_t numOfRows;
-  int32_t numOfCols;
+  int32_t      numOfRows;
+  int32_t      numOfCols;
   SUdfColumn **udfCols;
 } SUdfDataBlock;
 
 typedef struct SUdfInterBuf {
   int32_t bufLen;
-  char* buf;
-  int8_t numOfResult; //zero or one
+  char   *buf;
+  int8_t  numOfResult;  // zero or one
 } SUdfInterBuf;
 typedef void *UdfcFuncHandle;
 
@@ -86,28 +85,29 @@ typedef int32_t (*TUdfInitFunc)();
 typedef int32_t (*TUdfDestroyFunc)();
 
 #define UDF_MEMORY_EXP_GROWTH 1.5
-#define NBIT                     (3u)
-#define BitPos(_n)               ((_n) & ((1 << NBIT) - 1))
-#define BMCharPos(bm_, r_)       ((bm_)[(r_) >> NBIT])
-#define BitmapLen(_n) (((_n) + ((1 << NBIT) - 1)) >> NBIT)
+#define NBIT                  (3u)
+#define BitPos(_n)            ((_n) & ((1 << NBIT) - 1))
+#define BMCharPos(bm_, r_)    ((bm_)[(r_) >> NBIT])
+#define BitmapLen(_n)         (((_n) + ((1 << NBIT) - 1)) >> NBIT)
 
 #define udfColDataIsNull_var(pColumn, row) ((pColumn->colData.varLenCol.varOffsets)[row] == -1)
-#define udfColDataIsNull_f(pColumn, row) ((BMCharPos(pColumn->colData.fixLenCol.nullBitmap, row) & (1u << (7u - BitPos(row)))) == (1u << (7u - BitPos(row))))
+#define udfColDataIsNull_f(pColumn, row) \
+  ((BMCharPos(pColumn->colData.fixLenCol.nullBitmap, row) & (1u << (7u - BitPos(row)))) == (1u << (7u - BitPos(row))))
 #define udfColDataSetNull_f(pColumn, row)                                                \
   do {                                                                                   \
     BMCharPos(pColumn->colData.fixLenCol.nullBitmap, row) |= (1u << (7u - BitPos(row))); \
   } while (0)
 
-#define udfColDataSetNotNull_f(pColumn, r_)                                               \
-  do {                                                                                    \
-    BMCharPos(pColumn->colData.fixLenCol.nullBitmap, r_) &= ~(1u << (7u - BitPos(r_)));   \
+#define udfColDataSetNotNull_f(pColumn, r_)                                             \
+  do {                                                                                  \
+    BMCharPos(pColumn->colData.fixLenCol.nullBitmap, r_) &= ~(1u << (7u - BitPos(r_))); \
   } while (0)
-#define udfColDataSetNull_var(pColumn, row)  ((pColumn->colData.varLenCol.varOffsets)[row] = -1)
+#define udfColDataSetNull_var(pColumn, row) ((pColumn->colData.varLenCol.varOffsets)[row] = -1)
 
 typedef uint16_t VarDataLenT;  // maxVarDataLen: 32767
-#define VARSTR_HEADER_SIZE sizeof(VarDataLenT)
-#define varDataLen(v) ((VarDataLenT *)(v))[0]
-#define varDataVal(v) ((char *)(v) + VARSTR_HEADER_SIZE)
+#define VARSTR_HEADER_SIZE     sizeof(VarDataLenT)
+#define varDataLen(v)          ((VarDataLenT *)(v))[0]
+#define varDataVal(v)          ((char *)(v) + VARSTR_HEADER_SIZE)
 #define varDataTLen(v)         (sizeof(VarDataLenT) + varDataLen(v))
 #define varDataCopy(dst, v)    memcpy((dst), (void *)(v), varDataTLen(v))
 #define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
@@ -116,8 +116,7 @@ typedef uint16_t VarDataLenT;  // maxVarDataLen: 32767
   (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON))
 #define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
-
-static FORCE_INLINE char* udfColDataGetData(const SUdfColumn* pColumn, int32_t row) {
+static FORCE_INLINE char *udfColDataGetData(const SUdfColumn *pColumn, int32_t row) {
   if (IS_VAR_DATA_TYPE(pColumn->colMeta.type)) {
     return pColumn->colData.varLenCol.payload + pColumn->colData.varLenCol.varOffsets[row];
   } else {
@@ -125,13 +124,13 @@ static FORCE_INLINE char* udfColDataGetData(const SUdfColumn* pColumn, int32_t r
   }
 }
 
-static FORCE_INLINE bool udfColDataIsNull(const SUdfColumn* pColumn, int32_t row) {
+static FORCE_INLINE bool udfColDataIsNull(const SUdfColumn *pColumn, int32_t row) {
   if (IS_VAR_DATA_TYPE(pColumn->colMeta.type)) {
     if (pColumn->colMeta.type == TSDB_DATA_TYPE_JSON) {
       if (udfColDataIsNull_var(pColumn, row)) {
         return true;
       }
-      char* data = udfColDataGetData(pColumn, row);
+      char *data = udfColDataGetData(pColumn, row);
       return (*data == TSDB_DATA_TYPE_NULL);
     } else {
       return udfColDataIsNull_var(pColumn, row);
@@ -141,29 +140,29 @@ static FORCE_INLINE bool udfColDataIsNull(const SUdfColumn* pColumn, int32_t row
   }
 }
 
-static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn* pColumn, int32_t newCapacity) {
+static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn *pColumn, int32_t newCapacity) {
   SUdfColumnMeta *meta = &pColumn->colMeta;
   SUdfColumnData *data = &pColumn->colData;
 
-  if (newCapacity== 0 || newCapacity <= data->rowsAlloc) {
+  if (newCapacity == 0 || newCapacity <= data->rowsAlloc) {
     return TSDB_CODE_SUCCESS;
   }
 
-  int allocCapacity = (data->rowsAlloc< 8) ? 8 : data->rowsAlloc;
+  int allocCapacity = (data->rowsAlloc < 8) ? 8 : data->rowsAlloc;
   while (allocCapacity < newCapacity) {
     allocCapacity *= UDF_MEMORY_EXP_GROWTH;
   }
 
   if (IS_VAR_DATA_TYPE(meta->type)) {
-    char* tmp = (char*)realloc(data->varLenCol.varOffsets, sizeof(int32_t) * allocCapacity);
+    char *tmp = (char *)realloc(data->varLenCol.varOffsets, sizeof(int32_t) * allocCapacity);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
-    data->varLenCol.varOffsets = (int32_t*)tmp;
+    data->varLenCol.varOffsets = (int32_t *)tmp;
     data->varLenCol.varOffsetsLen = sizeof(int32_t) * allocCapacity;
     // for payload, add data in udfColDataAppend
   } else {
-    char* tmp = (char*)realloc(data->fixLenCol.nullBitmap, BitmapLen(allocCapacity));
+    char *tmp = (char *)realloc(data->fixLenCol.nullBitmap, BitmapLen(allocCapacity));
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -173,13 +172,13 @@ static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn* pColumn, int32_t ne
       return TSDB_CODE_SUCCESS;
     }
 
-    tmp = (char*)realloc(data->fixLenCol.data, allocCapacity* meta->bytes);
+    tmp = (char *)realloc(data->fixLenCol.data, allocCapacity * meta->bytes);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
 
     data->fixLenCol.data = tmp;
-    data->fixLenCol.dataLen = allocCapacity* meta->bytes;
+    data->fixLenCol.dataLen = allocCapacity * meta->bytes;
   }
 
   data->rowsAlloc = allocCapacity;
@@ -187,8 +186,8 @@ static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn* pColumn, int32_t ne
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE void udfColDataSetNull(SUdfColumn* pColumn, int32_t row) {
-  udfColEnsureCapacity(pColumn, row+1);
+static FORCE_INLINE void udfColDataSetNull(SUdfColumn *pColumn, int32_t row) {
+  udfColEnsureCapacity(pColumn, row + 1);
   if (IS_VAR_DATA_TYPE(pColumn->colMeta.type)) {
     udfColDataSetNull_var(pColumn, row);
   } else {
@@ -197,10 +196,10 @@ static FORCE_INLINE void udfColDataSetNull(SUdfColumn* pColumn, int32_t row) {
   pColumn->hasNull = true;
 }
 
-static FORCE_INLINE int32_t udfColDataSet(SUdfColumn* pColumn, uint32_t currentRow, const char* pData, bool isNull) {
+static FORCE_INLINE int32_t udfColDataSet(SUdfColumn *pColumn, uint32_t currentRow, const char *pData, bool isNull) {
   SUdfColumnMeta *meta = &pColumn->colMeta;
   SUdfColumnData *data = &pColumn->colData;
-  udfColEnsureCapacity(pColumn, currentRow+1);
+  udfColEnsureCapacity(pColumn, currentRow + 1);
   bool isVarCol = IS_VAR_DATA_TYPE(meta->type);
   if (isNull) {
     udfColDataSetNull(pColumn, currentRow);
@@ -233,7 +232,7 @@ static FORCE_INLINE int32_t udfColDataSet(SUdfColumn* pColumn, uint32_t currentR
           newSize = newSize * UDF_MEMORY_EXP_GROWTH;
         }
 
-        char *buf = (char*)realloc(data->varLenCol.payload, newSize);
+        char *buf = (char *)realloc(data->varLenCol.payload, newSize);
         if (buf == NULL) {
           return TSDB_CODE_OUT_OF_MEMORY;
         }
@@ -249,11 +248,11 @@ static FORCE_INLINE int32_t udfColDataSet(SUdfColumn* pColumn, uint32_t currentR
       data->varLenCol.payloadLen += dataLen;
     }
   }
-  data->numOfRows = (currentRow + 1 > data->numOfRows) ? (currentRow+1) : data->numOfRows;
+  data->numOfRows = (currentRow + 1 > data->numOfRows) ? (currentRow + 1) : data->numOfRows;
   return 0;
 }
 
-typedef int32_t (*TUdfScalarProcFunc)(SUdfDataBlock* block, SUdfColumn *resultCol);
+typedef int32_t (*TUdfScalarProcFunc)(SUdfDataBlock *block, SUdfColumn *resultCol);
 
 typedef int32_t (*TUdfAggStartFunc)(SUdfInterBuf *buf);
 typedef int32_t (*TUdfAggProcessFunc)(SUdfDataBlock *block, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf);

include/libs/function/tudf.h

@@ -24,12 +24,12 @@
 #define alloc alloc
 #include <taosudf.h>
 
-#include <stdint.h>
 #include <stdbool.h>
-#include "tmsg.h"
-#include "tcommon.h"
+#include <stdint.h>
 #include "function.h"
+#include "tcommon.h"
 #include "tdatablock.h"
+#include "tmsg.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -43,8 +43,7 @@ extern "C" {
 #endif
 #define UDF_DNODE_ID_ENV_NAME "DNODE_ID"
 
-
-//low level APIs
+// low level APIs
 /**
  * setup udf
  * @param udf, in
@@ -62,7 +61,8 @@ int32_t doCallUdfAggProcess(UdfcFuncHandle handle, SSDataBlock *block, SUdfInter
 int32_t doCallUdfAggFinalize(UdfcFuncHandle handle, SUdfInterBuf *interBuf, SUdfInterBuf *resultData);
 // input: interbuf1, interbuf2
 // output: resultBuf
-int32_t doCallUdfAggMerge(UdfcFuncHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2, SUdfInterBuf *resultBuf);
+int32_t doCallUdfAggMerge(UdfcFuncHandle handle, SUdfInterBuf *interBuf1, SUdfInterBuf *interBuf2,
+                          SUdfInterBuf *resultBuf);
 // input: block
 // output: resultData
 int32_t doCallUdfScalarFunc(UdfcFuncHandle handle, SScalarParam *input, int32_t numOfCols, SScalarParam *output);
@@ -75,11 +75,11 @@ int32_t doTeardownUdf(UdfcFuncHandle handle);
 
 void freeUdfInterBuf(SUdfInterBuf *buf);
 
-//high level APIs
-bool udfAggGetEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo* pResultCellInfo);
+// high level APIs
+bool    udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv);
+bool    udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
 int32_t udfAggProcess(struct SqlFunctionCtx *pCtx);
-int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock* pBlock);
+int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock);
 
 int32_t callUdfScalarFunc(char *udfName, SScalarParam *input, int32_t numOfCols, SScalarParam *output);
 

include/libs/monitor/monitor.h

@@ -227,7 +227,6 @@ int32_t tDeserializeSMonMloadInfo(void *buf, int32_t bufLen, SMonMloadInfo *pInf
 int32_t tSerializeSQnodeLoad(void *buf, int32_t bufLen, SQnodeLoad *pInfo);
 int32_t tDeserializeSQnodeLoad(void *buf, int32_t bufLen, SQnodeLoad *pInfo);
 
-
 typedef struct {
   const char *server;
   uint16_t    port;

include/libs/nodes/plannodes.h

@@ -99,6 +99,7 @@ typedef struct SScanLogicNode {
   int8_t        cacheLastMode;
   bool          hasNormalCols;  // neither tag column nor primary key tag column
   bool          sortPrimaryKey;
+  bool          igLastNull;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -115,6 +116,7 @@ typedef struct SAggLogicNode {
   SNodeList* pGroupKeys;
   SNodeList* pAggFuncs;
   bool       hasLastRow;
+  bool       hasLast;
   bool       hasTimeLineFunc;
   bool       onlyHasKeepOrderFunc;
 } SAggLogicNode;
@@ -317,6 +319,7 @@ typedef struct SLastRowScanPhysiNode {
   SScanPhysiNode scan;
   SNodeList*     pGroupTags;
   bool           groupSort;
+  bool           ignoreNull;
 } SLastRowScanPhysiNode;
 
 typedef struct SSystemTableScanPhysiNode {

include/libs/nodes/querynodes.h

@@ -291,6 +291,7 @@ typedef struct SSelectStmt {
   bool        hasTailFunc;
   bool        hasInterpFunc;
   bool        hasLastRowFunc;
+  bool        hasLastFunc;
   bool        hasTimeLineFunc;
   bool        hasUdaf;
   bool        hasStateKey;

include/libs/qcom/query.h

@@ -61,7 +61,6 @@ typedef struct STableComInfo {
   int32_t  rowSize;       // row size of the schema
 } STableComInfo;
 
-
 typedef struct SIndexMeta {
 #if defined(WINDOWS) || defined(_TD_DARWIN_64)
   size_t avoidCompilationErrors;
@@ -70,11 +69,11 @@ typedef struct SIndexMeta {
 } SIndexMeta;
 
 typedef struct SExecResult {
-  int32_t         code;
-  uint64_t        numOfRows;
-  uint64_t        numOfBytes;
-  int32_t         msgType;
-  void*           res;
+  int32_t  code;
+  uint64_t numOfRows;
+  uint64_t numOfBytes;
+  int32_t  msgType;
+  void*    res;
 } SExecResult;
 
 typedef struct STbVerInfo {
@@ -166,7 +165,7 @@ typedef struct SRequestConnInfo {
   SEpSet   mgmtEps;
 } SRequestConnInfo;
 
-typedef void (*__freeFunc)(void *param);
+typedef void (*__freeFunc)(void* param);
 
 typedef struct SMsgSendInfo {
   __async_send_cb_fn_t fp;      // async callback function
@@ -218,7 +217,7 @@ void initQueryModuleMsgHandle();
 const SSchema* tGetTbnameColumnSchema();
 bool           tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
-int32_t queryCreateCTableMetaFromMsg(STableMetaRsp *msg, SCTableMeta *pMeta);
+int32_t queryCreateCTableMetaFromMsg(STableMetaRsp* msg, SCTableMeta* pMeta);
 int32_t queryCreateTableMetaFromMsg(STableMetaRsp* msg, bool isSuperTable, STableMeta** pMeta);
 char*   jobTaskStatusStr(int32_t status);
 
@@ -250,64 +249,66 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 #define NEED_CLIENT_HANDLE_ERROR(_code)                                          \
   (NEED_CLIENT_RM_TBLMETA_ERROR(_code) || NEED_CLIENT_REFRESH_VG_ERROR(_code) || \
    NEED_CLIENT_REFRESH_TBLMETA_ERROR(_code))
-#define NEED_REDIRECT_ERROR(_code)                                                      \
-  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL ||     \
-   (_code) == TSDB_CODE_NODE_NOT_DEPLOYED || (_code) == TSDB_CODE_SYN_NOT_LEADER ||     \
+#define NEED_REDIRECT_ERROR(_code)                                                  \
+  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL || \
+   (_code) == TSDB_CODE_NODE_NOT_DEPLOYED || (_code) == TSDB_CODE_SYN_NOT_LEADER || \
    (_code) == TSDB_CODE_APP_NOT_READY || (_code) == TSDB_CODE_RPC_BROKEN_LINK)
-  
+
 #define NEED_CLIENT_RM_TBLMETA_REQ(_type)                                                                  \
   ((_type) == TDMT_VND_CREATE_TABLE || (_type) == TDMT_MND_CREATE_STB || (_type) == TDMT_VND_DROP_TABLE || \
    (_type) == TDMT_MND_DROP_STB)
 
-#define NEED_SCHEDULER_REDIRECT_ERROR(_code)                                                      \
-  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_NODE_NOT_DEPLOYED ||                 \
+#define NEED_SCHEDULER_REDIRECT_ERROR(_code)                                      \
+  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_NODE_NOT_DEPLOYED || \
    (_code) == TSDB_CODE_SYN_NOT_LEADER || (_code) == TSDB_CODE_APP_NOT_READY)
 
 #define REQUEST_TOTAL_EXEC_TIMES 2
 
-#define IS_SYS_DBNAME(_dbname) (((*(_dbname) == 'i') && (0 == strcmp(_dbname, TSDB_INFORMATION_SCHEMA_DB))) || ((*(_dbname) == 'p') && (0 == strcmp(_dbname, TSDB_PERFORMANCE_SCHEMA_DB))))
+#define IS_SYS_DBNAME(_dbname)                                                    \
+  (((*(_dbname) == 'i') && (0 == strcmp(_dbname, TSDB_INFORMATION_SCHEMA_DB))) || \
+   ((*(_dbname) == 'p') && (0 == strcmp(_dbname, TSDB_PERFORMANCE_SCHEMA_DB))))
 
-#define qFatal(...)                                                                           \
-  do {                                                                                        \
-    if (qDebugFlag & DEBUG_FATAL) {                                                           \
+#define qFatal(...)                                                     \
+  do {                                                                  \
+    if (qDebugFlag & DEBUG_FATAL) {                                     \
       taosPrintLog("QRY FATAL ", DEBUG_FATAL, qDebugFlag, __VA_ARGS__); \
-    }                                                                                         \
+    }                                                                   \
   } while (0)
-#define qError(...)                                                                           \
-  do {                                                                                        \
-    if (qDebugFlag & DEBUG_ERROR) {                                                           \
+#define qError(...)                                                     \
+  do {                                                                  \
+    if (qDebugFlag & DEBUG_ERROR) {                                     \
       taosPrintLog("QRY ERROR ", DEBUG_ERROR, qDebugFlag, __VA_ARGS__); \
-    }                                                                                         \
+    }                                                                   \
   } while (0)
-#define qWarn(...)                                                                          \
-  do {                                                                                      \
-    if (qDebugFlag & DEBUG_WARN) {                                                          \
+#define qWarn(...)                                                    \
+  do {                                                                \
+    if (qDebugFlag & DEBUG_WARN) {                                    \
       taosPrintLog("QRY WARN ", DEBUG_WARN, qDebugFlag, __VA_ARGS__); \
-    }                                                                                       \
+    }                                                                 \
   } while (0)
-#define qInfo(...)                                                                     \
-  do {                                                                                 \
-    if (qDebugFlag & DEBUG_INFO) {                                                     \
+#define qInfo(...)                                               \
+  do {                                                           \
+    if (qDebugFlag & DEBUG_INFO) {                               \
       taosPrintLog("QRY ", DEBUG_INFO, qDebugFlag, __VA_ARGS__); \
-    }                                                                                  \
+    }                                                            \
   } while (0)
-#define qDebug(...)                                                                     \
-  do {                                                                                  \
-    if (qDebugFlag & DEBUG_DEBUG) {                                                     \
+#define qDebug(...)                                               \
+  do {                                                            \
+    if (qDebugFlag & DEBUG_DEBUG) {                               \
       taosPrintLog("QRY ", DEBUG_DEBUG, qDebugFlag, __VA_ARGS__); \
-    }                                                                                   \
+    }                                                             \
   } while (0)
-#define qTrace(...)                                                                     \
-  do {                                                                                  \
-    if (qDebugFlag & DEBUG_TRACE) {                                                     \
+#define qTrace(...)                                               \
+  do {                                                            \
+    if (qDebugFlag & DEBUG_TRACE) {                               \
       taosPrintLog("QRY ", DEBUG_TRACE, qDebugFlag, __VA_ARGS__); \
-    }                                                                                   \
+    }                                                             \
   } while (0)
-#define qDebugL(...)                                                                           \
-  do {                                                                                         \
-    if (qDebugFlag & DEBUG_DEBUG) {                                                            \
+#define qDebugL(...)                                                     \
+  do {                                                                   \
+    if (qDebugFlag & DEBUG_DEBUG) {                                      \
       taosPrintLongString("QRY ", DEBUG_DEBUG, qDebugFlag, __VA_ARGS__); \
-    }                                                                                          \
+    }                                                                    \
   } while (0)
 
 #define QRY_ERR_RET(c)                \

include/libs/qworker/qworker.h

@@ -72,7 +72,6 @@ typedef struct SQWMsg {
   SRpcHandleInfo connInfo;
 } SQWMsg;
 
-
 int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, void **qWorkerMgmt, const SMsgCb *pMsgCb);
 
 int32_t qWorkerAbortPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg);
@@ -95,13 +94,15 @@ int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_
 
 int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SDeleteRes *pRes);
 
-void    qWorkerDestroy(void **qWorkerMgmt);
+void qWorkerDestroy(void **qWorkerMgmt);
 
 int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pStat);
 
-int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId, SQWMsg *qwMsg, SArray *explainRes);
+int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
+                                 SQWMsg *qwMsg, SArray *explainRes);
 
-int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId, void** pRsp, SArray* explainRes);
+int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId,
+                                 void **pRsp, SArray *explainRes);
 
 #ifdef __cplusplus
 }

include/libs/scalar/filter.h

@@ -31,9 +31,9 @@ enum {
   FLT_OPTION_NEED_UNIQE = 4,
 };
 
-#define FILTER_RESULT_ALL_QUALIFIED        0x1
-#define FILTER_RESULT_NONE_QUALIFIED       0x2
-#define FILTER_RESULT_PARTIAL_QUALIFIED    0x3
+#define FILTER_RESULT_ALL_QUALIFIED     0x1
+#define FILTER_RESULT_NONE_QUALIFIED    0x2
+#define FILTER_RESULT_PARTIAL_QUALIFIED 0x3
 
 typedef struct SFilterColumnParam {
   int32_t numOfCols;
@@ -41,7 +41,8 @@ typedef struct SFilterColumnParam {
 } SFilterColumnParam;
 
 extern int32_t filterInitFromNode(SNode *pNode, SFilterInfo **pinfo, uint32_t options);
-extern bool filterExecute(SFilterInfo *info, SSDataBlock *pSrc, SColumnInfoData** p, SColumnDataAgg *statis, int16_t numOfCols, int32_t* pFilterResStatus);
+extern bool    filterExecute(SFilterInfo *info, SSDataBlock *pSrc, SColumnInfoData **p, SColumnDataAgg *statis,
+                             int16_t numOfCols, int32_t *pFilterResStatus);
 extern int32_t filterSetDataFromSlotId(SFilterInfo *info, void *param);
 extern int32_t filterSetDataFromColId(SFilterInfo *info, void *param);
 extern int32_t filterGetTimeRange(SNode *pNode, STimeWindow *win, bool *isStrict);

include/libs/scheduler/scheduler.h

@@ -26,18 +26,18 @@ extern "C" {
 extern tsem_t schdRspSem;
 
 typedef struct SQueryProfileSummary {
-  int64_t startTs;      // Object created and added into the message queue
-  int64_t endTs;        // the timestamp when the task is completed
-  int64_t cputime;      // total cpu cost, not execute elapsed time
+  int64_t startTs;  // Object created and added into the message queue
+  int64_t endTs;    // the timestamp when the task is completed
+  int64_t cputime;  // total cpu cost, not execute elapsed time
 
-  int64_t loadRemoteDataDuration;       // remote io time
-  int64_t loadNativeDataDuration;       // native disk io time
+  int64_t loadRemoteDataDuration;  // remote io time
+  int64_t loadNativeDataDuration;  // native disk io time
 
-  uint64_t loadNativeData; // blocks + SMA + header files
-  uint64_t loadRemoteData; // remote data acquired by exchange operator.
+  uint64_t loadNativeData;  // blocks + SMA + header files
+  uint64_t loadRemoteData;  // remote data acquired by exchange operator.
 
-  uint64_t waitDuration; // the time to waiting to be scheduled in queue does matter, so we need to record it
-  int64_t  addQTs;       // the time to be added into the message queue, used to calculate the waiting duration in queue.
+  uint64_t waitDuration;  // the time to waiting to be scheduled in queue does matter, so we need to record it
+  int64_t  addQTs;  // the time to be added into the message queue, used to calculate the waiting duration in queue.
 
   uint64_t totalRows;
   uint64_t loadRows;
@@ -45,16 +45,16 @@ typedef struct SQueryProfileSummary {
   uint32_t loadBlocks;
   uint32_t loadBlockAgg;
   uint32_t skipBlocks;
-  uint64_t resultSize;   // generated result size in Kb.
+  uint64_t resultSize;  // generated result size in Kb.
 } SQueryProfileSummary;
 
 typedef struct STaskInfo {
   SQueryNodeAddr addr;
-  SSubQueryMsg  *msg;
+  SSubQueryMsg*  msg;
 } STaskInfo;
 
 typedef struct SSchdFetchParam {
-  void **pData;
+  void**   pData;
   int32_t* code;
 } SSchdFetchParam;
 
@@ -63,35 +63,34 @@ typedef void (*schedulerFetchFp)(void* pResult, void* param, int32_t code);
 typedef bool (*schedulerChkKillFp)(void* param);
 
 typedef struct SSchedulerReq {
-  bool                  syncReq;
-  bool                  localReq;
-  SRequestConnInfo     *pConn;
-  SArray               *pNodeList;
-  SQueryPlan           *pDag;
-  int64_t               allocatorRefId;
-  const char           *sql;
-  int64_t               startTs;
-  schedulerExecFp       execFp;
-  schedulerFetchFp      fetchFp;
-  void*                 cbParam;
-  schedulerChkKillFp    chkKillFp;
-  void*                 chkKillParam;
-  SExecResult*          pExecRes;
-  void**                pFetchRes;
+  bool               syncReq;
+  bool               localReq;
+  SRequestConnInfo*  pConn;
+  SArray*            pNodeList;
+  SQueryPlan*        pDag;
+  int64_t            allocatorRefId;
+  const char*        sql;
+  int64_t            startTs;
+  schedulerExecFp    execFp;
+  schedulerFetchFp   fetchFp;
+  void*              cbParam;
+  schedulerChkKillFp chkKillFp;
+  void*              chkKillParam;
+  SExecResult*       pExecRes;
+  void**             pFetchRes;
 } SSchedulerReq;
 
-
 int32_t schedulerInit(void);
 
-int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJob);
+int32_t schedulerExecJob(SSchedulerReq* pReq, int64_t* pJob);
 
-int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq);
+int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq* pReq);
 
 void schedulerFetchRowsA(int64_t job, schedulerFetchFp fp, void* param);
 
-int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub);
+int32_t schedulerGetTasksStatus(int64_t job, SArray* pSub);
 
-void schedulerStopQueryHb(void *pTrans);
+void schedulerStopQueryHb(void* pTrans);
 
 int32_t schedulerUpdatePolicy(int32_t policy);
 int32_t schedulerEnableReSchedule(bool enableResche);
@@ -101,7 +100,7 @@ int32_t schedulerEnableReSchedule(bool enableResche);
  * @param pJob
  * @return
  */
-//int32_t scheduleCancelJob(void *pJob);
+// int32_t scheduleCancelJob(void *pJob);
 
 /**
  * Free the query job

include/libs/sync/sync.h

@@ -132,7 +132,7 @@ typedef struct SSyncFSM {
   void (*FpRollBackCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);
 
   void (*FpRestoreFinishCb)(struct SSyncFSM* pFsm);
-  void (*FpReConfigCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SReConfigCbMeta *cbMeta);
+  void (*FpReConfigCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SReConfigCbMeta* cbMeta);
   void (*FpLeaderTransferCb)(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);
 
   void (*FpBecomeLeaderCb)(struct SSyncFSM* pFsm);

include/libs/tfs/tfs.h

@@ -16,15 +16,15 @@
 #ifndef _TD_TFS_H_
 #define _TD_TFS_H_
 
-#include "tdef.h"
 #include "monitor.h"
+#include "tdef.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct STfs STfs;
+typedef struct STfs    STfs;
 typedef struct STfsDir STfsDir;
 
 typedef struct {

include/libs/transport/trpc.h

@@ -82,6 +82,9 @@ typedef struct SRpcInit {
   int8_t   connType;      // TAOS_CONN_UDP, TAOS_CONN_TCPC, TAOS_CONN_TCPS
   int32_t  idleTime;      // milliseconds, 0 means idle timer is disabled
 
+  int32_t compressSize;  // -1: no compress, 0 : all data compressed, size: compress data if larger than size
+  int8_t  encryption;    // encrypt or not
+
   // the following is for client app ecurity only
   char *user;  // user name
 
@@ -115,10 +118,9 @@ typedef struct {
 } SRpcCtx;
 
 int32_t rpcInit();
+void    rpcCleanup();
 
-void  rpcCleanup();
 void *rpcOpen(const SRpcInit *pRpc);
-
 void  rpcClose(void *);
 void  rpcCloseImpl(void *);
 void *rpcMallocCont(int32_t contLen);

include/os/os.h

@@ -26,33 +26,33 @@ extern "C" {
 #include <regex.h>
 
 #if !defined(WINDOWS)
-#include <unistd.h>
 #include <dirent.h>
+#include <libgen.h>
 #include <sched.h>
+#include <unistd.h>
 #include <wordexp.h>
-#include <libgen.h>
 
-#include <sys/utsname.h>
-#include <sys/param.h>
-#include <sys/mman.h>
 #include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include <sys/shm.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <termios.h>
-#include <sys/statvfs.h>
-#include <sys/shm.h>
+#include <sys/utsname.h>
 #include <sys/wait.h>
+#include <termios.h>
 
 #if defined(DARWIN)
 #else
-#include <sys/prctl.h>
 #include <argp.h>
+#include <sys/prctl.h>
 #endif
 #else
 
 #ifndef __func__
-#define __func__ __FUNCTION__ 
+#define __func__ __FUNCTION__
 #endif
 #include <malloc.h>
 #include <time.h>
@@ -82,11 +82,13 @@ extern "C" {
 #include <wchar.h>
 #include <wctype.h>
 
-#include "taoserror.h"
+#include "osThread.h"
+
 #include "osAtomic.h"
 #include "osDef.h"
 #include "osDir.h"
 #include "osEndian.h"
+#include "osEnv.h"
 #include "osFile.h"
 #include "osLocale.h"
 #include "osLz4.h"
@@ -94,10 +96,9 @@ extern "C" {
 #include "osMemory.h"
 #include "osProc.h"
 #include "osRand.h"
-#include "osThread.h"
 #include "osSemaphore.h"
-#include "osSignal.h"
 #include "osShm.h"
+#include "osSignal.h"
 #include "osSleep.h"
 #include "osSocket.h"
 #include "osString.h"
@@ -106,7 +107,7 @@ extern "C" {
 #include "osTime.h"
 #include "osTimer.h"
 #include "osTimezone.h"
-#include "osEnv.h"
+#include "taoserror.h"
 
 #ifdef __cplusplus
 }

include/os/osDef.h

@@ -21,105 +21,104 @@ extern "C" {
 #endif
 
 #if defined(_TD_DARWIN_64)
-  // specific
+// specific
 #ifndef __COMPAR_FN_T
 #define __COMPAR_FN_T
-  typedef int(*__compar_fn_t)(const void *, const void *);
+typedef int (*__compar_fn_t)(const void *, const void *);
 #endif
 
-  // for send function in tsocket.c
-  #if defined(MSG_NOSIGNAL)
-    #undef MSG_NOSIGNAL
-  #endif
+// for send function in tsocket.c
+#if defined(MSG_NOSIGNAL)
+#undef MSG_NOSIGNAL
+#endif
 
-  #define MSG_NOSIGNAL             0
+#define MSG_NOSIGNAL 0
 
-  #define SO_NO_CHECK              0x1234
-  #define SOL_TCP                  0x1234
-  #define TCP_KEEPIDLE             0x1234
+#define SO_NO_CHECK  0x1234
+#define SOL_TCP      0x1234
+#define TCP_KEEPIDLE 0x1234
 
-  #ifndef PTHREAD_MUTEX_RECURSIVE_NP
-    #define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
-  #endif
+#ifndef PTHREAD_MUTEX_RECURSIVE_NP
+#define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
+#endif
 #endif
 
 #if defined(_ALPINE)
 #ifndef __COMPAR_FN_T
 #define __COMPAR_FN_T
-  typedef int(*__compar_fn_t)(const void *, const void *);
+typedef int (*__compar_fn_t)(const void *, const void *);
+#endif
+void error(int, int, const char *);
+#ifndef PTHREAD_MUTEX_RECURSIVE_NP
+#define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
 #endif
-  void  error (int, int, const char *);
-  #ifndef PTHREAD_MUTEX_RECURSIVE_NP
-    #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
-  #endif
 #endif
-
 
 #if defined(WINDOWS)
-  char *stpcpy (char *dest, const char *src);
-  char *stpncpy (char *dest, const char *src, int n);
+char *stpcpy(char *dest, const char *src);
+char *stpncpy(char *dest, const char *src, int n);
 
-  // specific
+// specific
 #ifndef __COMPAR_FN_T
 #define __COMPAR_FN_T
-  typedef int (*__compar_fn_t)(const void *, const void *);
-#endif
-  #define ssize_t int
-  #define _SSIZE_T_
-  #define bzero(ptr, size) memset((ptr), 0, (size))
-  #define strcasecmp  _stricmp
-  #define strncasecmp _strnicmp
-  #define wcsncasecmp _wcsnicmp
-  #define strtok_r strtok_s
-  // #define snprintf _snprintf
-  #define in_addr_t unsigned long
+typedef int (*__compar_fn_t)(const void *, const void *);
+#endif
+#define ssize_t int
+#define _SSIZE_T_
+#define bzero(ptr, size) memset((ptr), 0, (size))
+#define strcasecmp       _stricmp
+#define strncasecmp      _strnicmp
+#define wcsncasecmp      _wcsnicmp
+#define strtok_r         strtok_s
+// #define snprintf _snprintf
+#define in_addr_t unsigned long
 //  #define socklen_t int
 
-  char *     strsep(char **stringp, const char *delim);
-  char *     getpass(const char *prefix);
-  char *     strndup(const char *s, int n);
-
-  // for send function in tsocket.c
-  #define MSG_NOSIGNAL             0
-  #define SO_NO_CHECK              0x1234
-  #define SOL_TCP                  0x1234
-
-  #define SHUT_RDWR                SD_BOTH
-  #define SHUT_RD                  SD_RECEIVE
-  #define SHUT_WR                  SD_SEND
-
-  #define LOCK_EX 1
-  #define LOCK_NB 2
-  #define LOCK_UN 3
-
-  #ifndef PATH_MAX
-  #define PATH_MAX 256
-  #endif
-
-  typedef struct {
-    int    we_wordc;
-    char  *we_wordv[1];
-    int    we_offs;
-    char   wordPos[1025];
-  } wordexp_t;
-  int  wordexp(char *words, wordexp_t *pwordexp, int flags);
-  void wordfree(wordexp_t *pwordexp);
-
-  #define openlog(a, b, c)
-  #define closelog()
-  #define LOG_ERR 0
-  #define LOG_INFO 1
-  void syslog(int unused, const char *format, ...);
-#endif // WINDOWS
-  
+char *strsep(char **stringp, const char *delim);
+char *getpass(const char *prefix);
+char *strndup(const char *s, int n);
+
+// for send function in tsocket.c
+#define MSG_NOSIGNAL 0
+#define SO_NO_CHECK  0x1234
+#define SOL_TCP      0x1234
+
+#define SHUT_RDWR SD_BOTH
+#define SHUT_RD   SD_RECEIVE
+#define SHUT_WR   SD_SEND
+
+#define LOCK_EX 1
+#define LOCK_NB 2
+#define LOCK_UN 3
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+typedef struct {
+  int   we_wordc;
+  char *we_wordv[1];
+  int   we_offs;
+  char  wordPos[1025];
+} wordexp_t;
+int  wordexp(char *words, wordexp_t *pwordexp, int flags);
+void wordfree(wordexp_t *pwordexp);
+
+#define openlog(a, b, c)
+#define closelog()
+#define LOG_ERR  0
+#define LOG_INFO 1
+void syslog(int unused, const char *format, ...);
+#endif  // WINDOWS
+
 #ifndef WINDOWS
-  #ifndef O_BINARY
-    #define O_BINARY 0
-  #endif
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
 #endif
 
-#define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
-#define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 
+#define POINTER_SHIFT(p, b)      ((void *)((char *)(p) + (b)))
+#define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2))
 
 #ifndef NDEBUG
 #define ASSERT(x) assert(x)
@@ -141,7 +140,7 @@ extern "C" {
 
 #if defined(__GNUC__)
 #define UNUSED_PARAM(x) _UNUSED##x __attribute__((unused))
-#define UNUSED_FUNC __attribute__((unused))
+#define UNUSED_FUNC     __attribute__((unused))
 #else
 #define UNUSED_PARAM(x) x
 #define UNUSED_FUNC
@@ -169,16 +168,22 @@ extern "C" {
     }                            \
   } while (0)
 
-#define DEFAULT_DOUBLE_COMP(x, y)           \
-  do {                                      \
-    if (isnan(x) && isnan(y)) { return 0; } \
-    if (isnan(x)) { return -1; }            \
-    if (isnan(y)) { return 1; }             \
-    if ((x) == (y)) {                       \
-      return 0;                             \
-    } else {                                \
-      return (x) < (y) ? -1 : 1;            \
-    }                                       \
+#define DEFAULT_DOUBLE_COMP(x, y) \
+  do {                            \
+    if (isnan(x) && isnan(y)) {   \
+      return 0;                   \
+    }                             \
+    if (isnan(x)) {               \
+      return -1;                  \
+    }                             \
+    if (isnan(y)) {               \
+      return 1;                   \
+    }                             \
+    if ((x) == (y)) {             \
+      return 0;                   \
+    } else {                      \
+      return (x) < (y) ? -1 : 1;  \
+    }                             \
   } while (0)
 
 #define DEFAULT_FLOAT_COMP(x, y) DEFAULT_DOUBLE_COMP(x, y)
@@ -190,43 +195,49 @@ extern "C" {
 
 #undef threadlocal
 #ifdef _ISOC11_SOURCE
-  #define threadlocal _Thread_local
+#define threadlocal _Thread_local
 #elif defined(__APPLE__)
-  #define threadlocal __thread
+#define threadlocal __thread
 #elif defined(__GNUC__) && !defined(threadlocal)
-  #define threadlocal __thread
+#define threadlocal __thread
 #else
-  #define threadlocal __declspec( thread )
+#define threadlocal __declspec(thread)
 #endif
 
 #ifdef WINDOWS
-  #define PRIzu "ld"  
+#define PRIzu "ld"
 #else
-  #define PRIzu "zu"  
+#define PRIzu "zu"
 #endif
 
 #if !defined(WINDOWS)
-  #if defined(_TD_DARWIN_64)
-    // MacOS
-    #if !defined(_GNU_SOURCE)
-      #define setThreadName(name) do { pthread_setname_np((name)); } while (0)
-    #else
-      // pthread_setname_np not defined
-      #define setThreadName(name)
-    #endif
-  #else
-    // Linux, length of name must <= 16 (the last '\0' included)
-    #define setThreadName(name) do { prctl(PR_SET_NAME, (name)); } while (0)
-  #endif
+#if defined(_TD_DARWIN_64)
+// MacOS
+#if !defined(_GNU_SOURCE)
+#define setThreadName(name)     \
+  do {                          \
+    pthread_setname_np((name)); \
+  } while (0)
+#else
+// pthread_setname_np not defined
+#define setThreadName(name)
+#endif
+#else
+// Linux, length of name must <= 16 (the last '\0' included)
+#define setThreadName(name)     \
+  do {                          \
+    prctl(PR_SET_NAME, (name)); \
+  } while (0)
+#endif
 #else
-  // Windows
-  #define setThreadName(name)
+// Windows
+#define setThreadName(name)
 #endif
 
 #if defined(_WIN32)
-#define TD_DIRSEP	"\\"
+#define TD_DIRSEP "\\"
 #else
-#define TD_DIRSEP	"/"
+#define TD_DIRSEP "/"
 #endif
 
 #define TD_LOCALE_LEN   64

include/os/osDir.h

@@ -19,12 +19,12 @@
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define opendir OPENDIR_FUNC_TAOS_FORBID
-    #define readdir READDIR_FUNC_TAOS_FORBID
-    #define closedir CLOSEDIR_FUNC_TAOS_FORBID
-    #define dirname DIRNAME_FUNC_TAOS_FORBID
-    #undef basename
-    #define basename BASENAME_FUNC_TAOS_FORBID
+#define opendir  OPENDIR_FUNC_TAOS_FORBID
+#define readdir  READDIR_FUNC_TAOS_FORBID
+#define closedir CLOSEDIR_FUNC_TAOS_FORBID
+#define dirname  DIRNAME_FUNC_TAOS_FORBID
+#undef basename
+#define basename BASENAME_FUNC_TAOS_FORBID
 #endif
 
 #ifdef __cplusplus
@@ -32,26 +32,25 @@ extern "C" {
 #endif
 
 #ifdef WINDOWS
-#define TD_TMP_DIR_PATH "C:\\Windows\\Temp\\"
-#define TD_CFG_DIR_PATH "C:\\TDengine\\cfg\\"
+#define TD_TMP_DIR_PATH  "C:\\Windows\\Temp\\"
+#define TD_CFG_DIR_PATH  "C:\\TDengine\\cfg\\"
 #define TD_DATA_DIR_PATH "C:\\TDengine\\data\\"
-#define TD_LOG_DIR_PATH "C:\\TDengine\\log\\"
+#define TD_LOG_DIR_PATH  "C:\\TDengine\\log\\"
 #elif defined(_TD_DARWIN_64)
-#define TD_TMP_DIR_PATH "/tmp/taosd/"
-#define TD_CFG_DIR_PATH "/etc/taos/"
+#define TD_TMP_DIR_PATH  "/tmp/taosd/"
+#define TD_CFG_DIR_PATH  "/etc/taos/"
 #define TD_DATA_DIR_PATH "/var/lib/taos/"
-#define TD_LOG_DIR_PATH "/var/log/taos/"
+#define TD_LOG_DIR_PATH  "/var/log/taos/"
 #else
-#define TD_TMP_DIR_PATH "/tmp/"
-#define TD_CFG_DIR_PATH "/etc/taos/"
+#define TD_TMP_DIR_PATH  "/tmp/"
+#define TD_CFG_DIR_PATH  "/etc/taos/"
 #define TD_DATA_DIR_PATH "/var/lib/taos/"
-#define TD_LOG_DIR_PATH "/var/log/taos/"
+#define TD_LOG_DIR_PATH  "/var/log/taos/"
 #endif
 
-typedef struct TdDir *TdDirPtr;
+typedef struct TdDir      *TdDirPtr;
 typedef struct TdDirEntry *TdDirEntryPtr;
 
-
 void    taosRemoveDir(const char *dirname);
 bool    taosDirExist(const char *dirname);
 int32_t taosMkDir(const char *dirname);
@@ -61,13 +60,13 @@ void    taosRemoveOldFiles(const char *dirname, int32_t keepDays);
 int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen);
 int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen);
 bool    taosIsDir(const char *dirname);
-char*   taosDirName(char *dirname);
-char*   taosDirEntryBaseName(char *dirname);
+char   *taosDirName(char *dirname);
+char   *taosDirEntryBaseName(char *dirname);
 
 TdDirPtr      taosOpenDir(const char *dirname);
 TdDirEntryPtr taosReadDir(TdDirPtr pDir);
 bool          taosDirEntryIsDir(TdDirEntryPtr pDirEntry);
-char*         taosGetDirEntryName(TdDirEntryPtr pDirEntry);
+char         *taosGetDirEntryName(TdDirEntryPtr pDirEntry);
 int32_t       taosCloseDir(TdDirPtr *ppDir);
 
 #ifdef __cplusplus

include/os/osEndian.h

@@ -24,7 +24,7 @@ typedef enum { TD_LITTLE_ENDIAN = 0, TD_BIG_ENDIAN } td_endian_t;
 
 static const int32_t endian_test_var = 1;
 #define IS_LITTLE_ENDIAN() (*(uint8_t *)(&endian_test_var) != 0)
-#define TD_RT_ENDIAN() (IS_LITTLE_ENDIAN() ? TD_LITTLE_ENDIAN : TD_BIG_ENDIAN)
+#define TD_RT_ENDIAN()     (IS_LITTLE_ENDIAN() ? TD_LITTLE_ENDIAN : TD_BIG_ENDIAN)
 
 #ifdef __cplusplus
 }

include/os/osEnv.h

@@ -17,6 +17,7 @@
 #define _TD_OS_ENV_H_
 
 #include "osSysinfo.h"
+#include "osTimezone.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -34,7 +35,7 @@ extern int64_t         tsOpenMax;
 extern int64_t         tsStreamMax;
 extern float           tsNumOfCores;
 extern int64_t         tsTotalMemoryKB;
-extern char*           tsProcPath;
+extern char           *tsProcPath;
 
 extern char configDir[];
 extern char tsDataDir[];

include/os/osEok.h

@@ -24,58 +24,54 @@ extern "C" {
 
 #ifdef __APPLE__
 
-enum EPOLL_EVENTS
-  {
-    EPOLLIN = 0x001,
+enum EPOLL_EVENTS {
+  EPOLLIN = 0x001,
 #define EPOLLIN EPOLLIN
-    EPOLLPRI = 0x002,
+  EPOLLPRI = 0x002,
 #define EPOLLPRI EPOLLPRI
-    EPOLLOUT = 0x004,
+  EPOLLOUT = 0x004,
 #define EPOLLOUT EPOLLOUT
-    EPOLLRDNORM = 0x040,
+  EPOLLRDNORM = 0x040,
 #define EPOLLRDNORM EPOLLRDNORM
-    EPOLLRDBAND = 0x080,
+  EPOLLRDBAND = 0x080,
 #define EPOLLRDBAND EPOLLRDBAND
-    EPOLLWRNORM = 0x100,
+  EPOLLWRNORM = 0x100,
 #define EPOLLWRNORM EPOLLWRNORM
-    EPOLLWRBAND = 0x200,
+  EPOLLWRBAND = 0x200,
 #define EPOLLWRBAND EPOLLWRBAND
-    EPOLLMSG = 0x400,
+  EPOLLMSG = 0x400,
 #define EPOLLMSG EPOLLMSG
-    EPOLLERR = 0x008,
+  EPOLLERR = 0x008,
 #define EPOLLERR EPOLLERR
-    EPOLLHUP = 0x010,
+  EPOLLHUP = 0x010,
 #define EPOLLHUP EPOLLHUP
-    EPOLLRDHUP = 0x2000,
+  EPOLLRDHUP = 0x2000,
 #define EPOLLRDHUP EPOLLRDHUP
-    EPOLLEXCLUSIVE = 1u << 28,
+  EPOLLEXCLUSIVE = 1u << 28,
 #define EPOLLEXCLUSIVE EPOLLEXCLUSIVE
-    EPOLLWAKEUP = 1u << 29,
+  EPOLLWAKEUP = 1u << 29,
 #define EPOLLWAKEUP EPOLLWAKEUP
-    EPOLLONESHOT = 1u << 30,
+  EPOLLONESHOT = 1u << 30,
 #define EPOLLONESHOT EPOLLONESHOT
-    EPOLLET = 1u << 31
+  EPOLLET = 1u << 31
 #define EPOLLET EPOLLET
-  };
+};
 
 /* Valid opcodes ( "op" parameter ) to issue to epoll_ctl().  */
 #define EPOLL_CTL_ADD 1 /* Add a file descriptor to the interface.  */
 #define EPOLL_CTL_DEL 2 /* Remove a file descriptor from the interface.  */
 #define EPOLL_CTL_MOD 3 /* Change file descriptor epoll_event structure.  */
 
-
-typedef union epoll_data
-{
-  void *ptr;
-  int fd;
+typedef union epoll_data {
+  void    *ptr;
+  int      fd;
   uint32_t u32;
   uint64_t u64;
 } epoll_data_t;
 
-struct epoll_event
-{
-  uint32_t events;  /* Epoll events */
-  epoll_data_t data;  /* User data variable */
+struct epoll_event {
+  uint32_t     events; /* Epoll events */
+  epoll_data_t data;   /* User data variable */
 };
 
 int epoll_create(int size);
@@ -83,11 +79,10 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
 int epoll_close(int epfd);
 
-#endif // __APPLE__
+#endif  // __APPLE__
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // _eok_h_fd274616_996c_400e_9023_ae70be881fa3_
-
+#endif  // _eok_h_fd274616_996c_400e_9023_ae70be881fa3_

include/os/osLocale.h

@@ -25,7 +25,7 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define setlocale SETLOCALE_FUNC_TAOS_FORBID
+#define setlocale SETLOCALE_FUNC_TAOS_FORBID
 #endif
 
 char *taosCharsetReplace(char *charsetstr);

include/os/osLz4.h

@@ -21,25 +21,25 @@ extern "C" {
 #endif
 
 #ifdef WINDOWS
-  int32_t BUILDIN_CLZL(uint64_t val);
-  int32_t BUILDIN_CLZ(uint32_t val);
-  int32_t BUILDIN_CTZL(uint64_t val);
-  int32_t BUILDIN_CTZ(uint32_t val);
-#elif defined (_TD_LINUX_32)
-  #define BUILDIN_CLZL(val) __builtin_clzll(val)
-  #define BUILDIN_CTZL(val) __builtin_ctzll(val)
-  #define BUILDIN_CLZ(val) __builtin_clz(val)
-  #define BUILDIN_CTZ(val) __builtin_ctz(val)
-#elif defined (_TD_ARM_32)
-  #define BUILDIN_CLZL(val) __builtin_clzll(val)
-  #define BUILDIN_CTZL(val) __builtin_ctzll(val)
-  #define BUILDIN_CLZ(val) __builtin_clz(val)
-  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+int32_t BUILDIN_CLZL(uint64_t val);
+int32_t BUILDIN_CLZ(uint32_t val);
+int32_t BUILDIN_CTZL(uint64_t val);
+int32_t BUILDIN_CTZ(uint32_t val);
+#elif defined(_TD_LINUX_32)
+#define BUILDIN_CLZL(val) __builtin_clzll(val)
+#define BUILDIN_CTZL(val) __builtin_ctzll(val)
+#define BUILDIN_CLZ(val)  __builtin_clz(val)
+#define BUILDIN_CTZ(val)  __builtin_ctz(val)
+#elif defined(_TD_ARM_32)
+#define BUILDIN_CLZL(val) __builtin_clzll(val)
+#define BUILDIN_CTZL(val) __builtin_ctzll(val)
+#define BUILDIN_CLZ(val)  __builtin_clz(val)
+#define BUILDIN_CTZ(val)  __builtin_ctz(val)
 #else
-  #define BUILDIN_CLZL(val) __builtin_clzl(val)
-  #define BUILDIN_CTZL(val) __builtin_ctzl(val)
-  #define BUILDIN_CLZ(val) __builtin_clz(val)
-  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+#define BUILDIN_CLZL(val) __builtin_clzl(val)
+#define BUILDIN_CTZL(val) __builtin_ctzl(val)
+#define BUILDIN_CLZ(val)  __builtin_clz(val)
+#define BUILDIN_CTZ(val)  __builtin_ctz(val)
 #endif
 
 #ifdef __cplusplus

include/os/osMath.h

@@ -23,40 +23,40 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following sectio
 #ifndef ALLOW_FORBID_FUNC
-#define qsort  QSORT_FUNC_TAOS_FORBID
+#define qsort QSORT_FUNC_TAOS_FORBID
 #endif
 
 #define TPOW2(x) ((x) * (x))
-#define TABS(x) ((x) > 0 ? (x) : -(x))
+#define TABS(x)  ((x) > 0 ? (x) : -(x))
 
-#define TSWAP(a, b)                              \
-  do {                                           \
-    char *__tmp = alloca(sizeof(a));             \
-    memcpy(__tmp, &(a), sizeof(a));              \
-    memcpy(&(a), &(b), sizeof(a));               \
-    memcpy(&(b), __tmp, sizeof(a));              \
+#define TSWAP(a, b)                  \
+  do {                               \
+    char *__tmp = alloca(sizeof(a)); \
+    memcpy(__tmp, &(a), sizeof(a));  \
+    memcpy(&(a), &(b), sizeof(a));   \
+    memcpy(&(b), __tmp, sizeof(a));  \
   } while (0)
 
 #ifdef WINDOWS
 
-  #define TMAX(a, b) (((a) > (b)) ? (a) : (b))
-  #define TMIN(a, b) (((a) < (b)) ? (a) : (b))
-  #define TRANGE(aa, bb, cc) ((aa) = TMAX((aa), (bb)),(aa) = TMIN((aa), (cc)))
+#define TMAX(a, b)         (((a) > (b)) ? (a) : (b))
+#define TMIN(a, b)         (((a) < (b)) ? (a) : (b))
+#define TRANGE(aa, bb, cc) ((aa) = TMAX((aa), (bb)), (aa) = TMIN((aa), (cc)))
 
 #else
 
-  #define TMAX(a, b)             \
-    ({                           \
-      __typeof(a) __a = (a);     \
-      __typeof(b) __b = (b);     \
-      (__a > __b) ? __a : __b;   \
-    })
+#define TMAX(a, b)           \
+  ({                         \
+    __typeof(a) __a = (a);   \
+    __typeof(b) __b = (b);   \
+    (__a > __b) ? __a : __b; \
+  })
 
-#define TMIN(a, b)             \
-  ({                           \
-    __typeof(a) __a = (a);     \
-    __typeof(b) __b = (b);     \
-    (__a < __b) ? __a : __b;   \
+#define TMIN(a, b)           \
+  ({                         \
+    __typeof(a) __a = (a);   \
+    __typeof(b) __b = (b);   \
+    (__a < __b) ? __a : __b; \
   })
 
 #define TRANGE(a, b, c) \
@@ -71,7 +71,7 @@ extern "C" {
 typedef int32_t (*__compar_fn_t)(const void *, const void *);
 #endif
 
-void taosSort(void* arr, int64_t sz, int64_t width, __compar_fn_t compar);
+void taosSort(void *arr, int64_t sz, int64_t width, __compar_fn_t compar);
 
 #ifdef __cplusplus
 }

include/os/osMemory.h

@@ -23,19 +23,19 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following sectio
 #ifndef ALLOW_FORBID_FUNC
-    #define malloc MALLOC_FUNC_TAOS_FORBID
-    #define calloc CALLOC_FUNC_TAOS_FORBID
-    #define realloc REALLOC_FUNC_TAOS_FORBID
-    #define free FREE_FUNC_TAOS_FORBID
+#define malloc  MALLOC_FUNC_TAOS_FORBID
+#define calloc  CALLOC_FUNC_TAOS_FORBID
+#define realloc REALLOC_FUNC_TAOS_FORBID
+#define free    FREE_FUNC_TAOS_FORBID
 #endif
 
-void *taosMemoryMalloc(int32_t size);
-void *taosMemoryCalloc(int32_t num, int32_t size);
-void *taosMemoryRealloc(void *ptr, int32_t size);
-void *taosMemoryStrDup(const char *ptr);
-void taosMemoryFree(void *ptr);
+void   *taosMemoryMalloc(int32_t size);
+void   *taosMemoryCalloc(int32_t num, int32_t size);
+void   *taosMemoryRealloc(void *ptr, int32_t size);
+void   *taosMemoryStrDup(const char *ptr);
+void    taosMemoryFree(void *ptr);
 int32_t taosMemorySize(void *ptr);
-void taosPrintBackTrace();
+void    taosPrintBackTrace();
 
 #define taosMemoryFreeClear(ptr)   \
   do {                             \

include/os/osRand.h

@@ -23,14 +23,14 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define rand RAND_FUNC_TAOS_FORBID
-    #define srand SRAND_FUNC_TAOS_FORBID
-    #define rand_r RANDR_FUNC_TAOS_FORBID
+#define rand   RAND_FUNC_TAOS_FORBID
+#define srand  SRAND_FUNC_TAOS_FORBID
+#define rand_r RANDR_FUNC_TAOS_FORBID
 #endif
 
-void taosSeedRand(uint32_t seed);
+void     taosSeedRand(uint32_t seed);
 uint32_t taosRand(void);
-uint32_t taosRandR(uint32_t *pSeed);
+uint32_t taosRandR(uint32_t* pSeed);
 void     taosRandStr(char* str, int32_t size);
 uint32_t taosSafeRand(void);
 

include/os/osShm.h

@@ -23,10 +23,10 @@ extern "C" {
 typedef struct {
   int32_t id;
   int32_t size;
-  void*   ptr;
+  void   *ptr;
 } SShm;
 
-int32_t taosCreateShm(SShm *pShm, int32_t key, int32_t shmsize) ;
+int32_t taosCreateShm(SShm *pShm, int32_t key, int32_t shmsize);
 void    taosDropShm(SShm *pShm);
 int32_t taosAttachShm(SShm *pShm);
 

include/os/osSignal.h

@@ -21,27 +21,27 @@ extern "C" {
 #endif
 
 #ifndef SIGALRM
-  #define SIGALRM 1234
+#define SIGALRM 1234
 #endif
 
 #ifndef SIGHUP
-  #define SIGHUP 1230
+#define SIGHUP 1230
 #endif
 
 #ifndef SIGCHLD
-  #define SIGCHLD 1234
+#define SIGCHLD 1234
 #endif
 
 #ifndef SIGUSR1
-  #define SIGUSR1 1234
+#define SIGUSR1 1234
 #endif
 
 #ifndef SIGUSR2
-  #define SIGUSR2 1234
+#define SIGUSR2 1234
 #endif
 
 #ifndef SIGBREAK
-  #define SIGBREAK 1234
+#define SIGBREAK 1234
 #endif
 
 #ifdef WINDOWS
@@ -59,4 +59,4 @@ void taosKillChildOnParentStopped();
 }
 #endif
 
-#endif  /*_TD_OS_SIGNAL_H_*/
+#endif /*_TD_OS_SIGNAL_H_*/

include/os/osSleep.h

@@ -23,10 +23,10 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define Sleep SLEEP_FUNC_TAOS_FORBID
-    #define sleep SLEEP_FUNC_TAOS_FORBID
-    #define usleep USLEEP_FUNC_TAOS_FORBID
-    #define nanosleep NANOSLEEP_FUNC_TAOS_FORBID
+#define Sleep     SLEEP_FUNC_TAOS_FORBID
+#define sleep     SLEEP_FUNC_TAOS_FORBID
+#define usleep    USLEEP_FUNC_TAOS_FORBID
+#define nanosleep NANOSLEEP_FUNC_TAOS_FORBID
 #endif
 
 void taosSsleep(int32_t s);

include/os/osSocket.h

@@ -75,7 +75,7 @@ extern "C" {
 typedef int socklen_t;
 #define TAOS_EPOLL_WAIT_TIME 100
 typedef SOCKET eventfd_t;
-#define eventfd(a, b)      -1
+#define eventfd(a, b) -1
 #ifndef EPOLLWAKEUP
 #define EPOLLWAKEUP (1u << 29)
 #endif
@@ -119,8 +119,8 @@ typedef int32_t  SocketFd;
 typedef SocketFd EpollFd;
 
 typedef struct TdSocketServer *TdSocketServerPtr;
-typedef struct TdSocket *      TdSocketPtr;
-typedef struct TdEpoll *       TdEpollPtr;
+typedef struct TdSocket       *TdSocketPtr;
+typedef struct TdEpoll        *TdEpollPtr;
 
 int32_t taosSendto(TdSocketPtr pSocket, void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);
 int32_t taosWriteSocket(TdSocketPtr pSocket, void *msg, int len);

include/os/osString.h

@@ -26,37 +26,37 @@ typedef int32_t TdUcs4;
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define iconv_open ICONV_OPEN_FUNC_TAOS_FORBID
-    #define iconv_close ICONV_CLOSE_FUNC_TAOS_FORBID
-    #define iconv ICONV_FUNC_TAOS_FORBID
-    #define wcwidth WCWIDTH_FUNC_TAOS_FORBID
-    #define wcswidth WCSWIDTH_FUNC_TAOS_FORBID
-    #define mbtowc MBTOWC_FUNC_TAOS_FORBID
-    #define mbstowcs MBSTOWCS_FUNC_TAOS_FORBID
-    #define wctomb WCTOMB_FUNC_TAOS_FORBID
-    #define wcstombs WCSTOMBS_FUNC_TAOS_FORBID
-    #define wcsncpy WCSNCPY_FUNC_TAOS_FORBID
-    #define wchar_t WCHAR_T_TYPE_TAOS_FORBID
-    #define strcasestr STR_CASE_STR_FORBID
-    #define strtoll STR_TO_LL_FUNC_TAOS_FORBID
-    #define strtoull STR_TO_ULL_FUNC_TAOS_FORBID
-    #define strtol STR_TO_L_FUNC_TAOS_FORBID
-    #define strtoul STR_TO_UL_FUNC_TAOS_FORBID
-    #define strtod STR_TO_LD_FUNC_TAOS_FORBID
-    #define strtold STR_TO_D_FUNC_TAOS_FORBID
-    #define strtof STR_TO_F_FUNC_TAOS_FORBID
+#define iconv_open  ICONV_OPEN_FUNC_TAOS_FORBID
+#define iconv_close ICONV_CLOSE_FUNC_TAOS_FORBID
+#define iconv       ICONV_FUNC_TAOS_FORBID
+#define wcwidth     WCWIDTH_FUNC_TAOS_FORBID
+#define wcswidth    WCSWIDTH_FUNC_TAOS_FORBID
+#define mbtowc      MBTOWC_FUNC_TAOS_FORBID
+#define mbstowcs    MBSTOWCS_FUNC_TAOS_FORBID
+#define wctomb      WCTOMB_FUNC_TAOS_FORBID
+#define wcstombs    WCSTOMBS_FUNC_TAOS_FORBID
+#define wcsncpy     WCSNCPY_FUNC_TAOS_FORBID
+#define wchar_t     WCHAR_T_TYPE_TAOS_FORBID
+#define strcasestr  STR_CASE_STR_FORBID
+#define strtoll     STR_TO_LL_FUNC_TAOS_FORBID
+#define strtoull    STR_TO_ULL_FUNC_TAOS_FORBID
+#define strtol      STR_TO_L_FUNC_TAOS_FORBID
+#define strtoul     STR_TO_UL_FUNC_TAOS_FORBID
+#define strtod      STR_TO_LD_FUNC_TAOS_FORBID
+#define strtold     STR_TO_D_FUNC_TAOS_FORBID
+#define strtof      STR_TO_F_FUNC_TAOS_FORBID
 #endif
 
 #ifdef WINDOWS
-  #define tstrdup(str) _strdup(str)
+#define tstrdup(str) _strdup(str)
 #else
-  #define tstrdup(str) strdup(str)
+#define tstrdup(str) strdup(str)
 #endif
 
-#define tstrncpy(dst, src, size) \
-  do {                              \
-    strncpy((dst), (src), (size));  \
-    (dst)[(size)-1] = 0;            \
+#define tstrncpy(dst, src, size)   \
+  do {                             \
+    strncpy((dst), (src), (size)); \
+    (dst)[(size)-1] = 0;           \
   } while (0)
 
 int32_t taosUcs4len(TdUcs4 *ucs4);
@@ -67,7 +67,7 @@ void    taosConvDestroy();
 int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs);
 bool    taosMbsToUcs4(const char *mbs, size_t mbs_len, TdUcs4 *ucs4, int32_t ucs4_max_len, int32_t *len);
 int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes);
-TdUcs4* tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4);
+TdUcs4 *tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4);
 bool    taosValidateEncodec(const char *encodec);
 int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len);
 int32_t taosHexDecode(const char *src, char *dst, int32_t len);
@@ -80,16 +80,16 @@ int32_t taosWcharToMb(char *pStr, TdWchar wchar);
 
 char *taosStrCaseStr(const char *str, const char *pattern);
 
-int64_t taosStr2Int64(const char *str, char** pEnd, int32_t radix);
-uint64_t taosStr2UInt64(const char *str, char** pEnd, int32_t radix);
-int32_t taosStr2Int32(const char *str, char** pEnd, int32_t radix);
-uint32_t taosStr2UInt32(const char *str, char** pEnd, int32_t radix);
-int16_t taosStr2Int16(const char *str, char** pEnd, int32_t radix);
-uint16_t taosStr2UInt16(const char *str, char** pEnd, int32_t radix);
-int8_t taosStr2Int8(const char *str, char** pEnd, int32_t radix);
-uint8_t taosStr2UInt8(const char *str, char** pEnd, int32_t radix);
-double taosStr2Double(const char *str, char** pEnd);
-float taosStr2Float(const char *str, char** pEnd);
+int64_t  taosStr2Int64(const char *str, char **pEnd, int32_t radix);
+uint64_t taosStr2UInt64(const char *str, char **pEnd, int32_t radix);
+int32_t  taosStr2Int32(const char *str, char **pEnd, int32_t radix);
+uint32_t taosStr2UInt32(const char *str, char **pEnd, int32_t radix);
+int16_t  taosStr2Int16(const char *str, char **pEnd, int32_t radix);
+uint16_t taosStr2UInt16(const char *str, char **pEnd, int32_t radix);
+int8_t   taosStr2Int8(const char *str, char **pEnd, int32_t radix);
+uint8_t  taosStr2UInt8(const char *str, char **pEnd, int32_t radix);
+double   taosStr2Double(const char *str, char **pEnd);
+float    taosStr2Float(const char *str, char **pEnd);
 
 #ifdef __cplusplus
 }

include/os/osSysinfo.h

@@ -54,10 +54,10 @@ void    taosSetCoreDump(bool enable);
 
 #if !defined(LINUX)
 
-#define _UTSNAME_LENGTH 65
+#define _UTSNAME_LENGTH         65
 #define _UTSNAME_MACHINE_LENGTH _UTSNAME_LENGTH
 
-#endif // WINDOWS
+#endif  // WINDOWS
 
 typedef struct {
   char sysname[_UTSNAME_MACHINE_LENGTH];
@@ -68,7 +68,7 @@ typedef struct {
 } SysNameInfo;
 
 SysNameInfo taosGetSysNameInfo();
-bool taosCheckCurrentInDll();
+bool        taosCheckCurrentInDll();
 
 #ifdef __cplusplus
 }

include/os/osSystem.h

@@ -23,16 +23,16 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define popen POPEN_FUNC_TAOS_FORBID
-    #define pclose PCLOSE_FUNC_TAOS_FORBID
-    #define tcsetattr TCSETATTR_FUNC_TAOS_FORBID
-    #define tcgetattr TCGETATTR_FUNC_TAOS_FORBID
+#define popen     POPEN_FUNC_TAOS_FORBID
+#define pclose    PCLOSE_FUNC_TAOS_FORBID
+#define tcsetattr TCSETATTR_FUNC_TAOS_FORBID
+#define tcgetattr TCGETATTR_FUNC_TAOS_FORBID
 #endif
 
-typedef struct TdCmd *TdCmdPtr;
+typedef struct TdCmd* TdCmdPtr;
 
 TdCmdPtr taosOpenCmd(const char* cmd);
-int64_t  taosGetsCmd(TdCmdPtr pCmd, int32_t maxSize, char *__restrict buf);
+int64_t  taosGetsCmd(TdCmdPtr pCmd, int32_t maxSize, char* __restrict buf);
 int64_t  taosGetLineCmd(TdCmdPtr pCmd, char** __restrict ptrBuf);
 int32_t  taosEOFCmd(TdCmdPtr pCmd);
 int64_t  taosCloseCmd(TdCmdPtr* ppCmd);

include/os/osTimer.h

@@ -23,22 +23,22 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define timer_create TIMER_CREATE_FUNC_TAOS_FORBID
-    #define timer_settime TIMER_SETTIME_FUNC_TAOS_FORBID
-    #define timer_delete TIMER_DELETE_FUNC_TAOS_FORBID
-    #define timeSetEvent TIMESETEVENT_SETTIME_FUNC_TAOS_FORBID
-    #define timeKillEvent TIMEKILLEVENT_SETTIME_FUNC_TAOS_FORBID
+#define timer_create  TIMER_CREATE_FUNC_TAOS_FORBID
+#define timer_settime TIMER_SETTIME_FUNC_TAOS_FORBID
+#define timer_delete  TIMER_DELETE_FUNC_TAOS_FORBID
+#define timeSetEvent  TIMESETEVENT_SETTIME_FUNC_TAOS_FORBID
+#define timeKillEvent TIMEKILLEVENT_SETTIME_FUNC_TAOS_FORBID
 #endif
 
 #define MSECONDS_PER_TICK 5
 
-int32_t taosInitTimer(void (*callback)(int32_t), int32_t ms);
-void    taosUninitTimer();
-int64_t taosGetMonotonicMs();
+int32_t     taosInitTimer(void (*callback)(int32_t), int32_t ms);
+void        taosUninitTimer();
+int64_t     taosGetMonotonicMs();
 const char *taosMonotonicInit();
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /*_TD_OS_TIMER_H_*/
+#endif /*_TD_OS_TIMER_H_*/

include/os/osTimezone.h

@@ -23,36 +23,35 @@ extern "C" {
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
-    #define tzset TZSET_FUNC_TAOS_FORBID
+#define tzset TZSET_FUNC_TAOS_FORBID
 #endif
 
-enum TdTimezone
-{
-      TdWestZone12=-12,
-      TdWestZone11,
-      TdWestZone10,
-      TdWestZone9,
-      TdWestZone8,
-      TdWestZone7,
-      TdWestZone6,
-      TdWestZone5,
-      TdWestZone4,
-      TdWestZone3,
-      TdWestZone2,
-      TdWestZone1,
-      TdZeroZone,
-      TdEastZone1,
-      TdEastZone2,
-      TdEastZone3,
-      TdEastZone4,
-      TdEastZone5,
-      TdEastZone6,
-      TdEastZone7,
-      TdEastZone8,
-      TdEastZone9,
-      TdEastZone10,
-      TdEastZone11,
-      TdEastZone12
+enum TdTimezone {
+  TdWestZone12 = -12,
+  TdWestZone11,
+  TdWestZone10,
+  TdWestZone9,
+  TdWestZone8,
+  TdWestZone7,
+  TdWestZone6,
+  TdWestZone5,
+  TdWestZone4,
+  TdWestZone3,
+  TdWestZone2,
+  TdWestZone1,
+  TdZeroZone,
+  TdEastZone1,
+  TdEastZone2,
+  TdEastZone3,
+  TdEastZone4,
+  TdEastZone5,
+  TdEastZone6,
+  TdEastZone7,
+  TdEastZone8,
+  TdEastZone9,
+  TdEastZone10,
+  TdEastZone11,
+  TdEastZone12
 };
 
 void taosGetSystemTimezone(char *outTimezone, enum TdTimezone *tsTimezone);

include/util/taoserror.h

@@ -566,6 +566,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS    TAOS_DEF_ERROR_CODE(0, 0x2663)
 #define TSDB_CODE_PAR_NOT_SUPPORT_JOIN          TAOS_DEF_ERROR_CODE(0, 0x2664)
 #define TSDB_CODE_PAR_INVALID_TAGS_PC           TAOS_DEF_ERROR_CODE(0, 0x2665)
+#define TSDB_CODE_PAR_INVALID_TIMELINE_QUERY    TAOS_DEF_ERROR_CODE(0, 0x2666)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x26FF)
 
 //planner

include/util/tbloomfilter.h

@@ -25,26 +25,25 @@ extern "C" {
 #endif
 
 typedef struct SBloomFilter {
-  uint32_t hashFunctions;
-  uint64_t expectedEntries;
-  uint64_t numUnits;
-  uint64_t numBits;
-  uint64_t size;
+  uint32_t   hashFunctions;
+  uint64_t   expectedEntries;
+  uint64_t   numUnits;
+  uint64_t   numBits;
+  uint64_t   size;
   _hash_fn_t hashFn1;
   _hash_fn_t hashFn2;
-  void *buffer;
-  double errorRate;
+  void      *buffer;
+  double     errorRate;
 } SBloomFilter;
 
 SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate);
-int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len);
-int32_t tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf,
-                              uint32_t len);
-void tBloomFilterDestroy(SBloomFilter *pBF);
-void tBloomFilterDump(const SBloomFilter *pBF);
-bool tBloomFilterIsFull(const SBloomFilter *pBF);
-int32_t tBloomFilterEncode(const SBloomFilter *pBF, SEncoder* pEncoder);
-SBloomFilter* tBloomFilterDecode(SDecoder* pDecoder);
+int32_t       tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len);
+int32_t       tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf, uint32_t len);
+void          tBloomFilterDestroy(SBloomFilter *pBF);
+void          tBloomFilterDump(const SBloomFilter *pBF);
+bool          tBloomFilterIsFull(const SBloomFilter *pBF);
+int32_t       tBloomFilterEncode(const SBloomFilter *pBF, SEncoder *pEncoder);
+SBloomFilter *tBloomFilterDecode(SDecoder *pDecoder);
 
 #ifdef __cplusplus
 }

include/util/tconfig.h

@@ -105,11 +105,11 @@ int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal);
 const char *cfgStypeStr(ECfgSrcType type);
 const char *cfgDtypeStr(ECfgDataType type);
 
-void cfgDumpItemValue(SConfigItem *pItem, char* buf, int32_t bufSize, int32_t* pLen);
+void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
 
 void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
 
-int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl);
+int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl);
 
 #ifdef __cplusplus
 }

include/util/tcrc32c.h

 /*
-	  Copyright (c) 2013 - 2014, 2016 Mark Adler, Robert Vazan, Max Vysokikh
+          Copyright (c) 2013 - 2014, 2016 Mark Adler, Robert Vazan, Max Vysokikh
 
-	  This software is provided 'as-is', without any express or implied
-	  warranty.  In no event will the author be held liable for any damages
-	  arising from the use of this software.
+          This software is provided 'as-is', without any express or implied
+          warranty.  In no event will the author be held liable for any damages
+          arising from the use of this software.
 
-	  Permission is granted to anyone to use this software for any purpose,
-	  including commercial applications, and to alter it and redistribute it
-	  freely, subject to the following restrictions:
+          Permission is granted to anyone to use this software for any purpose,
+          including commercial applications, and to alter it and redistribute it
+          freely, subject to the following restrictions:
 
-	  1. The origin of this software must not be misrepresented; you must not
-	  claim that you wrote the original software. If you use this software
-	  in a product, an acknowledgment in the product documentation would be
-	  appreciated but is not required.
-	  2. Altered source versions must be plainly marked as such, and must not be
-	  misrepresented as being the original software.
-	  3. This notice may not be removed or altered from any source distribution.
-	*/
+          1. The origin of this software must not be misrepresented; you must not
+          claim that you wrote the original software. If you use this software
+          in a product, an acknowledgment in the product documentation would be
+          appreciated but is not required.
+          2. Altered source versions must be plainly marked as such, and must not be
+          misrepresented as being the original software.
+          3. This notice may not be removed or altered from any source distribution.
+        */
 
 #ifndef _TD_UTIL_CRC32_H_
 #define _TD_UTIL_CRC32_H_
@@ -41,4 +41,4 @@ void taosResolveCRC();
 }
 #endif
 
-#endif  /*_TD_UTIL_CRC32_H_*/
+#endif /*_TD_UTIL_CRC32_H_*/

include/util/tdigest.h

@@ -22,50 +22,53 @@
 #ifndef TDIGEST_H
 #define TDIGEST_H
 
+#include "os.h"
+
 #ifndef M_PI
-#define M_PI        3.14159265358979323846264338327950288   /* pi             */
+#define M_PI 3.14159265358979323846264338327950288 /* pi             */
 #endif
 
 #define DOUBLE_MAX 1.79e+308
 
-#define ADDITION_CENTROID_NUM 2
-#define COMPRESSION 300
+#define ADDITION_CENTROID_NUM      2
+#define COMPRESSION                300
 #define GET_CENTROID(compression)  (ceil(compression * M_PI / 2) + 1 + ADDITION_CENTROID_NUM)
 #define GET_THRESHOLD(compression) (7.5 + 0.37 * compression - 2e-4 * pow(compression, 2))
-#define TDIGEST_SIZE(compression)  (sizeof(TDigest) + sizeof(SCentroid)*GET_CENTROID(compression) + sizeof(SPt)*GET_THRESHOLD(compression))
+#define TDIGEST_SIZE(compression) \
+  (sizeof(TDigest) + sizeof(SCentroid) * GET_CENTROID(compression) + sizeof(SPt) * GET_THRESHOLD(compression))
 
 typedef struct SCentroid {
-    double mean;
-    int64_t weight;
-}SCentroid;
+  double  mean;
+  int64_t weight;
+} SCentroid;
 
 typedef struct SPt {
-    double value;
-    int64_t weight;
-}SPt;
+  double  value;
+  int64_t weight;
+} SPt;
 
 typedef struct TDigest {
-    double compression;
-    int32_t threshold;
-    int64_t size;
+  double  compression;
+  int32_t threshold;
+  int64_t size;
 
-    int64_t total_weight;
-    double min;
-    double max;
+  int64_t total_weight;
+  double  min;
+  double  max;
 
-    int32_t num_buffered_pts;
-    SPt *buffered_pts;
+  int32_t num_buffered_pts;
+  SPt    *buffered_pts;
 
-    int32_t num_centroids;
-    SCentroid *centroids;
-}TDigest;
+  int32_t    num_centroids;
+  SCentroid *centroids;
+} TDigest;
 
-TDigest *tdigestNewFrom(void* pBuf, int32_t compression);
-void tdigestAdd(TDigest *t, double x, int64_t w);
-void tdigestMerge(TDigest *t1, TDigest *t2);
-double tdigestQuantile(TDigest *t, double q);
-void tdigestCompress(TDigest *t);
-void tdigestFreeFrom(TDigest *t);
-void tdigestAutoFill(TDigest* t, int32_t compression);
+TDigest *tdigestNewFrom(void *pBuf, int32_t compression);
+void     tdigestAdd(TDigest *t, double x, int64_t w);
+void     tdigestMerge(TDigest *t1, TDigest *t2);
+double   tdigestQuantile(TDigest *t, double q);
+void     tdigestCompress(TDigest *t);
+void     tdigestFreeFrom(TDigest *t);
+void     tdigestAutoFill(TDigest *t, int32_t compression);
 
 #endif /* TDIGEST_H */

include/util/thash.h

@@ -29,7 +29,7 @@ typedef void (*_hash_before_fn_t)(void *);
 typedef void (*_hash_free_fn_t)(void *);
 
 #define HASH_KEY_ALREADY_EXISTS (-2)
-#define HASH_NODE_EXIST(code) (code == HASH_KEY_ALREADY_EXISTS)
+#define HASH_NODE_EXIST(code)   (code == HASH_KEY_ALREADY_EXISTS)
 
 /**
  * murmur hash algorithm
@@ -50,7 +50,7 @@ uint64_t MurmurHash3_64(const char *key, uint32_t len);
 uint32_t taosIntHash_32(const char *key, uint32_t len);
 uint32_t taosIntHash_64(const char *key, uint32_t len);
 
-_hash_fn_t taosGetDefaultHashFunction(int32_t type);
+_hash_fn_t  taosGetDefaultHashFunction(int32_t type);
 _equal_fn_t taosGetDefaultEqualFunction(int32_t type);
 
 typedef enum SHashLockTypeE {
@@ -59,7 +59,7 @@ typedef enum SHashLockTypeE {
 } SHashLockTypeE;
 
 typedef struct SHashNode SHashNode;
-typedef struct SHashObj SHashObj;
+typedef struct SHashObj  SHashObj;
 
 /**
  * init the hash table
@@ -118,7 +118,7 @@ int32_t taosHashGetDup(SHashObj *pHashObj, const void *key, size_t keyLen, void
  * @param size
  * @return
  */
-int32_t taosHashGetDup_m(SHashObj* pHashObj, const void* key, size_t keyLen, void** destBuf, int32_t* size);
+int32_t taosHashGetDup_m(SHashObj *pHashObj, const void *key, size_t keyLen, void **destBuf, int32_t *size);
 
 /**
  * remove item with the specified key
@@ -169,13 +169,13 @@ void *taosHashIterate(SHashObj *pHashObj, void *p);
  */
 void taosHashCancelIterate(SHashObj *pHashObj, void *p);
 
- /**
-  * Get the corresponding key information for a given data in hash table
-  * @param data
-  * @param keyLen
-  * @return
-  */
-void *taosHashGetKey(void *data, size_t* keyLen);
+/**
+ * Get the corresponding key information for a given data in hash table
+ * @param data
+ * @param keyLen
+ * @return
+ */
+void *taosHashGetKey(void *data, size_t *keyLen);
 
 /**
  * return the payload data with the specified key(reference number added)

include/util/tidpool.h

@@ -23,10 +23,10 @@ extern "C" {
 #endif
 
 typedef struct {
-  int32_t         maxId;
-  int32_t         numOfFree;
-  int32_t         freeSlot;
-  bool           *freeList;
+  int32_t       maxId;
+  int32_t       numOfFree;
+  int32_t       freeSlot;
+  bool         *freeList;
   TdThreadMutex mutex;
 } id_pool_t;
 

include/util/tlrucache.h

@@ -28,37 +28,34 @@ typedef void (*_taos_lru_deleter_t)(const void *key, size_t keyLen, void *value)
 
 typedef struct LRUHandle LRUHandle;
 
-typedef enum {
-  TAOS_LRU_PRIORITY_HIGH,
-  TAOS_LRU_PRIORITY_LOW
-} LRUPriority;
-  
+typedef enum { TAOS_LRU_PRIORITY_HIGH, TAOS_LRU_PRIORITY_LOW } LRUPriority;
+
 typedef enum {
   TAOS_LRU_STATUS_OK,
   TAOS_LRU_STATUS_FAIL,
   TAOS_LRU_STATUS_INCOMPLETE,
   TAOS_LRU_STATUS_OK_OVERWRITTEN
 } LRUStatus;
-  
-SLRUCache *taosLRUCacheInit(size_t capacity, int numShardBits, double highPriPoolRatio);  
-void taosLRUCacheCleanup(SLRUCache *cache);
 
-LRUStatus taosLRUCacheInsert(SLRUCache *cache, const void *key, size_t keyLen, void *value, size_t charge,
-                             _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority);
-LRUHandle *taosLRUCacheLookup(SLRUCache * cache, const void *key, size_t keyLen);
-void taosLRUCacheErase(SLRUCache * cache, const void *key, size_t keyLen);
+SLRUCache *taosLRUCacheInit(size_t capacity, int numShardBits, double highPriPoolRatio);
+void       taosLRUCacheCleanup(SLRUCache *cache);
+
+LRUStatus  taosLRUCacheInsert(SLRUCache *cache, const void *key, size_t keyLen, void *value, size_t charge,
+                              _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority);
+LRUHandle *taosLRUCacheLookup(SLRUCache *cache, const void *key, size_t keyLen);
+void       taosLRUCacheErase(SLRUCache *cache, const void *key, size_t keyLen);
 
 void taosLRUCacheEraseUnrefEntries(SLRUCache *cache);
 
 bool taosLRUCacheRef(SLRUCache *cache, LRUHandle *handle);
 bool taosLRUCacheRelease(SLRUCache *cache, LRUHandle *handle, bool eraseIfLastRef);
 
-void* taosLRUCacheValue(SLRUCache *cache, LRUHandle *handle);
+void *taosLRUCacheValue(SLRUCache *cache, LRUHandle *handle);
 
 size_t taosLRUCacheGetUsage(SLRUCache *cache);
 size_t taosLRUCacheGetPinnedUsage(SLRUCache *cache);
 
-void taosLRUCacheSetCapacity(SLRUCache *cache, size_t capacity);
+void   taosLRUCacheSetCapacity(SLRUCache *cache, size_t capacity);
 size_t taosLRUCacheGetCapacity(SLRUCache *cache);
 
 void taosLRUCacheSetStrictCapacity(SLRUCache *cache, bool strict);

include/util/tpagedbuf.h

@@ -53,7 +53,8 @@ typedef struct SDiskbasedBufStatis {
  * @param handle
  * @return
  */
-int32_t createDiskbasedBuf(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t inMemBufSize, const char* id, const char* dir);
+int32_t createDiskbasedBuf(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t inMemBufSize, const char* id,
+                           const char* dir);
 
 /**
  *
@@ -158,7 +159,7 @@ void setBufPageCompressOnDisk(SDiskbasedBuf* pBuf, bool comp);
  * @param pBuf
  * @param pageId
  */
-void dBufSetBufPageRecycled(SDiskbasedBuf *pBuf, void* pPage);
+void dBufSetBufPageRecycled(SDiskbasedBuf* pBuf, void* pPage);
 
 /**
  * Print the statistics when closing this buffer

include/util/tscalablebf.h

@@ -23,18 +23,17 @@ extern "C" {
 #endif
 
 typedef struct SScalableBf {
-  SArray *bfArray; // array of bloom filters
+  SArray  *bfArray;  // array of bloom filters
   uint32_t growth;
   uint64_t numBits;
 } SScalableBf;
 
 SScalableBf *tScalableBfInit(uint64_t expectedEntries, double errorRate);
-int32_t tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len);
-int32_t tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf,
-                             uint32_t len);
-void tScalableBfDestroy(SScalableBf *pSBf);
-int32_t tScalableBfEncode(const SScalableBf *pSBf, SEncoder* pEncoder);
-SScalableBf* tScalableBfDecode(SDecoder* pDecoder);
+int32_t      tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len);
+int32_t      tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf, uint32_t len);
+void         tScalableBfDestroy(SScalableBf *pSBf);
+int32_t      tScalableBfEncode(const SScalableBf *pSBf, SEncoder *pEncoder);
+SScalableBf *tScalableBfDecode(SDecoder *pDecoder);
 
 #ifdef __cplusplus
 }

include/util/tthread.h

@@ -23,10 +23,10 @@ extern "C" {
 #endif
 
 TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param);
-bool       taosDestroyThread(TdThread* pthread);
-bool       taosThreadRunning(TdThread* pthread);
+bool      taosDestroyThread(TdThread* pthread);
+bool      taosThreadRunning(TdThread* pthread);
 
-typedef void *(*ThreadFp)(void *param);
+typedef void* (*ThreadFp)(void* param);
 
 #ifdef __cplusplus
 }

include/util/tutil.h

@@ -19,8 +19,8 @@
 #include "os.h"
 #include "tcrc32c.h"
 #include "tdef.h"
-#include "tmd5.h"
 #include "thash.h"
+#include "tmd5.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -71,7 +71,7 @@ static FORCE_INLINE void taosEncryptPass_c(uint8_t *inBuf, size_t len, char *tar
 }
 
 static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, int32_t method, int32_t prefix,
-                                      int32_t suffix) {
+                                             int32_t suffix) {
   if (prefix == 0 && suffix == 0) {
     return MurmurHash3_32(tbname, tblen);
   } else {

source/client/src/clientEnv.c

@@ -71,7 +71,8 @@ static void deregisterRequest(SRequestObj *pRequest) {
   int32_t num = atomic_sub_fetch_32(&pTscObj->numOfReqs, 1);
 
   int64_t duration = taosGetTimestampUs() - pRequest->metric.start;
-  tscDebug("0x%" PRIx64 " free Request from connObj: 0x%" PRIx64 ", reqId:0x%" PRIx64 " elapsed:%.2f ms, "
+  tscDebug("0x%" PRIx64 " free Request from connObj: 0x%" PRIx64 ", reqId:0x%" PRIx64
+           " elapsed:%.2f ms, "
            "current:%d, app current:%d",
            pRequest->self, pTscObj->id, pRequest->requestId, duration / 1000.0, num, currentInst);
 
@@ -84,7 +85,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
     atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
   } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
     tscPerf("select duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
-            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%"PRIx64,
+            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%" PRIx64,
             duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
             pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
             pRequest->metric.planEnd - pRequest->metric.semanticEnd,
@@ -144,6 +145,7 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.user = (char *)user;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.compressSize = tsCompressMsgSize;
   void *pDnodeConn = rpcOpen(&rpcInit);
   if (pDnodeConn == NULL) {
     tscError("failed to init connection to server");

source/client/src/clientImpl.c

@@ -1991,6 +1991,7 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   rpcInit.sessions = 16;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.compressSize = tsCompressMsgSize;
   rpcInit.user = "_dnd";
 
   clientRpc = rpcOpen(&rpcInit);

source/common/src/tmisce.c

@@ -61,17 +61,15 @@ bool isEpsetEqual(const SEpSet* s1, const SEpSet* s2) {
 
 void updateEpSet_s(SCorEpSet* pEpSet, SEpSet* pNewEpSet) {
   taosCorBeginWrite(&pEpSet->version);
-    pEpSet->epSet = *pNewEpSet;
+  pEpSet->epSet = *pNewEpSet;
   taosCorEndWrite(&pEpSet->version);
 }
 
 SEpSet getEpSet_s(SCorEpSet* pEpSet) {
   SEpSet ep = {0};
   taosCorBeginRead(&pEpSet->version);
-    ep = pEpSet->epSet;
+  ep = pEpSet->epSet;
   taosCorEndRead(&pEpSet->version);
 
   return ep;
 }
-
-

source/common/src/ttime.c

@@ -67,11 +67,11 @@ static int64_t user_mktime64(const uint32_t year0, const uint32_t mon0, const ui
 // ==== mktime() kernel code =================//
 static int64_t m_deltaUtc = 0;
 void           deltaToUtcInitOnce() {
-  struct tm tm = {0};
+            struct tm tm = {0};
 
-  (void)taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
-  m_deltaUtc = (int64_t)taosMktime(&tm);
-  // printf("====delta:%lld\n\n", seconds);
+            (void)taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
+            m_deltaUtc = (int64_t)taosMktime(&tm);
+            // printf("====delta:%lld\n\n", seconds);
 }
 
 static int64_t parseFraction(char* str, char** end, int32_t timePrec);
@@ -81,8 +81,8 @@ static int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int
 static char*   forwardToTimeStringEnd(char* str);
 static bool    checkTzPresent(const char* str, int32_t len);
 
-static int32_t (*parseLocaltimeFp[])(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) = {parseLocaltime,
-                                                                                                                  parseLocaltimeDst};
+static int32_t (*parseLocaltimeFp[])(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) = {
+    parseLocaltime, parseLocaltimeDst};
 
 int32_t taosParseTime(const char* timestr, int64_t* utime, int32_t len, int32_t timePrec, int8_t day_light) {
   /* parse datatime string in with tz */
@@ -324,7 +324,7 @@ static FORCE_INLINE bool validateTm(struct tm* pTm) {
 
   int32_t leapYearMonthDay = 29;
   int32_t year = pTm->tm_year + 1900;
-  bool isLeapYear = ((year % 100) == 0)? ((year % 400) == 0):((year % 4) == 0);
+  bool    isLeapYear = ((year % 100) == 0) ? ((year % 400) == 0) : ((year % 4) == 0);
 
   if (isLeapYear && (pTm->tm_mon == 1)) {
     if (pTm->tm_mday > leapYearMonthDay) {
@@ -336,14 +336,14 @@ static FORCE_INLINE bool validateTm(struct tm* pTm) {
     }
   }
 
-  return  true;
+  return true;
 }
 
 int32_t parseLocaltime(char* timestr, int32_t len, int64_t* time, int32_t timePrec, char delim) {
   *time = 0;
   struct tm tm = {0};
 
-  char *str;
+  char* str;
   if (delim == 'T') {
     str = taosStrpTime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
   } else if (delim == 0) {
@@ -353,7 +353,7 @@ int32_t parseLocaltime(char* timestr, int32_t len, int64_t* time, int32_t timePr
   }
 
   if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
-    //if parse failed, try "%Y-%m-%d" format
+    // if parse failed, try "%Y-%m-%d" format
     str = taosStrpTime(timestr, "%Y-%m-%d", &tm);
     if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
       return -1;
@@ -390,7 +390,7 @@ int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* time, int32_t tim
   struct tm tm = {0};
   tm.tm_isdst = -1;
 
-  char *str;
+  char* str;
   if (delim == 'T') {
     str = taosStrpTime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
   } else if (delim == 0) {
@@ -400,7 +400,7 @@ int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* time, int32_t tim
   }
 
   if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
-    //if parse failed, try "%Y-%m-%d" format
+    // if parse failed, try "%Y-%m-%d" format
     str = taosStrpTime(timestr, "%Y-%m-%d", &tm);
     if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
       return -1;
@@ -438,14 +438,12 @@ char getPrecisionUnit(int32_t precision) {
 }
 
 int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
-  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI ||
-         fromPrecision == TSDB_TIME_PRECISION_MICRO ||
+  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
          fromPrecision == TSDB_TIME_PRECISION_NANO);
-  assert(toPrecision == TSDB_TIME_PRECISION_MILLI ||
-         toPrecision == TSDB_TIME_PRECISION_MICRO ||
+  assert(toPrecision == TSDB_TIME_PRECISION_MILLI || toPrecision == TSDB_TIME_PRECISION_MICRO ||
          toPrecision == TSDB_TIME_PRECISION_NANO);
   double tempResult = (double)time;
-  switch(fromPrecision) {
+  switch (fromPrecision) {
     case TSDB_TIME_PRECISION_MILLI: {
       switch (toPrecision) {
         case TSDB_TIME_PRECISION_MILLI:
@@ -459,7 +457,7 @@ int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrec
           time *= 1000000;
           goto end_;
       }
-    } // end from milli
+    }  // end from milli
     case TSDB_TIME_PRECISION_MICRO: {
       switch (toPrecision) {
         case TSDB_TIME_PRECISION_MILLI:
@@ -471,7 +469,7 @@ int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrec
           time *= 1000;
           goto end_;
       }
-    } //end from micro
+    }  // end from micro
     case TSDB_TIME_PRECISION_NANO: {
       switch (toPrecision) {
         case TSDB_TIME_PRECISION_MILLI:
@@ -481,20 +479,21 @@ int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrec
         case TSDB_TIME_PRECISION_NANO:
           return time;
       }
-    } //end from nano
+    }  // end from nano
     default: {
       assert(0);
       return time;  // only to pass windows compilation
     }
-  } //end switch fromPrecision
+  }  // end switch fromPrecision
 end_:
   if (tempResult >= (double)INT64_MAX) return INT64_MAX;
   if (tempResult <= (double)INT64_MIN) return INT64_MIN;  // INT64_MIN means NULL
   return time;
 }
 
-// !!!!notice:there are precision problems, double lose precison if time is too large, for example: 1626006833631000000*1.0 = double = 1626006833631000064
-//int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
+// !!!!notice:there are precision problems, double lose precison if time is too large, for example:
+// 1626006833631000000*1.0 = double = 1626006833631000064
+// int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
 //  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
 //         fromPrecision == TSDB_TIME_PRECISION_NANO);
 //  assert(toPrecision == TSDB_TIME_PRECISION_MILLI || toPrecision == TSDB_TIME_PRECISION_MICRO ||
@@ -503,53 +502,53 @@ end_:
 //  ((double)time * factors[fromPrecision][toPrecision]);
 //}
 
-
-// !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double = 1626006833631000064
+// !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
+// 1626006833631000064
 int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit) {
   assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
          fromPrecision == TSDB_TIME_PRECISION_NANO);
   int64_t factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
-  double tmp = time;
+  double  tmp = time;
   switch (toUnit) {
-    case 's':{
-      tmp /= (NANOSECOND_PER_SEC/factors[fromPrecision]);     // the result of division is an integer
-      time /= (NANOSECOND_PER_SEC/factors[fromPrecision]);
+    case 's': {
+      tmp /= (NANOSECOND_PER_SEC / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_SEC / factors[fromPrecision]);
       break;
     }
     case 'm':
-      tmp /= (NANOSECOND_PER_MINUTE/factors[fromPrecision]);  // the result of division is an integer
-      time /= (NANOSECOND_PER_MINUTE/factors[fromPrecision]);
+      tmp /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);
       break;
     case 'h':
-      tmp /= (NANOSECOND_PER_HOUR/factors[fromPrecision]);    // the result of division is an integer
-      time /= (NANOSECOND_PER_HOUR/factors[fromPrecision]);
+      tmp /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);
       break;
     case 'd':
-      tmp /= (NANOSECOND_PER_DAY/factors[fromPrecision]);     // the result of division is an integer
-      time /= (NANOSECOND_PER_DAY/factors[fromPrecision]);
+      tmp /= (NANOSECOND_PER_DAY / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_DAY / factors[fromPrecision]);
       break;
     case 'w':
-      tmp /= (NANOSECOND_PER_WEEK/factors[fromPrecision]);    // the result of division is an integer
-      time /= (NANOSECOND_PER_WEEK/factors[fromPrecision]);
+      tmp /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);
       break;
     case 'a':
-      tmp /= (NANOSECOND_PER_MSEC/factors[fromPrecision]);    // the result of division is an integer
-      time /= (NANOSECOND_PER_MSEC/factors[fromPrecision]);
+      tmp /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);  // the result of division is an integer
+      time /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);
       break;
     case 'u':
       // the result of (NANOSECOND_PER_USEC/(double)factors[fromPrecision]) maybe a double
       switch (fromPrecision) {
-        case TSDB_TIME_PRECISION_MILLI:{
+        case TSDB_TIME_PRECISION_MILLI: {
           tmp *= 1000;
           time *= 1000;
           break;
         }
-        case TSDB_TIME_PRECISION_MICRO:{
+        case TSDB_TIME_PRECISION_MICRO: {
           tmp /= 1;
           time /= 1;
           break;
         }
-        case TSDB_TIME_PRECISION_NANO:{
+        case TSDB_TIME_PRECISION_NANO: {
           tmp /= 1000;
           time /= 1000;
           break;
@@ -569,11 +568,11 @@ int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
   return time;
 }
 
-int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec, int64_t *timeVal) {
+int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal) {
   int32_t charLen = varDataLen(inputData);
-  char *newColData;
+  char*   newColData;
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY) {
-    newColData = taosMemoryCalloc(1,  charLen + 1);
+    newColData = taosMemoryCalloc(1, charLen + 1);
     memcpy(newColData, varDataVal(inputData), charLen);
     int32_t ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
@@ -582,9 +581,9 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
     }
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
-    newColData = taosMemoryCalloc(1,  charLen + TSDB_NCHAR_SIZE);
-    int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(inputData), charLen, newColData);
-    if (len < 0){
+    newColData = taosMemoryCalloc(1, charLen + TSDB_NCHAR_SIZE);
+    int len = taosUcs4ToMbs((TdUcs4*)varDataVal(inputData), charLen, newColData);
+    if (len < 0) {
       taosMemoryFree(newColData);
       return TSDB_CODE_FAILED;
     }
@@ -877,8 +876,8 @@ const char* fmtts(int64_t ts) {
 }
 
 void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
-  char       ts[40] = {0};
-  struct tm  ptm;
+  char      ts[40] = {0};
+  struct tm ptm;
 
   int32_t fractionLen;
   char*   format = NULL;

source/common/src/ttszip.c

@@ -209,7 +209,8 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
     uint32_t newSize = (uint32_t)(pTSBuf->numOfAlloc * 1.5);
     assert((int32_t)newSize > pTSBuf->numOfAlloc);
 
-    STSGroupBlockInfoEx* tmp = (STSGroupBlockInfoEx*)taosMemoryRealloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
+    STSGroupBlockInfoEx* tmp =
+        (STSGroupBlockInfoEx*)taosMemoryRealloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
     if (tmp == NULL) {
       return NULL;
     }

source/dnode/mgmt/exe/dmMain.c

@@ -15,9 +15,10 @@
 
 #define _DEFAULT_SOURCE
 #include "dmMgmt.h"
-#include "tconfig.h"
 #include "mnode.h"
+#include "tconfig.h"
 
+// clang-format off
 #define DM_APOLLO_URL    "The apollo string to use when configuring the server, such as: -a 'jsonFile:./tests/cfg.json', cfg.json text can be '{\"fqdn\":\"td1\"}'."
 #define DM_CFG_DIR       "Configuration directory."
 #define DM_DMP_CFG       "Dump configuration."
@@ -28,9 +29,10 @@
 #define DM_MACHINE_CODE  "Get machine code."
 #define DM_VERSION       "Print program version."
 #define DM_EMAIL         "<support@taosdata.com>"
+// clang-format on
 static struct {
 #ifdef WINDOWS
-  bool         winServiceMode;
+  bool winServiceMode;
 #endif
   bool         dumpConfig;
   bool         dumpSdb;
@@ -101,10 +103,10 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
       global.dumpConfig = true;
     } else if (strcmp(argv[i], "-V") == 0) {
       global.printVersion = true;
-  #ifdef WINDOWS
+#ifdef WINDOWS
     } else if (strcmp(argv[i], "--win_service") == 0) {
       global.winServiceMode = true;
-  #endif
+#endif
     } else if (strcmp(argv[i], "-e") == 0) {
       global.envCmd[cmdEnvIndex] = argv[++i];
       cmdEnvIndex++;
@@ -183,7 +185,7 @@ int main(int argc, char const *argv[]) {
   }
 
 #ifdef WINDOWS
-  int mainWindows(int argc,char** argv);
+  int mainWindows(int argc, char **argv);
   if (global.winServiceMode) {
     stratWindowsService(mainWindows);
   } else {
@@ -191,7 +193,7 @@ int main(int argc, char const *argv[]) {
   }
   return 0;
 }
-int mainWindows(int argc,char** argv) {
+int mainWindows(int argc, char **argv) {
 #endif
 
   if (global.generateGrant) {
@@ -224,7 +226,7 @@ int mainWindows(int argc,char** argv) {
     taosCleanupArgs();
     return -1;
   }
-  
+
   taosConvInit();
 
   if (global.dumpConfig) {

source/dnode/mgmt/mgmt_dnode/src/dmWorker.c

@@ -101,7 +101,7 @@ void dmStopMonitorThread(SDnodeMgmt *pMgmt) {
 static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SDnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
-  STraceId *  trace = &pMsg->info.traceId;
+  STraceId   *trace = &pMsg->info.traceId;
   dGTrace("msg:%p, will be processed in dnode queue, type:%s", pMsg, TMSG_INFO(pMsg->msgType));
 
   switch (pMsg->msgType) {

source/dnode/mgmt/mgmt_qnode/inc/qmInt.h

@@ -51,7 +51,7 @@ int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
 
-int32_t qndPreprocessQueryMsg(SQnode *pQnode, SRpcMsg * pMsg);
+int32_t qndPreprocessQueryMsg(SQnode *pQnode, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_qnode/src/qmHandle.c

@@ -21,7 +21,6 @@ void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) {
   qndGetLoad(pMgmt->pQnode, &qload);
 
   qload.dnodeId = pMgmt->pData->dnodeId;
-
 }
 
 void qmGetQnodeLoads(SQnodeMgmt *pMgmt, SQnodeLoad *pInfo) {

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -224,18 +224,17 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dInfo(
-      "vgId:%d, start to create vnode, page:%d pageSize:%d buffer:%d szPage:%d szBuf:%" PRIu64
-      " cacheLast:%d cacheLastSize:%d sstTrigger:%d tsdbPageSize:%d %d dbname:%s dbId:%" PRId64
-      "days:%d keep0:%d keep1:%d keep2:%d tsma:%d precision:%d compression:%d minRows:%d maxRows:%d, wal "
-      "fsync:%d level:%d retentionPeriod:%d retentionSize:%d rollPeriod:%d segSize:%d, hash method:%d begin:%u end:%u "
-      "prefix:%d surfix:%d replica:%d selfIndex:%d strict:%d",
-      req.vgId, req.pages, req.pageSize, req.buffer, req.pageSize * 1024, (uint64_t)req.buffer * 1024 * 1024,
-      req.cacheLast, req.cacheLastSize, req.sstTrigger, req.tsdbPageSize, req.tsdbPageSize * 1024, req.db, req.dbUid,
-      req.daysPerFile, req.daysToKeep0, req.daysToKeep1, req.daysToKeep2, req.isTsma, req.precision, req.compression,
-      req.minRows, req.maxRows, req.walFsyncPeriod, req.walLevel, req.walRetentionPeriod, req.walRetentionSize,
-      req.walRollPeriod, req.walSegmentSize, req.hashMethod, req.hashBegin, req.hashEnd, req.hashPrefix, req.hashSuffix,
-      req.replica, req.selfIndex, req.strict);
+  dInfo("vgId:%d, start to create vnode, page:%d pageSize:%d buffer:%d szPage:%d szBuf:%" PRIu64
+        ", cacheLast:%d cacheLastSize:%d sstTrigger:%d tsdbPageSize:%d %d dbname:%s dbId:%" PRId64
+        ", days:%d keep0:%d keep1:%d keep2:%d tsma:%d precision:%d compression:%d minRows:%d maxRows:%d"
+        ", wal fsync:%d level:%d retentionPeriod:%d retentionSize:%" PRId64 " rollPeriod:%d segSize:%" PRId64
+        ", hash method:%d begin:%u end:%u prefix:%d surfix:%d replica:%d selfIndex:%d strict:%d",
+        req.vgId, req.pages, req.pageSize, req.buffer, req.pageSize * 1024, (uint64_t)req.buffer * 1024 * 1024,
+        req.cacheLast, req.cacheLastSize, req.sstTrigger, req.tsdbPageSize, req.tsdbPageSize * 1024, req.db, req.dbUid,
+        req.daysPerFile, req.daysToKeep0, req.daysToKeep1, req.daysToKeep2, req.isTsma, req.precision, req.compression,
+        req.minRows, req.maxRows, req.walFsyncPeriod, req.walLevel, req.walRetentionPeriod, req.walRetentionSize,
+        req.walRollPeriod, req.walSegmentSize, req.hashMethod, req.hashBegin, req.hashEnd, req.hashPrefix,
+        req.hashSuffix, req.replica, req.selfIndex, req.strict);
   for (int32_t i = 0; i < req.replica; ++i) {
     dInfo("vgId:%d, replica:%d fqdn:%s port:%u", req.vgId, req.replicas[i].id, req.replicas[i].fqdn,
           req.replicas[i].port);

source/dnode/mgmt/node_mgmt/src/dmEnv.c

@@ -52,17 +52,23 @@ static int32_t dmInitMonitor() {
 static bool dmCheckDiskSpace() {
   osUpdate();
   if (!osDataSpaceAvailable()) {
-    dError("free disk size: %f GB, too little, require %f GB at least at least , quit", (double)tsDataSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsDataSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    dError("free disk size: %f GB, too little, require %f GB at least at least , quit",
+           (double)tsDataSpace.size.avail / 1024.0 / 1024.0 / 1024.0,
+           (double)tsDataSpace.reserved / 1024.0 / 1024.0 / 1024.0);
     terrno = TSDB_CODE_NO_AVAIL_DISK;
     return false;
   }
   if (!osLogSpaceAvailable()) {
-    dError("free disk size: %f GB, too little, require %f GB at least at least, quit", (double)tsLogSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsLogSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    dError("free disk size: %f GB, too little, require %f GB at least at least, quit",
+           (double)tsLogSpace.size.avail / 1024.0 / 1024.0 / 1024.0,
+           (double)tsLogSpace.reserved / 1024.0 / 1024.0 / 1024.0);
     terrno = TSDB_CODE_NO_AVAIL_DISK;
     return false;
   }
   if (!osTempSpaceAvailable()) {
-    dError("free disk size: %f GB, too little, require %f GB at least at least, quit", (double)tsTempSpace.size.avail / 1024.0 / 1024.0 / 1024.0, (double)tsTempSpace.reserved / 1024.0 / 1024.0 / 1024.0);
+    dError("free disk size: %f GB, too little, require %f GB at least at least, quit",
+           (double)tsTempSpace.size.avail / 1024.0 / 1024.0 / 1024.0,
+           (double)tsTempSpace.reserved / 1024.0 / 1024.0 / 1024.0);
     terrno = TSDB_CODE_NO_AVAIL_DISK;
     return false;
   }
@@ -73,7 +79,8 @@ static bool dmCheckDataDirVersion() {
   char checkDataDirJsonFileName[PATH_MAX];
   snprintf(checkDataDirJsonFileName, PATH_MAX, "%s/dnode/dnodeCfg.json", tsDataDir);
   if (taosCheckExistFile(checkDataDirJsonFileName)) {
-    dError("The default data directory %s contains old data of tdengine 2.x, please clear it before running!", tsDataDir);
+    dError("The default data directory %s contains old data of tdengine 2.x, please clear it before running!",
+           tsDataDir);
     return false;
   }
   return true;

source/dnode/mgmt/node_mgmt/src/dmMonitor.c

@@ -183,4 +183,3 @@ void dmGetQnodeLoads(SQnodeLoad *pInfo) {
     dmReleaseWrapper(pWrapper);
   }
 }
-

source/dnode/mgmt/node_mgmt/src/dmProc.c

@@ -91,8 +91,8 @@ static SProcQueue *dmInitProcQueue(SProc *proc, char *ptr, int32_t size) {
 static void dmCleanupProcQueue(SProcQueue *queue) {}
 
 static inline int32_t dmPushToProcQueue(SProc *proc, SProcQueue *queue, SRpcMsg *pMsg, EProcFuncType ftype) {
-  const void *  pHead = pMsg;
-  const void *  pBody = pMsg->pCont;
+  const void   *pHead = pMsg;
+  const void   *pBody = pMsg->pCont;
   const int16_t rawHeadLen = sizeof(SRpcMsg);
   const int32_t rawBodyLen = pMsg->contLen;
   const int16_t headLen = CEIL8(rawHeadLen);
@@ -261,7 +261,7 @@ int32_t dmInitProc(struct SMgmtWrapper *pWrapper) {
   proc->wrapper = pWrapper;
   proc->name = pWrapper->name;
 
-  SShm *  shm = &proc->shm;
+  SShm   *shm = &proc->shm;
   int32_t cstart = 0;
   int32_t csize = CEIL8(shm->size / 2);
   int32_t pstart = csize;
@@ -285,13 +285,13 @@ int32_t dmInitProc(struct SMgmtWrapper *pWrapper) {
 }
 
 static void *dmConsumChildQueue(void *param) {
-  SProc *       proc = param;
+  SProc        *proc = param;
   SMgmtWrapper *pWrapper = proc->wrapper;
-  SProcQueue *  queue = proc->cqueue;
+  SProcQueue   *queue = proc->cqueue;
   int32_t       numOfMsgs = 0;
   int32_t       code = 0;
   EProcFuncType ftype = DND_FUNC_REQ;
-  SRpcMsg *     pMsg = NULL;
+  SRpcMsg      *pMsg = NULL;
 
   dDebug("node:%s, start to consume from cqueue", proc->name);
   do {
@@ -328,13 +328,13 @@ static void *dmConsumChildQueue(void *param) {
 }
 
 static void *dmConsumParentQueue(void *param) {
-  SProc *       proc = param;
+  SProc        *proc = param;
   SMgmtWrapper *pWrapper = proc->wrapper;
-  SProcQueue *  queue = proc->pqueue;
+  SProcQueue   *queue = proc->pqueue;
   int32_t       numOfMsgs = 0;
   int32_t       code = 0;
   EProcFuncType ftype = DND_FUNC_REQ;
-  SRpcMsg *     pMsg = NULL;
+  SRpcMsg      *pMsg = NULL;
 
   dDebug("node:%s, start to consume from pqueue", proc->name);
   do {

source/dnode/mgmt/node_mgmt/src/dmTransport.c

@@ -277,6 +277,7 @@ int32_t dmInitClient(SDnode *pDnode) {
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.parent = pDnode;
   rpcInit.rfp = rpcRfp;
+  rpcInit.compressSize = tsCompressMsgSize;
 
   pTrans->clientRpc = rpcOpen(&rpcInit);
   if (pTrans->clientRpc == NULL) {

source/dnode/mgmt/node_util/inc/dmUtil.h

@@ -44,7 +44,6 @@
 extern "C" {
 #endif
 
-
 // clang-format off
 
 #define dFatal(...) { if (dDebugFlag & DEBUG_FATAL) { taosPrintLog("DND FATAL ", DEBUG_FATAL, 255,        __VA_ARGS__); }}

source/dnode/mgmt/test/bnode/dbnode.cpp

@@ -17,7 +17,7 @@ class DndTestBnode : public ::testing::Test {
     test.Init(TD_TMP_DIR_PATH "dbnodeTest", 9112);
     taosMsleep(1100);
   }
-  static void TearDownTestSuite() { test.Cleanup(); }
+  static void     TearDownTestSuite() { test.Cleanup(); }
   static Testbase test;
 
  public:

source/dnode/mgmt/test/sut/inc/sut.h

@@ -47,7 +47,7 @@ class Testbase {
   int32_t    connId;
 
  public:
-  int32_t SendShowReq(int8_t showType, const char *tb, const char* db);
+  int32_t SendShowReq(int8_t showType, const char* tb, const char* db);
   int32_t GetShowRows();
 
 #if 0

source/dnode/mgmt/test/sut/src/sut.cpp

@@ -30,14 +30,14 @@ void Testbase::InitLog(const char* path) {
   tsdbDebugFlag = 0;
   tsLogEmbedded = 1;
   tsAsyncLog = 0;
-  
+
   taosRemoveDir(path);
   taosMkDir(path);
   tstrncpy(tsLogDir, path, PATH_MAX);
 
   taosGetSystemInfo();
   tsRpcQueueMemoryAllowed = tsTotalMemoryKB * 0.1;
-if (taosInitLog("taosdlog", 1) != 0) {
+  if (taosInitLog("taosdlog", 1) != 0) {
     printf("failed to init log file\n");
   }
 }

source/dnode/mnode/impl/inc/mndGrant.h

@@ -22,12 +22,12 @@
 
 #include "mndInt.h"
 
-int32_t mndInitGrant(SMnode *pMnode);
-void    mndCleanupGrant();
-void    grantParseParameter();
-void    grantReset(SMnode *pMnode, EGrantType grant, uint64_t value);
-void    grantAdd(EGrantType grant, uint64_t value);
-void    grantRestore(EGrantType grant, uint64_t value);
+  int32_t mndInitGrant(SMnode * pMnode);
+  void    mndCleanupGrant();
+  void    grantParseParameter();
+  void    grantReset(SMnode * pMnode, EGrantType grant, uint64_t value);
+  void    grantAdd(EGrantType grant, uint64_t value);
+  void    grantRestore(EGrantType grant, uint64_t value);
 
 #ifdef __cplusplus
 }