Merge branch 'develop' into updatetestcase

documentation20/webdocs/markdowndocs/Evaluation-ch.md

@@ -6,10 +6,10 @@ TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑
 
 TDengine的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与Hadoop等典型的大数据平台相比，它具有如下鲜明的特点：
 
-* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒就能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快了十倍以上。
-* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10
-* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。临时查询可通过Shell, Python, R, Matlab随时进行。
+* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
+* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
+* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, Matlab随时进行。
 * __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
 * __零运维成本、零学习成本__：安装、集群一秒搞定，无需分库分表，实时备份。标准SQL，支持JDBC, RESTful, 支持Python/Java/C/C++/Go, 与MySQL相似，零学习成本。
 
@@ -21,7 +21,7 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 
 
 ### 数据源特点和需求
-从数据源角度，设计人员可以从已经角度分析TDengine在目标应用系统里面的适用性。
+从数据源角度，设计人员可以从下面几个角度分析TDengine在目标应用系统里面的适用性。
 
 |数据源特点和需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
@@ -33,14 +33,14 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 |系统架构要求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
 |要求简单可靠的系统架构|  |  | √ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
-|要求容错和高可靠|  |  | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能|
-|标准化规范|  |  | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范|
+|要求容错和高可靠|  |  | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能。|
+|标准化规范|  |  | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范。|
 
 ### 系统功能需求
 |系统功能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
 |要求完整的内置数据处理算法|  | √ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
-|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能|
+|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能。|
 
 ### 系统性能需求
 |系统性能需求|不适用|可能适用|非常适用|简单说明|
@@ -53,8 +53,8 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 |系统维护需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
 |要求系统可靠运行|  |  | √ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
-|要求运维学习成本可控|  |  | √ |同上|
-|要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务|
+|要求运维学习成本可控|  |  | √ |同上。|
+|要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
 
 ## TDengine 性能指标介绍和验证方法
 

documentation20/webdocs/markdowndocs/Getting Started-ch.md

@@ -59,7 +59,7 @@ systemctl status taosd
 
 ## TDengine命令行程序
 
-执行TDengine命令行程序，您只要在Linux终端执行`taos`即可
+执行TDengine命令行程序，您只要在Linux终端执行`taos`即可。
 
 ```cmd
 taos
@@ -74,9 +74,9 @@ taos>
 在TDengine终端中，用户可以通过SQL命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的SQL语句需要以分号结束来运行。示例：
 
 ```mysql
-create database db;
-use db;
-create table t (ts timestamp, cdata int);
+create database demo;
+use demo;
+create table t (ts timestamp, speed int);
 insert into t values ('2019-07-15 00:00:00', 10);
 insert into t values ('2019-07-15 01:00:00', 20);
 select * from t;

documentation20/webdocs/markdowndocs/Model-ch.md

@@ -11,9 +11,12 @@ TDengine采用关系型数据模型，需要建库、建表。因此对于一个
 ```cmd
 CREATE DATABASE power KEEP 365 DAYS 10 REPLICA 3 BLOCKS 4;
 ```
-上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，副本数为3, 内存块数为4。详细的语法及参数请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>
+上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，副本数为3, 内存块数为4。详细的语法及参数请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL</a>
 
-注意：任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
+**注意：**
+
+- 任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
+- 处于两个不同库的表是不能进行JOIN操作的。
 
 ## 创建超级表
 一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用TDengine, 需要对每个类型的设备创建一超级表。以表一中的智能电表为例，可以使用如下的SQL命令创建超级表：
@@ -31,14 +34,14 @@ CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 ```
 其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 TAOS SQL。
 
-TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列号）。但对于有的场景，并没有唯一的ID，可以将多个ID组合成一个唯一的ID。不建议将具有唯一性的ID作为标签值。
-
+TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列号）。但对于有的场景，并没有唯一的ID，可以将多个ID组合成一个唯一的ID。不建议将具有唯一性的ID作为标签值。  
+  
 **自动建表**：在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
 
 ```cmd
 INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
 ```
-上述SQL语句将记录(now, 10.2, 219, 0.32) 插入进表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。
-
-**多列模型**：TDengine支持多列模型，只要这些物理量是同时采集的，这些量就可以作为不同列放在同一张表里。有的数据采集点有多组采集量，每一组的数据采集时间是不一样的，这时需要对同一个采集点建多张表。但还有一种极限的设计，单列模型，无论是否同时采集，每个采集的物理量单独建表。TDengine建议，只要采集时间一致，就采用多列模型，因为插入效率以及存储效率更高。
+上述SQL语句将记录(now, 10.2, 219, 0.32) 插入进表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。  
+  
+**多列模型**：TDengine支持多列模型，只要这些物理量是同时采集的，这些量就可以作为不同列放在同一张表里。有的数据采集点有多组采集量，每一组的数据采集时间是不一样的，这时需要对同一个采集点建多张表。但还有一种极限的设计，单列模型，无论是否同时采集，每个采集的物理量单独建表。TDengine建议，只要采集时间一致，就采用多列模型，因为插入效率以及存储效率更高。TDengine支持最大的列数为1024列。
 

documentation20/webdocs/markdowndocs/Queries-ch.md

@@ -59,7 +59,7 @@ Query OK, 2 row(s) in set (0.002136s)
 
 物联网场景里，经常需要通过降采样（down sampling）将采集的数据按时间段进行聚合。TDengine 提供了一个简便的关键词 interval 让按照时间窗口的查询操作变得极为简单。比如，将智能电表 d1001 采集的电流值每10秒钟求和
 ```mysql
-taos> SELECT sum(current) FROM d1001 INTERVAL(10s) ;
+taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
            ts            |       sum(current)        |
 ======================================================
  2018-10-03 14:38:00.000 |              10.300000191 |
@@ -68,7 +68,7 @@ Query OK, 2 row(s) in set (0.000883s)
 ```
 降采样操作也适用于超级表，比如：将所有智能电表采集的电流值每秒钟求和
 ```mysql
-taos> SELECT SUM(current) FROM meters INTERVAL(1s) ;
+taos> SELECT SUM(current) FROM meters INTERVAL(1s);
            ts            |       sum(current)        |
 ======================================================
  2018-10-03 14:38:04.000 |              10.199999809 |

documentation20/webdocs/markdowndocs/TAOS SQL-ch.md

@@ -59,7 +59,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 
 - **创建数据库**  
     ```mysql
-    CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep]
+    CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep];
     ```
     说明：
     
@@ -71,21 +71,21 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 
 - **使用数据库**
     ```mysql
-    USE db_name
+    USE db_name;
     ```
     使用/切换数据库
 
 
 - **删除数据库**
     ```mysql
-    DROP DATABASE [IF EXISTS] db_name
+    DROP DATABASE [IF EXISTS] db_name;
     ```
     删除数据库。所包含的全部数据表将被删除，谨慎使用
 
 
 - **显示系统所有数据库**
     ```mysql
-    SHOW DATABASES
+    SHOW DATABASES;
     ```
 
 
@@ -93,7 +93,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **创建数据表**
   
     ```mysql
-    CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...])
+    CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
     ```
     说明：
     1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；
@@ -104,13 +104,13 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **删除数据表**
 
     ```mysql
-    DROP TABLE [IF EXISTS] tb_name
+    DROP TABLE [IF EXISTS] tb_name;
     ```
 
 - **显示当前数据库下的所有数据表信息**
 
     ```mysql
-    SHOW TABLES [LIKE tb_name_wildcar]
+    SHOW TABLES [LIKE tb_name_wildcar];
     ```
 
     显示当前数据库下的所有数据表信息。说明：可在like中使用通配符进行名称的匹配。 通配符匹配：1）’%’ (百分号)匹配0到任意个字符；2）’_’下划线匹配一个字符。
@@ -119,13 +119,13 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **获取表的结构信息**
 
     ```mysql
-    DESCRIBE tb_name
+    DESCRIBE tb_name;
     ```
 
 - **表增加列**
 
     ```mysql
-    ALTER TABLE tb_name ADD COLUMN field_name data_type
+    ALTER TABLE tb_name ADD COLUMN field_name data_type;
     ```
     说明：
     1) 列的最大个数为1024，最小个数为2；
@@ -134,7 +134,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **表删除列**
 
     ```mysql
-    ALTER TABLE tb_name DROP COLUMN field_name 
+    ALTER TABLE tb_name DROP COLUMN field_name; 
     ```
     如果表是通过[超级表](../super-table/)创建，更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表，可以直接修改表结构
 
@@ -142,7 +142,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **创建超级表**
   
     ```mysql
-    CREATE TABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3])
+    CREATE TABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
     ```
     创建STable, 与创建表的SQL语法相似，但需指定TAGS字段的名称和类型
     
@@ -155,61 +155,61 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 - **删除超级表**
 
     ```mysql
-    DROP TABLE [IF EXISTS] stb_name
+    DROP TABLE [IF EXISTS] stb_name;
     ```
     删除STable会自动删除通过STable创建的字表。
 
 - **显示当前数据库下的所有超级表信息**
 
     ```mysql
-    SHOW STABLES [LIKE tb_name_wildcar]
+    SHOW STABLES [LIKE tb_name_wildcar];
     ```
     查看数据库内全部STable，及其相关信息，包括STable的名称、创建时间、列数量、标签（TAG）数量、通过该STable建表的数量。
 
 - **获取超级表的结构信息**
 
     ```mysql
-    DESCRIBE stb_name
+    DESCRIBE stb_name;
     ```
     
 - **超级表增加列**
 
     ```mysql
-    ALTER TABLE stb_name ADD COLUMN field_name data_type
+    ALTER TABLE stb_name ADD COLUMN field_name data_type;
     ```
 
 - **超级表删除列**
 
     ```mysql
-    ALTER TABLE stb_name DROP COLUMN field_name 
+    ALTER TABLE stb_name DROP COLUMN field_name; 
     ```
 
 ## 超级表 STable 中 TAG 管理
 - **添加标签**
   
     ```mysql
-    ALTER TABLE stb_name ADD TAG new_tag_name tag_type
+    ALTER TABLE stb_name ADD TAG new_tag_name tag_type;
     ```
     为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过128个，总长度不超过16k个字符.
 
 - **删除标签**
 
     ```mysql
-    ALTER TABLE stb_name DROP TAG tag_name
+    ALTER TABLE stb_name DROP TAG tag_name;
     ```
     删除超级表的一个标签，从超级表删除某个标签后，该超级表下的所有子表也会自动删除该标签。
 
 - **修改标签名**
 
     ```mysql
-    ALTER TABLE stb_name CHANGE TAG old_tag_name new_tag_name
+    ALTER TABLE stb_name CHANGE TAG old_tag_name new_tag_name;
     ```
     修改超级表的标签名，从超级表修改某个标签名后，该超级表下的所有子表也会自动更新该标签名。
 
 - **修改字表标签值**
 
     ```mysql
-    ALTER TABLE tb_name SET TAG tag_name=new_tag_value
+    ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
     ```
     说明：除了更新标签的值的操作是针对子表进行，其他所有的标签操作（添加标签、删除标签等）均只能作用于STable，不能对单个子表操作。对STable添加标签以后，依托于该STable建立的所有表将自动增加了一个标签，所有新增标签的默认值都是NULL。
 
@@ -253,8 +253,8 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 
 - **同时向多个表按列插入多条记录**
     ```mysql
-    INSERT INTO tb1_name (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value1, ...)
-                tb2_name (tb2_field1_name, ...) VALUES(field1_value1, ...) (field1_value2, ...)
+    INSERT INTO tb1_name (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...)
+                tb2_name (tb2_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...);
     ```
     同时向表tb1_name和tb2_name中按列分别插入多条记录 
 
@@ -435,11 +435,11 @@ Query OK, 1 row(s) in set (0.000081s)
 #### 小技巧
 获取一个超级表所有的子表名及相关的标签信息：
 ```
-SELECT TBNAME, location FROM meters
+SELECT TBNAME, location FROM meters;
 ```
 统计超级表下辖子表数量：
 ```
-SELECT COUNT(TBNAME) FROM meters
+SELECT COUNT(TBNAME) FROM meters;
 ```
 以上两个查询均只支持在Where条件子句中添加针对标签（TAGS）的过滤条件。例如：
 ```
@@ -486,31 +486,31 @@ Query OK, 1 row(s) in set (0.001091s)
 - 对于下面的例子，表tb1用以下语句创建
 
     ```mysql
-    CREATE TABLE tb1 (ts timestamp, col1 int, col2 float, col3 binary(50))
+    CREATE TABLE tb1 (ts timestamp, col1 int, col2 float, col3 binary(50));
     ```
 
 - 查询tb1刚过去的一个小时的所有记录
 
     ```mysql
-    SELECT * FROM tb1 WHERE ts >= NOW - 1h
+    SELECT * FROM tb1 WHERE ts >= NOW - 1h;
     ```
 
 - 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围，并且col3的字符串是'nny'结尾的记录，结果按照时间戳降序
 
     ```mysql
-    SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC
+    SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC;
     ```
 
 - 查询col1与col2的和，并取名complex, 时间大于2018-06-01 08:00:00.000, col2大于1.2，结果输出仅仅10条记录，从第5条开始
 
     ```mysql
-    SELECT (col1 + col2) AS 'complex' FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' and col2 > 1.2 LIMIT 10 OFFSET 5
+    SELECT (col1 + col2) AS 'complex' FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' and col2 > 1.2 LIMIT 10 OFFSET 5;
     ```
 
 - 查询过去10分钟的记录，col2的值大于3.14，并且将结果输出到文件 `/home/testoutpu.csv`.
 
     ```mysql
-    SELECT COUNT(*) FROM tb1 WHERE ts >= NOW - 10m AND col2 > 3.14 >> /home/testoutpu.csv
+    SELECT COUNT(*) FROM tb1 WHERE ts >= NOW - 10m AND col2 > 3.14 >> /home/testoutpu.csv;
     ```
 
 ## SQL函数
@@ -521,7 +521,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **COUNT**
     ```mysql
-    SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause]
+    SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中记录行数或某列的非空值个数。  
     返回结果数据类型：长整型INT64。  
@@ -547,7 +547,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **AVG**
     ```mysql
-    SELECT AVG(field_name) FROM tb_name [WHERE clause]
+    SELECT AVG(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的平均值。  
     返回结果数据类型：双精度浮点数Double。  
@@ -571,7 +571,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **TWA**
     ```mysql
-    SELECT TWA(field_name) FROM tb_name WHERE clause
+    SELECT TWA(field_name) FROM tb_name WHERE clause;
     ```
     功能说明：时间加权平均函数。统计表/超级表中某列在一段时间内的时间加权平均。  
     返回结果数据类型：双精度浮点数Double。  
@@ -581,7 +581,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **SUM**
     ```mysql
-    SELECT SUM(field_name) FROM tb_name [WHERE clause]
+    SELECT SUM(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的和。  
     返回结果数据类型：双精度浮点数Double和长整型INT64。  
@@ -605,7 +605,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **STDDEV**
     ```mysql
-    SELECT STDDEV(field_name) FROM tb_name [WHERE clause]
+    SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的均方差。  
     返回结果数据类型：双精度浮点数Double。  
@@ -623,7 +623,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **LEASTSQUARES**
     ```mysql
-    SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause]
+    SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的值是主键（时间戳）的拟合直线方程。start_val是自变量初始值，step_val是自变量的步长值。  
     返回结果数据类型：字符串表达式（斜率, 截距）。  
@@ -644,7 +644,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **MIN**
     ```mysql
-    SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause]
+    SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最小值。  
     返回结果数据类型：同应用的字段。  
@@ -667,7 +667,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **MAX**
     ```mysql
-    SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最大值。  
     返回结果数据类型：同应用的字段。  
@@ -691,7 +691,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **FIRST**
     ```mysql
-    SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最先写入的非NULL值。  
     返回结果数据类型：同应用的字段。  
@@ -715,7 +715,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **LAST**
     ```mysql
-    SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最后写入的非NULL值。  
     返回结果数据类型：同应用的字段。  
@@ -739,7 +739,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **TOP**
     ```mysql
-    SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明： 统计表/超级表中某列的值最大*k*个非NULL值。若多于k个列值并列最大，则返回时间戳小的。     
     返回结果数据类型：同应用的字段。  
@@ -766,7 +766,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **BOTTOM**
     ```mysql
-    SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最小*k*个非NULL值。若多于k个列值并列最小，则返回时间戳小的。  
     返回结果数据类型：同应用的字段。  
@@ -792,7 +792,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **PERCENTILE**
     ```mysql
-    SELECT PERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT PERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表中某列的值百分比分位数。  
     返回结果数据类型： 双精度浮点数Double。  
@@ -810,7 +810,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **APERCENTILE**
     ```mysql
-    SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。  
     返回结果数据类型： 双精度浮点数Double。  
@@ -826,7 +826,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     
 - **LAST_ROW**
     ```mysql
-    SELECT LAST_ROW(field_name) FROM { tb_name | stb_name }
+    SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
     ```
     功能说明：返回表（超级表）的最后一条记录。  
     返回结果数据类型：同应用的字段。  
@@ -851,7 +851,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 ### 计算函数
 - **DIFF**
     ```mysql
-    SELECT DIFF(field_name) FROM tb_name [WHERE clause]
+    SELECT DIFF(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的值与前一行对应值的差。  
     返回结果数据类型： 同应用字段。  
@@ -871,7 +871,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 - **SPREAD**
     ```mysql
-    SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause]
+    SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的最大值和最小值之差。  
     返回结果数据类型： 双精度浮点数。  
@@ -897,7 +897,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 - **四则运算**
 
     ```mysql
-    SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name }  [WHERE clause]
+    SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name }  [WHERE clause];
     ```
     功能说明：统计表/超级表中某列或多列间的值加、减、乘、除、取余计算结果。  
     返回结果数据类型：双精度浮点数。  
@@ -968,5 +968,5 @@ SELECT AVG(current),MAX(current),LEASTSQUARES(current, start_val, step_val), PER
 - 表名最大长度为193，每行数据最大长度16k个字符
 - 列名最大长度为65，最多允许1024列，最少需要2列，第一列必须是时间戳
 - 标签最多允许128个，可以0个，标签总长度不超过16k个字符
-- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改
+- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为8M
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
\ No newline at end of file

documentation20/webdocs/markdowndocs/administrator-ch.md

@@ -78,7 +78,7 @@ TDengine集群的节点数必须大于等于副本数，否则创建表时将报
 
 TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修改配置参数，以满足不同场景的需求。配置文件的缺省位置在/etc/taos目录，可以通过taosd命令行执行参数-c指定配置文件目录。比如taosd -c /home/user来指定配置文件位于/home/user这个目录。
 
-下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节。**注意：配置修改后，需要重启*taosd*服务才能生效。**
+下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节，而且这些参数的缺省配置都是工作的，一般无需设置。**注意：配置修改后，需要重启*taosd*服务才能生效。**
 
 - firstEp: taosd启动时，主动连接的集群中第一个dnode的end point, 缺省值为 localhost:6030。
 - secondEp: taosd启动时，如果first连接不上，尝试连接集群中第二个dnode的end point, 缺省值为空。
@@ -94,6 +94,8 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 - maxSQLLength：单条SQL语句允许最长限制。默认值：65380字节。
 - maxBinaryDisplayWidth：Shell中binary 和 nchar字段的显示宽度上限，超过此限制的部分将被隐藏。默认值：30。可在 shell 中通过命令 set max_binary_display_width nn动态修改此选项。
 
+**注意：**对于端口，TDengine会使用从serverPort起11个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030都6040共11个端口，而且必须TCP和UDP都打开。
+
 不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine提供如下存储相关的系统配置参数：
 
 - days：一个数据文件存储数据的时间跨度，单位为天，默认值：10。
@@ -111,7 +113,7 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL： 
 
 ```
- create database demo days 10 cache 32 blocks 8 replica 3
+ create database demo days 10 cache 32 blocks 8 replica 3;
 ```
 
 该SQL创建了一个库demo, 每个数据文件存储10天数据，内存块为32兆字节，每个VNODE占用8个内存块，副本数为3，而其他参数与系统配置完全一致。
@@ -150,25 +152,25 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
 系统管理员可以在CLI界面里添加、删除用户，也可以修改密码。CLI里SQL语法如下：
 
 ```
-CREATE USER user_name PASS ‘password’
+CREATE USER user_name PASS ‘password’;
 ```
 
 创建用户，并指定用户名和密码，密码需要用单引号引起来
 
 ```
-DROP USER user_name
+DROP USER user_name;
 ```
 
 删除用户，限root用户使用
 
 ```
-ALTER USER user_name PASS ‘password’  
+ALTER USER user_name PASS ‘password’;
 ```
 
 修改用户密码, 为避免被转换为小写，密码需要用单引号引用
 
 ```
-SHOW USERS
+SHOW USERS;
 ```
 
 显示所有用户
@@ -186,7 +188,7 @@ TDengine的shell支持source filename命令，用于批量运行文件中的SQL
 TDengine也支持在shell对已存在的表从CSV文件中进行数据导入。CSV文件只属于一张表且CSV文件中的数据格式需与要导入表的结构相同, 在导入的时候，其语法如下
 
 ```mysql
-insert into tb1 file 'path/data.csv'
+insert into tb1 file 'path/data.csv';
 ```
 注意：如果CSV文件首行存在描述信息，请手动删除后再导入
 
@@ -237,7 +239,7 @@ TDengine提供了方便的数据库导入导出工具taosdump。用户可以将t
 如果用户需要导出一个表或一个STable中的数据，可在shell中运行
 
 ```
-select * from <tb_name> >> data.csv
+select * from <tb_name> >> data.csv;
 ```
 
 这样，表tb_name中的数据就会按照CSV格式导出到文件data.csv中。
@@ -251,37 +253,37 @@ TDengine提供了方便的数据库导出工具taosdump。用户可以根据需
 系统管理员可以从CLI查询系统的连接、正在进行的查询、流式计算，并且可以关闭连接、停止正在进行的查询和流式计算。CLI里SQL语法如下：
 
 ```
-SHOW CONNECTIONS
+SHOW CONNECTIONS;
 ```
 
 显示数据库的连接，其中一列显示ip:port, 为连接的IP地址和端口号。
 
 ```
-KILL CONNECTION <connection-id>
+KILL CONNECTION <connection-id>;
 ```
 
 强制关闭数据库连接，其中的connection-id是SHOW CONNECTIONS中显示的第一列的数字。
 
 ```
-SHOW QUERIES
+SHOW QUERIES;
 ```
 
 显示数据查询，其中第一列显示的以冒号隔开的两个数字为query-id，为发起该query应用连接的connection-id和查询次数。
 
 ```
-KILL QUERY <query-id>
+KILL QUERY <query-id>;
 ```
 
 强制关闭数据查询，其中query-id是SHOW QUERIES中显示的 connection-id:query-no字串，如“105:2”，拷贝粘贴即可。
 
 ```
-SHOW STREAMS
+SHOW STREAMS;
 ```
 
 显示流式计算，其中第一列显示的以冒号隔开的两个数字为stream-id, 为启动该stream应用连接的connection-id和发起stream的次数。
 
 ```
-KILL STREAM <stream-id>
+KILL STREAM <stream-id>;
 ```
 
 强制关闭流式计算，其中的中stream-id是SHOW STREAMS中显示的connection-id:stream-no字串，如103:2，拷贝粘贴即可。

documentation20/webdocs/markdowndocs/advanced features-ch.md

@@ -39,7 +39,7 @@ create table D1002 using meters tags ("Beijing.Haidian", 2);
 我们已经知道，可以通过下面这条SQL语句以一分钟为时间窗口、30秒为前向增量统计这些电表的平均电压。
 
 ```sql
-select avg(voltage) from meters interval(1m) sliding(30s)
+select avg(voltage) from meters interval(1m) sliding(30s)；
 ```
 
 每次执行这条语句，都会重新计算所有数据。 
@@ -47,14 +47,14 @@ select avg(voltage) from meters interval(1m) sliding(30s)
 可以把上面的语句改进成下面的样子，每次使用不同的 `startTime` 并定期执行：
 
 ```sql
-select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s)
+select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s)；
 ```
 
 这样做没有问题，但TDengine提供了更简单的方法，
 只要在最初的查询语句前面加上 `create table {tableName} as ` 就可以了, 例如：
 
 ```sql
-create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s)
+create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s)；
 ```
 
 会自动创建一个名为 `avg_vol` 的新表，然后每隔30秒，TDengine会增量执行 `as` 后面的 SQL 语句，
@@ -80,7 +80,7 @@ taos> select * from avg_vol;
 比如使用下面的SQL创建的连续查询将运行一小时，之后会自动停止。
 
 ```sql
-create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s)
+create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s)；
 ```
 
 需要说明的是，上面例子中的 `now` 是指创建连续查询的时间，而不是查询执行的时间，否则，查询就无法自动停止了。 

documentation20/webdocs/markdowndocs/cluster-ch.md

@@ -97,8 +97,11 @@ SHOW DNODES;
 ```
 SHOW VGROUPS;
 ```
-##高可用性
-TDengine通过多副本的机制来提供系统的高可用性。副本数是与DB关联的，一个集群里可以有多个DB，根据运营的需求，每个DB可以配置不同的副本数。创建数据库时，通过参数replica 指定副本数（缺省为1）。如果副本数为1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误“more dnodes are needed"。比如下面的命令将创建副本数为3的数据库demo：
+##vnode的高可用性
+TDengine通过多副本的机制来提供系统的高可用性，包括vnode和mnode的高可用性。
+
+vnode的副本数是与DB关联的，一个集群里可以有多个DB，根据运营的需求，每个DB可以配置不同的副本数。创建数据库时，通过参数replica 指定副本数（缺省为1）。如果副本数为1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误“more dnodes are needed"。比如下面的命令将创建副本数为3的数据库demo：
+
 ```
 CREATE DATABASE demo replica 3;
 ```
@@ -108,7 +111,7 @@ CREATE DATABASE demo replica 3;
 
 因为vnode的引入，无法简单的给出结论：“集群中过半dnode工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为3，只有三个dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个节点不工作，那整个集群就无法正常工作了。
 
-##Mnode的高可用
+##Mnode的高可用性
 TDengine集群是由mnode (taosd的一个模块，逻辑节点) 负责管理的，为保证mnode的高可用，可以配置多个mnode副本，副本数由系统配置参数numOfMnodes决定，有效范围为1-3。为保证元数据的强一致性，mnode副本之间是通过同步的方式进行数据复制的。
 
 一个集群有多个dnode, 但一个dnode至多运行一个mnode实例。多个dnode情况下，哪个dnode可以作为mnode呢？这是完全由系统根据整个系统资源情况，自动指定的。用户可通过CLI程序taos，在TDengine的console里，执行如下命令：
@@ -120,6 +123,8 @@ SHOW MNODES;
 
 为保证mnode服务的高可用性，numOfMnodes必须设置为2或更大。因为mnode保存的元数据必须是强一致的，如果numOfMnodes大于2，复制参数quorum自动设为2，也就是说，至少要保证有两个副本写入数据成功，才通知客户端应用写入成功。
 
+**注意：**一个TDengine高可用系统，无论是vnode还是mnode, 都必须配置多个副本。
+
 ##负载均衡
 
 有三种情况，将触发负载均衡，而且都无需人工干预。

documentation20/webdocs/markdowndocs/insert-ch.md

@@ -22,7 +22,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 
 **Tips:** 
 
-- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置）。
+- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置，最大可配置为8M）。
 - TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程切频繁切换，带来额外开销。
 
 ## Prometheus直接写入
@@ -49,7 +49,8 @@ go build
 参考Prometheus的[配置文档](https://prometheus.io/docs/prometheus/latest/configuration/configuration/),在Prometheus的配置文件中的<remote_write>部分，增加以下配置
 
 - url: bailongma API服务提供的URL, 参考下面的blm_prometheus启动示例章节
-  启动Prometheus后，可以通过taos客户端查询确认数据是否成功写入。
+
+启动Prometheus后，可以通过taos客户端查询确认数据是否成功写入。
 
 ### 启动blm_prometheus程序
 blm_prometheus程序有以下选项，在启动blm_prometheus程序时可以通过设定这些选项来设定blm_prometheus的配置。
@@ -127,7 +128,7 @@ go build
 一切正常的情况下，就会在对应的目录下生成一个blm_telegraf的可执行程序。
 
 ### 安装Telegraf
-目前TDengine支持Telegraf 1.7.4以上的版本。用户可以根据当前的操作系统，到Telegraf官网下载安装包，并执行安装。下载地址如下：https://portal.influxdata.com/downloads
+目前TDengine支持Telegraf 1.7.4以上的版本。用户可以根据当前的操作系统，到Telegraf官网下载安装包，并执行安装。下载地址如下：<a href='https://portal.influxdata.com/downloads'>https://portal.influxdata.com/downloads</a>
 
 ### 配置Telegraf
 修改Telegraf配置文件/etc/telegraf/telegraf.conf中与TDengine有关的配置项。 

src/common/inc/tglobal.h

@@ -32,6 +32,7 @@ extern uint16_t tsSyncPort;
 extern int32_t  tsStatusInterval;
 extern int32_t  tsNumOfMnodes;
 extern int32_t  tsEnableVnodeBak;
+extern int32_t  tsEnableTelemetryReporting;
 
 // common
 extern int      tsRpcTimer;

src/common/src/tglobal.c

@@ -40,6 +40,7 @@ uint16_t tsSyncPort = 6040;
 int32_t  tsStatusInterval = 1;  // second
 int32_t  tsNumOfMnodes = 3;
 int32_t  tsEnableVnodeBak = 1;
+int32_t  tsEnableTelemetryReporting = 1;
 
 // common
 int32_t tsRpcTimer = 1000;
@@ -430,6 +431,16 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
+  cfg.option = "telemetryReporting";
+  cfg.ptr = &tsEnableTelemetryReporting;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 1;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
+
   cfg.option = "balance";
   cfg.ptr = &tsEnableBalance;
   cfg.valType = TAOS_CFG_VTYPE_INT32;

src/dnode/inc/dnodeTelemetry.h

+/*
+ * Copyright (c) 2020 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_DNODE_TELEMETRY_H
+#define TDENGINE_DNODE_TELEMETRY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t dnodeInitTelemetry();
+void    dnodeCleanupTelemetry();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/dnode/src/dnodeMain.c

@@ -30,6 +30,7 @@
 #include "dnodeMWrite.h"
 #include "dnodeMPeer.h"
 #include "dnodeShell.h"
+#include "dnodeTelemetry.h"
 
 static int32_t dnodeInitStorage();
 static void dnodeCleanupStorage();
@@ -47,18 +48,19 @@ typedef struct {
 } SDnodeComponent;
 
 static const SDnodeComponent tsDnodeComponents[] = {
-  {"storage", dnodeInitStorage,    dnodeCleanupStorage},
-  {"vread",   dnodeInitVnodeRead,  dnodeCleanupVnodeRead},
-  {"vwrite",  dnodeInitVnodeWrite, dnodeCleanupVnodeWrite},
-  {"mread",   dnodeInitMnodeRead,  dnodeCleanupMnodeRead},
-  {"mwrite",  dnodeInitMnodeWrite, dnodeCleanupMnodeWrite},
-  {"mpeer",   dnodeInitMnodePeer,  dnodeCleanupMnodePeer},  
-  {"client",  dnodeInitClient,     dnodeCleanupClient},
-  {"server",  dnodeInitServer,     dnodeCleanupServer},
-  {"mgmt",    dnodeInitMgmt,       dnodeCleanupMgmt},
-  {"modules", dnodeInitModules,    dnodeCleanupModules},
-  {"mgmt-tmr",dnodeInitMgmtTimer,  dnodeCleanupMgmtTimer},
-  {"shell",   dnodeInitShell,      dnodeCleanupShell}
+  {"storage",   dnodeInitStorage,    dnodeCleanupStorage},
+  {"vread",     dnodeInitVnodeRead,  dnodeCleanupVnodeRead},
+  {"vwrite",    dnodeInitVnodeWrite, dnodeCleanupVnodeWrite},
+  {"mread",     dnodeInitMnodeRead,  dnodeCleanupMnodeRead},
+  {"mwrite",    dnodeInitMnodeWrite, dnodeCleanupMnodeWrite},
+  {"mpeer",     dnodeInitMnodePeer,  dnodeCleanupMnodePeer},  
+  {"client",    dnodeInitClient,     dnodeCleanupClient},
+  {"server",    dnodeInitServer,     dnodeCleanupServer},
+  {"mgmt",      dnodeInitMgmt,       dnodeCleanupMgmt},
+  {"modules",   dnodeInitModules,    dnodeCleanupModules},
+  {"mgmt-tmr",  dnodeInitMgmtTimer,  dnodeCleanupMgmtTimer},
+  {"shell",     dnodeInitShell,      dnodeCleanupShell},
+  {"telemetry", dnodeInitTelemetry,  dnodeCleanupTelemetry},
 };
 
 static int dnodeCreateDir(const char *dir) {

src/dnode/src/dnodeTelemetry.c

+/*
+ * Copyright (c) 2020 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/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taoserror.h"
+#include "tglobal.h"
+#include "tutil.h"
+#include "osTime.h"
+#include "tsocket.h"
+#include "tbuffer.h"
+#include "mnode.h"
+#include "mnodeCluster.h"
+#include "mnodeSdb.h"
+#include "dnode.h"
+#include "dnodeInt.h"
+#include "dnodeTelemetry.h"
+
+static sem_t tsExitSem;
+static pthread_t tsTelemetryThread;
+
+#define TELEMETRY_SERVER "telemetry.taosdata.com"
+#define TELEMETRY_PORT 80
+#define REPORT_INTERVAL 86400
+
+static void beginObject(SBufferWriter* bw) {
+  tbufWriteChar(bw, '{');
+}
+
+static void closeObject(SBufferWriter* bw) {
+  size_t len = tbufTell(bw);
+  if (tbufGetData(bw, false)[len - 1] == ',') {
+    tbufWriteCharAt(bw, len - 1, '}');
+  } else {
+    tbufWriteChar(bw, '}');
+  }
+  tbufWriteChar(bw, ',');
+}
+
+#if 0
+static void beginArray(SBufferWriter* bw) {
+  tbufWriteChar(bw, '[');
+}
+
+static void closeArray(SBufferWriter* bw) {
+  size_t len = tbufTell(bw);
+  if (tbufGetData(bw, false)[len - 1] == ',') {
+    tbufWriteCharAt(bw, len - 1, ']');
+  } else {
+    tbufWriteChar(bw, ']');
+  }
+  tbufWriteChar(bw, ',');
+}
+#endif
+
+static void writeString(SBufferWriter* bw, const char* str) {
+  tbufWriteChar(bw, '"');
+  tbufWrite(bw, str, strlen(str));
+  tbufWriteChar(bw, '"');
+}
+
+static void addIntField(SBufferWriter* bw, const char* k, int64_t v) {
+  writeString(bw, k);
+  tbufWriteChar(bw, ':');
+  char buf[32];
+  sprintf(buf, "%" PRId64, v);
+  tbufWrite(bw, buf, strlen(buf));
+  tbufWriteChar(bw, ',');
+}
+
+static void addStringField(SBufferWriter* bw, const char* k, const char* v) {
+  writeString(bw, k);
+  tbufWriteChar(bw, ':');
+  writeString(bw, v);
+  tbufWriteChar(bw, ',');
+}
+
+static void addCpuInfo(SBufferWriter* bw) {
+  char * line = NULL;
+  size_t size = 0;
+  int done = 0;
+
+  FILE* fp = fopen("/proc/cpuinfo", "r");
+  if (fp == NULL) {
+    return;
+  }
+
+  while (done != 3 && (size = getline(&line, &size, fp)) != -1) {
+    line[size - 1] = '\0';
+    if (((done&1) == 0) && strncmp(line, "model name", 10) == 0) {
+      const char* v = strchr(line, ':') + 2;
+      addStringField(bw, "cpuModel", v);
+      done |= 1;
+    } else if (((done&2)==0) && strncmp(line, "cpu cores", 9) == 0) {
+      const char* v = strchr(line, ':') + 2;
+      writeString(bw, "numOfCpu");
+      tbufWriteChar(bw, ':');
+      tbufWrite(bw, v, strlen(v));
+      tbufWriteChar(bw, ',');
+      done |= 2;
+    }
+  }
+
+  free(line);
+  fclose(fp);
+}
+
+static void addOsInfo(SBufferWriter* bw) {
+  char * line = NULL;
+  size_t size = 0;
+
+  FILE* fp = fopen("/etc/os-release", "r");
+  if (fp == NULL) {
+    return;
+  }
+
+  while ((size = getline(&line, &size, fp)) != -1) {
+    line[size - 1] = '\0';
+    if (strncmp(line, "PRETTY_NAME", 11) == 0) {
+      const char* p = strchr(line, '=') + 1;
+      if (*p == '"') {
+        p++;
+        line[size - 2] = 0;
+      }
+      addStringField(bw, "os", p);
+      break;
+    }
+  }
+
+  free(line);
+  fclose(fp);
+}
+
+static void addMemoryInfo(SBufferWriter* bw) {
+  char * line = NULL;
+  size_t size = 0;
+
+  FILE* fp = fopen("/proc/meminfo", "r");
+  if (fp == NULL) {
+    return;
+  }
+
+  while ((size = getline(&line, &size, fp)) != -1) {
+    line[size - 1] = '\0';
+    if (strncmp(line, "MemTotal", 8) == 0) {
+      const char* p = strchr(line, ':') + 1;
+      while (*p == ' ') p++;
+      addStringField(bw, "memory", p);
+      break;
+    }
+  }
+
+  free(line);
+  fclose(fp);
+}
+
+static void addVersionInfo(SBufferWriter* bw) {
+  addStringField(bw, "version", version);
+  addStringField(bw, "buildInfo", buildinfo);
+  addStringField(bw, "gitInfo", gitinfo);
+  //addStringField(&bw, "installAt", "2020-08-01T00:00:00Z");
+}
+
+static void addRuntimeInfo(SBufferWriter* bw) {
+  addIntField(bw, "clusterId", mnodeGetClusterId());
+  // addIntField(&bw, "numOfDnode", 1);
+  // addIntField(&bw, "numOfVnode", 1);
+  // addIntField(&bw, "numOfStable", 1);
+  // addIntField(&bw, "numOfTable", 1);
+  // addIntField(&bw, "numOfRows", 1);
+  // addStringField(&bw, "startAt", "2020-08-01T00:00:00Z");
+  // addStringField(&bw, "memoryUsage", "10240 kB");
+  // addStringField(&bw, "diskUsage", "10240 MB");
+}
+
+static void sendTelemetryReport() {
+  char buf[128];
+  uint32_t ip = taosGetIpFromFqdn(TELEMETRY_SERVER);
+  if (ip == 0xffffffff) {
+    dError("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
+    return;
+  }
+  int fd = taosOpenTcpClientSocket(ip, TELEMETRY_PORT, 0);
+  if (fd < 0) {
+    dError("failed to create socket for telemetry, reason:%s", strerror(errno));
+    return;
+  }
+
+  SBufferWriter bw = tbufInitWriter(NULL, false);
+  beginObject(&bw);
+  addIntField(&bw, "reportVersion", 1);
+  addOsInfo(&bw);
+  addCpuInfo(&bw);
+  addMemoryInfo(&bw);
+  addVersionInfo(&bw);
+  addRuntimeInfo(&bw);
+  closeObject(&bw);
+
+  const char* header = "POST /report HTTP/1.1\n"
+    "Host: " TELEMETRY_SERVER "\n"
+    "Content-Type: application/json\n"
+    "Content-Length: ";
+
+  taosWriteSocket(fd, header, strlen(header));
+  int contLen = tbufTell(&bw) - 1;
+  sprintf(buf, "%d\n\n", contLen);
+  taosWriteSocket(fd, buf, strlen(buf));
+  taosWriteSocket(fd, tbufGetData(&bw, false), contLen);
+  tbufCloseWriter(&bw);
+
+  taosReadSocket(fd, buf, 10); // read something to avoid nginx error 499
+  taosCloseSocket(fd);
+}
+
+static void* telemetryThread(void* param) {
+  int timeToWait = 0;
+  while (1) {
+    if (timeToWait <= 0) {
+      if (sdbIsMaster()) {
+        sendTelemetryReport();
+      }
+      timeToWait = REPORT_INTERVAL;
+    }
+
+    int startAt = taosGetTimestampSec();
+    struct timespec timeout = {.tv_sec = timeToWait, .tv_nsec = 0};
+    if (sem_timedwait(&tsExitSem, &timeout) == 0) {
+      break;
+    }
+    timeToWait -= (taosGetTimestampSec() - startAt);
+  }
+
+  return NULL;
+}
+
+int32_t dnodeInitTelemetry() {
+  if (!tsEnableTelemetryReporting) {
+    return 0;
+  }
+
+  if (sem_init(&tsExitSem, 0, 0) == -1) {
+    // just log the error, it is ok for telemetry to fail
+    dError("failed to create semaphore for telemetry, reason:%s", strerror(errno));
+    return 0;
+  }
+
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+  int32_t code = pthread_create(&tsTelemetryThread, &attr, telemetryThread, NULL);
+  pthread_attr_destroy(&attr);
+  if (code != 0) {
+    dError("failed to create telemetry thread, reason:%s", strerror(errno));
+  }
+
+  return 0;
+}
+
+void dnodeCleanupTelemetry() {
+  if (!tsEnableTelemetryReporting) {
+    return;
+  }
+
+  if (tsTelemetryThread) {
+    sem_post(&tsExitSem);
+    pthread_join(tsTelemetryThread, NULL);
+    sem_destroy(&tsExitSem);
+  }
+}
\ No newline at end of file

src/mnode/src/mnodeDb.c

@@ -458,6 +458,7 @@ void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) {
         pDb->vgList[v2] = pDb->vgList[v2 + 1];
       }
       pDb->numOfVgroups--;
+      pDb->vgList[pDb->numOfVgroups] = NULL;
       break;
     }
   }

src/mnode/src/mnodeSdb.c

@@ -487,7 +487,13 @@ static int32_t sdbInsertHash(SSdbTable *pTable, SSdbOper *pOper) {
   sdbDebug("table:%s, insert record:%s to hash, rowSize:%d numOfRows:%" PRId64 ", msg:%p", pTable->tableName,
            sdbGetKeyStrFromObj(pTable, pOper->pObj), pOper->rowSize, pTable->numOfRows, pOper->pMsg);
 
-  (*pTable->insertFp)(pOper);
+  int32_t code = (*pTable->insertFp)(pOper);
+  if (code != TSDB_CODE_SUCCESS) {
+    sdbError("table:%s, failed to insert record:%s to hash, remove it", pTable->tableName,
+             sdbGetKeyStrFromObj(pTable, pOper->pObj));
+    sdbDeleteHash(pTable, pOper);
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 

src/mnode/src/mnodeTable.c

@@ -2351,14 +2351,16 @@ static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) {
 
     // if the vgroup is already dropped from hash, it can't be accquired by pTable->vgId
     // so the refCount of vgroup can not be decreased
-    SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
-    if (pVgroup == NULL) {
-      mnodeRemoveTableFromVgroup(pVgroup, pTable);
-    }
-    mnodeDecVgroupRef(pVgroup);
+    // SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
+    // if (pVgroup == NULL) {
+    //   mnodeRemoveTableFromVgroup(mnodeMsg->pVgroup, pTable);
+    // }
+    // mnodeDecVgroupRef(pVgroup);
 
     mnodeSendDropChildTableMsg(mnodeMsg, false);
     rpcMsg->code = TSDB_CODE_SUCCESS;
+    dnodeSendRpcMnodeWriteRsp(mnodeMsg, rpcMsg->code);
+    return;
   }
 
   if (rpcMsg->code == TSDB_CODE_SUCCESS || rpcMsg->code == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {

src/mnode/src/mnodeVgroup.c

@@ -83,11 +83,12 @@ static int32_t mnodeVgroupActionInsert(SSdbOper *pOper) {
   // refer to db
   SDbObj *pDb = mnodeGetDb(pVgroup->dbName);
   if (pDb == NULL) {
+    mError("vgId:%d, db:%s is not exist while insert into hash", pVgroup->vgId, pVgroup->dbName);
     return TSDB_CODE_MND_INVALID_DB;
   }
   
   if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
+    mError("vgId:%d, db:%s status:%d, in dropping", pVgroup->vgId, pDb->name, pDb->status);
     return TSDB_CODE_MND_DB_IN_DROPPING;
   }
 
@@ -116,10 +117,12 @@ static int32_t mnodeVgroupActionInsert(SSdbOper *pOper) {
 static int32_t mnodeVgroupActionDelete(SSdbOper *pOper) {
   SVgObj *pVgroup = pOper->pObj;
 
-  if (pVgroup->pDb != NULL) {
-    mnodeRemoveVgroupFromDb(pVgroup);
+  if (pVgroup->pDb == NULL) {
+    mError("vgId:%d, db:%s is not exist while insert into hash", pVgroup->vgId, pVgroup->dbName);
+    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
   }
 
+  mnodeRemoveVgroupFromDb(pVgroup);
   mnodeDecDbRef(pVgroup->pDb);
 
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
@@ -446,6 +449,12 @@ int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSi
     }
   }
 
+  if (pDb->numOfVgroups < 1) {
+    mDebug("app:%p:%p, db:%s, failed create new vgroup since:%s, numOfVgroups:%d maxVgroupsPerDb:%d ",
+           pMsg->rpcMsg.ahandle, pMsg, pDb->name, tstrerror(code), pDb->numOfVgroups, maxVgroupsPerDb);
+    return code;
+  }
+
   SVgObj *pVgroup = pDb->vgList[0];
   if (pVgroup == NULL) {
     pthread_mutex_unlock(&pDb->mutex);
@@ -517,6 +526,19 @@ static int32_t mnodeCreateVgroupCb(SMnodeMsg *pMsg, int32_t code) {
 
     dnodeReprocessMnodeWriteMsg(pMsg);
     return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+    // if (pVgroup->status == TAOS_VG_STATUS_CREATING || pVgroup->status == TAOS_VG_STATUS_READY) {
+    //   mInfo("app:%p:%p, vgId:%d, is created in sdb, db:%s replica:%d", pMsg->rpcMsg.ahandle, pMsg, pVgroup->vgId,
+    //         pDb->name, pVgroup->numOfVnodes);
+    //   pVgroup->status = TAOS_VG_STATUS_READY;
+    //   SSdbOper desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .table = tsVgroupSdb};
+    //   (void)sdbUpdateRow(&desc);
+    //   dnodeReprocessMnodeWriteMsg(pMsg);
+    //   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+    // } else {
+    //   mError("app:%p:%p, vgId:%d, is created in sdb, db:%s replica:%d, but vgroup is dropping", pMsg->rpcMsg.ahandle,
+    //          pMsg, pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
+    //   return TSDB_CODE_MND_VGROUP_NOT_EXIST;
+    // }
   }
 }
 
@@ -955,7 +977,7 @@ void mnodeSendDropVnodeMsg(int32_t vgId, SRpcEpSet *epSet, void *ahandle) {
 
 static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) {
   pVgroup->status = TAOS_VG_STATUS_DROPPING; // deleting
-  mDebug("vgId:%d, send drop all vnodes msg, ahandle:%p", pVgroup->vgId, ahandle);
+  mDebug("vgId:%d, send drop all vnodes msg, ahandle:%p db:%s", pVgroup->vgId, ahandle, pVgroup->dbName);
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
     SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
     mDebug("vgId:%d, send drop vnode msg to dnode:%d, ahandle:%p", pVgroup->vgId, pVgroup->vnodeGid[i].dnodeId, ahandle);
@@ -1117,6 +1139,7 @@ void mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb) {
     }
 
     mnodeDecVgroupRef(pVgroup);
+    numOfVgroups++;
   }
 
   sdbFreeIter(pIter);

src/util/src/tqueue.c

@@ -61,6 +61,7 @@ taos_queue taosOpenQueue() {
 
   pthread_mutex_init(&queue->mutex, NULL);
 
+  uTrace("queue:%p is openned", queue);
   return queue;
 }
 
@@ -89,6 +90,8 @@ void taosCloseQueue(taos_queue param) {
   pthread_mutex_unlock(&queue->mutex);
   pthread_mutex_destroy(&queue->mutex);
   free(queue);
+
+  uTrace("queue:%p is closed", queue);
 }
 
 void *taosAllocateQitem(int size) {
@@ -161,7 +164,7 @@ int taosReadQitem(taos_queue param, int *type, void **pitem) {
 }
 
 void *taosAllocateQall() {
-  void *p = malloc(sizeof(STaosQall));
+  void *p = calloc(sizeof(STaosQall), 1);
   return p;
 }
 
@@ -230,15 +233,31 @@ taos_qset taosOpenQset() {
   pthread_mutex_init(&qset->mutex, NULL);
   tsem_init(&qset->sem, 0, 0);
 
+  uTrace("qset:%p is openned", qset);
   return qset;
 }
 
 void taosCloseQset(taos_qset param) {
   if (param == NULL) return;
   STaosQset *qset = (STaosQset *)param;
+
+#if 0
+  // remove all the queues from qset
+  pthread_mutex_lock(&qset->mutex);
+  while (qset->head) {
+    STaosQueue *queue = qset->head;
+    qset->head = qset->head->next;
+
+    queue->qset = NULL;
+    queue->next = NULL;
+  }
+  pthread_mutex_unlock(&qset->mutex);
+#endif  
+
   pthread_mutex_destroy(&qset->mutex);
   tsem_destroy(&qset->sem);
   free(qset);
+  uTrace("qset:%p is closed", qset);
 }
 
 // tsem_post 'qset->sem', so that reader threads waiting for it
@@ -269,6 +288,7 @@ int taosAddIntoQset(taos_qset p1, taos_queue p2, void *ahandle) {
 
   pthread_mutex_unlock(&qset->mutex);
 
+  uTrace("queue:%p is added into qset:%p", queue, qset);
   return 0;
 }
 
@@ -288,6 +308,7 @@ void taosRemoveFromQset(taos_qset p1, taos_queue p2) {
       STaosQueue *prev = qset->head;
       tqueue = qset->head->next;
       while (tqueue) {
+        assert(tqueue->qset);
         if (tqueue== queue) {
           prev->next = tqueue->next;
           break;
@@ -305,11 +326,14 @@ void taosRemoveFromQset(taos_qset p1, taos_queue p2) {
       pthread_mutex_lock(&queue->mutex);
       atomic_sub_fetch_32(&qset->numOfItems, queue->numOfItems);
       queue->qset = NULL;
+      queue->next = NULL;
       pthread_mutex_unlock(&queue->mutex);
     }
   } 
   
   pthread_mutex_unlock(&qset->mutex);
+
+  uTrace("queue:%p is removed from qset:%p", queue, qset);
 }
 
 int taosGetQueueNumber(taos_qset param) {

tests/comparisonTest/opentsdb/opentsdbtest/pom.xml

@@ -206,16 +206,6 @@
       <artifactId>slf4j-api</artifactId>
       <version>1.7.25</version>
     </dependency>
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-log4j12</artifactId>
-      <version>1.7.21</version>
-    </dependency>
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>log4j-over-slf4j</artifactId>
-      <version>1.7.7</version>
-    </dependency>
 
     <dependency> 
       <groupId>org.apache.logging.log4j</groupId>

tests/comparisonTest/opentsdb/opentsdbtest/src/main/java/com/opentsdb/test/OpentsdbTest.java

 import com.stumbleupon.async.Callback;
 import com.stumbleupon.async.Deferred;
-import lombok.extern.slf4j.Slf4j;
 
 import net.opentsdb.core.TSDB;
 import net.opentsdb.uid.NoSuchUniqueName;
@@ -40,13 +39,19 @@ import java.util.concurrent.*;
 import java.math.*;
 import java.lang.reflect.Method;
 
+import org.apache.log4j.Logger;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Level;
 
-public class OpentsdbTest{
 
+public class OpentsdbTest{
   //static { System.setProperty("logback.configurationFile", "/home/ubuntu/fang/opentsdb/opentsdbtest/logback.xml");}
   static { System.setProperty("logback.configurationFile", "/etc/opentsdb/logback.xml");}
 
   public static void main(String args[]) {  
+
+    Logger logger = LogManager.getLogger(OpentsdbTest.class);
+    logger.setLevel(Level.OFF);
     // begin to parse argument
     String datadir = "/home/ubuntu/testdata";
     String sqlchoice  = "q1";
@@ -156,7 +161,7 @@ public class OpentsdbTest{
           }
           switch (sqlchoice) {
             case "q1":
-              get_url = "http://192.168.1.114:4242/api/query?";
+              get_url = "http://127.0.0.1:4242/api/query?";
               /*
               get_url = get_url + "start=1563249700&m=none:temperature{devgroup=";
               get_url = get_url + String.valueOf(ig-10) +"}";

tests/comparisonTest/opentsdb/opentsdbtest/src/main/java/com/opentsdb/test/WriteThread.java

 import com.stumbleupon.async.Callback;
 import com.stumbleupon.async.Deferred;
-import lombok.extern.slf4j.Slf4j;
 
 import net.opentsdb.core.TSDB;
 import net.opentsdb.uid.NoSuchUniqueName;
@@ -64,7 +63,7 @@ public class WriteThread extends Thread {
   public void run() { 
     StringEntity stringEntity;
     String port = "4242";
-    String put_url = "http://192.168.1.114:"+port+"/api/put?summary";
+    String put_url = "http://127.0.0.1:"+port+"/api/put?summary";
     try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
       /*
       httpclient.getHttpConnectionManager().getParams()
@@ -152,4 +151,4 @@ public class WriteThread extends Thread {
         System.out.println("failed to connect");
     }
   }//end run
-}//end class
\ No newline at end of file
+}//end class

tests/perftest-scripts/cassandraTestWriteLoop.sh

@@ -17,7 +17,7 @@ function runTest {
 
   for r in ${!rowsPerRequest[@]}; do
     for c in `seq 1 $clients`; do
-      avgRPR[$r, $c]=0
+      avgRPR[$r,$c]=0
     done
   done
 
@@ -46,7 +46,6 @@ function runTest {
       avgRPR[$r,$c]=`echo "scale=4; $totalRPR / $NUM_LOOP" | bc`
       printTo "r:$r c:$c avgRPR:${avgRPR[$r,$c]}"
     done
-
   done
 
   printf "R/R, "
@@ -79,9 +78,14 @@ while : ; do
       verbose=true
       shift ;;
 
+    -n)
+      NUM_LOOP=$2
+      shift 2;;
+
     -c)
       clients=$2
       shift 2;;
+
     *)
       break ;;
   esac

tests/perftest-scripts/opentsdbTestWriteLoop.sh

+#!/bin/bash
+
+DATA_DIR=/mnt/root/testdata
+NUM_LOOP=1
+NUM_OF_FILES=100
+
+rowsPerRequest=(1 10 50 100 500 1000 2000)
+
+function printTo {
+  if $verbose ; then
+    echo $1
+  fi
+}
+
+function runTest {
+  declare -A avgRPR
+
+  for r in ${!rowsPerRequest[@]}; do
+    for c in `seq 1 $clients`; do
+      avgRPR[$r, $c]=0
+    done
+  done
+
+  for r in ${!rowsPerRequest[@]}; do
+    for c in `seq 1 $clients`; do
+      totalRPR=0
+      OUT_FILE=opentsdbWrite-rows${rowsPerRequest[$r]}-clients$c.out
+      for i in `seq 1 $NUM_LOOP`; do
+        printTo "loop i:$i java -jar \
+          $TSDBTEST_DIR/opentsdbtest/target/opentsdbtest-1.0-SNAPSHOT-jar-with-dependencies.jar \
+          -dataDir $DATA_DIR \
+          -numOfFiles $NUM_OF_FILES \
+          -writeClients $c \
+          -rowsPerRequest $r"
+        java -jar \
+          $TSDBTEST_DIR/opentsdbtest/target/opentsdbtest-1.0-SNAPSHOT-jar-with-dependencies.jar \
+          -dataDir $DATA_DIR \
+          -numOfFiles $NUM_OF_FILES \
+          -writeClients $c \
+          -rowsPerRequest ${rowsPerRequest[$r]} \
+          2>&1 | tee $OUT_FILE
+        RPR=`cat $OUT_FILE | grep speed | awk '{print $(NF-1)}'`
+        totalRPR=`echo "scale=4; $totalRPR + $RPR" | bc`
+        printTo "r:$r rows:${rowsPerRequest[$r]}, clients:$c, i:$i RPR:$RPR"
+      done
+      avgRPR[$r,$c]=`echo "scale=4; $totalRPR / $NUM_LOOP" | bc`
+      printTo "r:$r c:$c avgRPR:${avgRPR[$r, $c]}"
+    done
+  done
+
+  printf "R/R, "
+  for c in `seq 1 $clients`; do
+    if [ "$c" == "1" ]; then
+      printf "$c client, "
+    else
+      printf "$c clients, "
+    fi
+  done
+  printf "\n"
+
+  for r in ${!rowsPerRequest[@]}; do
+    printf "${rowsPerRequest[$r]}, "
+    for c in `seq 1 $clients`; do
+      printf "${avgRPR[$r,$c]}, "
+    done
+    printf "\n"
+  done
+}
+
+################ Main ################
+
+verbose=false
+clients=1
+
+while : ; do
+  case $1 in
+    -v)
+      verbose=true
+      shift ;;
+
+    -n)
+      NUM_LOOP=$2
+      shift 2;;
+
+    -c)
+      clients=$2
+      shift 2;;
+
+    *)
+      break ;;
+  esac
+done
+
+WORK_DIR=/mnt/root/TDengine
+TSDBTEST_DIR=$WORK_DIR/tests/comparisonTest/opentsdb
+
+runTest
+
+printTo "Test done!"

tests/perftest-scripts/tdengineTestWriteLoop.sh

 #!/bin/bash
 
 DATA_DIR=/mnt/root/testdata
-NUM_LOOP=5
+NUM_LOOP=1
 NUM_OF_FILES=100
 
 rowsPerRequest=(1 100 500 1000 2000)
@@ -37,7 +37,7 @@ function runTest {
 	      -rowsPerRequest $r"
         RPR=`$TDTEST_DIR/tdengineTest \
           -dataDir $DATA_DIR \
-          -numOfFiles 1 \
+          -numOfFiles $NUM_OF_FILES \
           -w -clients $c \
           -rowsPerRequest $r \
           | grep speed | awk '{print $(NF-1)}'`
@@ -80,6 +80,10 @@ while : ; do
       verbose=true
       shift ;;
 
+    -n)
+      NUM_LOOP=$2
+      shift 2;;
+
     master)
       master=true
       develop=false
@@ -93,18 +97,19 @@ while : ; do
     -c)
       clients=$2
       shift 2;;
+
     *)
       break ;;
   esac
 done
 
 if $master ; then
-  echo "Test master branch.."
+  printTo "Test master branch.."
   cp /mnt/root/cfg/master/taos.cfg /etc/taos/taos.cfg
   WORK_DIR=/mnt/root/TDengine.master
 else
-  echo "Test develop branch.."
-  cp /mnt/root/cfg/10billion/taos.cfg /etc/taos/taos.cfg
+  printTo "Test develop branch.."
+  cp /mnt/root/cfg/perftest/taos.cfg /etc/taos/taos.cfg
   WORK_DIR=/mnt/root/TDengine
 fi
 
@@ -113,4 +118,4 @@ TDTEST_DIR=$WORK_DIR/tests/comparisonTest/tdengine
 
 runTest
 
-echo "Test done!"
+printTo "Test done!"

tests/pytest/crash_gen.py

@@ -238,7 +238,7 @@ class WorkerThread:
 
 
 class ThreadCoordinator:
-    WORKER_THREAD_TIMEOUT = 30
+    WORKER_THREAD_TIMEOUT = 60 # one minute
 
     def __init__(self, pool: ThreadPool, dbManager):
         self._curStep = -1  # first step is 0
@@ -388,7 +388,9 @@ class ThreadCoordinator:
             except taos.error.ProgrammingError as err:
                 transitionFailed = True
                 errno2 = err.errno if (err.errno > 0) else 0x80000000 + err.errno  # correct error scheme
-                logger.info("Transition failed: errno=0x{:X}, msg: {}".format(errno2, err))
+                errMsg = "Transition failed: errno=0x{:X}, msg: {}".format(errno2, err)
+                logger.info(errMsg)
+                self._execStats.registerFailure(errMsg)
 
             # Then we move on to the next step
             self._releaseAllWorkerThreads(transitionFailed)                    
@@ -812,7 +814,7 @@ class DbConnNative(DbConn):
                     buildPath = root[:len(root) - len("/build/bin")]
                     break
         if buildPath == None:
-            raise RuntimeError("Failed to determine buildPath, selfPath={}".format(self_path))
+            raise RuntimeError("Failed to determine buildPath, selfPath={}".format(selfPath))
         return buildPath
 
     
@@ -2292,6 +2294,12 @@ class ServiceManagerThread:
         self._thread.daemon = True  # thread dies with the program
         self._thread.start()
 
+        self._thread2 = threading.Thread(
+            target=self.svcErrorReader,
+            args=(self._tdeSubProcess.getStdErr(), self._ipcQueue))
+        self._thread2.daemon = True  # thread dies with the program
+        self._thread2.start()
+
         # wait for service to start
         for i in range(0, 10):
             time.sleep(1.0)
@@ -2320,12 +2328,12 @@ class ServiceManagerThread:
             raise RuntimeError("sub process object missing")
 
         self._status = MainExec.STATUS_STOPPING
-        self._tdeSubProcess.stop()
+        retCode = self._tdeSubProcess.stop()
+        print("Attempted to stop sub process, got return code: {}".format(retCode))
 
         if self._tdeSubProcess.isRunning():  # still running
-            print(
-                "FAILED to stop sub process, it is still running... pid = {}".format(
-                    self.subProcess.pid))
+            print("FAILED to stop sub process, it is still running... pid = {}".format(
+                    self._tdeSubProcess.getPid()))
         else:
             self._tdeSubProcess = None  # not running any more
             self.join()  # stop the thread, change the status, etc.
@@ -2341,6 +2349,9 @@ class ServiceManagerThread:
             self._thread.join()
             self._thread = None
             self._status = MainExec.STATUS_STOPPED
+            # STD ERR thread
+            self._thread2.join()
+            self._thread2 = None
         else:
             print("Joining empty thread, doing nothing")
 
@@ -2421,6 +2432,10 @@ class ServiceManagerThread:
         print("\nNo more output from IO thread managing TDengine service")
         out.close()
 
+    def svcErrorReader(self, err: IO, queue):
+        for line in iter(err.readline, b''):
+            print("\nTD Svc STDERR: {}".format(line))
+
 
 class TdeSubProcess:
     def __init__(self):
@@ -2429,9 +2444,15 @@ class TdeSubProcess:
     def getStdOut(self):
         return self.subProcess.stdout
 
+    def getStdErr(self):
+        return self.subProcess.stderr
+
     def isRunning(self):
         return self.subProcess is not None
 
+    def getPid(self):
+        return self.subProcess.pid
+
     def getBuildPath(self):
         selfPath = os.path.dirname(os.path.realpath(__file__))
         if ("community" in selfPath):
@@ -2467,24 +2488,28 @@ class TdeSubProcess:
             os.rename(logPath, logPathSaved)
         # os.mkdir(logPath) # recreate, no need actually, TDengine will auto-create with proper perms
             
-
         svcCmd = [taosdPath, '-c', cfgPath]
+        # svcCmdSingle = "{} -c {}".format(taosdPath, cfgPath)
         # svcCmd = ['vmstat', '1']
         if self.subProcess:  # already there
             raise RuntimeError("Corrupt process state")
 
+        # print("Starting service: {}".format(svcCmd))
         self.subProcess = subprocess.Popen(
-            svcCmd,
+            svcCmd, shell=False,
+            # svcCmdSingle, shell=True, # capture core dump?
             stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
             # bufsize=1, # not supported in binary mode
-            close_fds=ON_POSIX)  # had text=True, which interferred with reading EOF
+            close_fds=ON_POSIX
+            )  # had text=True, which interferred with reading EOF
 
     def stop(self):
         if not self.subProcess:
             print("Sub process already stopped")
-            return
+            return -1
 
-        retCode = self.subProcess.poll()
+        retCode = self.subProcess.poll() # contains real sub process return code
         if retCode:  # valid return code, process ended
             self.subProcess = None
         else:  # process still alive, let's interrupt it
@@ -2495,11 +2520,15 @@ class TdeSubProcess:
             self.subProcess.send_signal(signal.SIGINT)
             try:
                 self.subProcess.wait(10)
+                retCode = self.subProcess.returncode
             except subprocess.TimeoutExpired as err:
                 print("Time out waiting for TDengine service process to exit")
+                retCode = -3
             else:
                 print("TDengine service process terminated successfully from SIG_INT")
+                retCode = -4
                 self.subProcess = None
+        return retCode
 
 class ThreadStacks: # stack info for all threads
     def __init__(self):