Merge branch 'develop' into feature/TD-6117

Jenkinsfile

@@ -235,11 +235,18 @@ pipeline {
               npm install td2.0-connector > /dev/null 2>&1
               node nodejsChecker.js host=localhost
               node test1970.js
+	      cd ${WKC}/tests/connectorTest/nodejsTest/nanosupport
+	      npm install td2.0-connector > /dev/null 2>&1
+              node nanosecondTest.js
+
               '''
               sh '''
                 cd ${WKC}/tests/examples/C#/taosdemo
                 mcs -out:taosdemo *.cs > /dev/null 2>&1
-                echo '' |./taosdemo
+                echo '' |./taosdemo -c /etc/taos
+                cd ${WKC}/tests/connectorTest/C#Test/nanosupport
+                mcs -out:nano *.cs > /dev/null 2>&1
+                echo '' |./nano
               '''
               sh '''
                 cd ${WKC}/tests/gotest

cmake/define.inc

@@ -133,8 +133,10 @@ IF (TD_LINUX)
 
   IF (TD_MEMORY_SANITIZER)
     SET(DEBUG_FLAGS "-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -O0 -g3 -DDEBUG")
+    MESSAGE(STATUS "memory sanitizer detected as true")
   ELSE ()
     SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
+    MESSAGE(STATUS "memory sanitizer detected as false")
   ENDIF ()
   SET(RELEASE_FLAGS "-O3 -Wno-error")
 

cmake/version.inc

@@ -86,7 +86,7 @@ ENDIF ()
 MESSAGE(STATUS "============= compile version parameter information start ============= ")
 MESSAGE(STATUS "ver number:" ${TD_VER_NUMBER})
 MESSAGE(STATUS "compatible ver number:" ${TD_VER_COMPATIBLE})
-MESSAGE(STATUS "communit commit id:" ${TD_VER_GIT})
+MESSAGE(STATUS "community commit id:" ${TD_VER_GIT})
 MESSAGE(STATUS "internal commit id:" ${TD_VER_GIT_INTERNAL})
 MESSAGE(STATUS "build date:" ${TD_VER_DATE})
 MESSAGE(STATUS "ver type:" ${TD_VER_VERTYPE})

documentation20/cn/04.model/docs.md

@@ -43,7 +43,7 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
 
 每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。一张超级表里包含的采集物理量必须是同时采集的（时间戳是一致的）。
 
-一张超级表最多容许1024列，如果一个采集点采集的物理量个数超过1024，需要建多张超级表来处理。一个系统可以有多个DB，一个DB里可以有一到多个超级表。
+一张超级表最多容许 1024 列，如果一个采集点采集的物理量个数超过 1024，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。（从 2.1.7.0 版本开始，列数限制由 1024 列放宽到了 4096 列。）
 
 ## <a class="anchor" id="create-table"></a>创建表
 

documentation20/cn/10.cluster/docs.md

@@ -119,9 +119,14 @@ taos>
 
 上面已经介绍如何从零开始搭建集群。集群组建完后，还可以随时添加新的数据节点进行扩容，或删除数据节点，并检查集群当前状态。
 
+
+**提示：**
+
+- 以下所有执行命令的操作需要先登陆进TDengine系统，必要时请使用root权限。
+
 ### 添加数据节点
 
-执行CLI程序taos，使用root账号登录进系统，执行：
+执行CLI程序taos，执行：
 
 ```
 CREATE DNODE "fqdn:port"; 
@@ -131,7 +136,7 @@ CREATE DNODE "fqdn:port";
 
 ### 删除数据节点
 
-执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，执行：
 
 ```mysql
 DROP DNODE "fqdn:port | dnodeID";
@@ -153,7 +158,7 @@ DROP DNODE "fqdn:port | dnodeID";
 
 手动将某个vnode迁移到指定的dnode。
 
-执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，执行：
 
 ```mysql
 ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
@@ -169,7 +174,7 @@ ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
 
 ### 查看数据节点
 
-执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，执行：
 ```mysql
 SHOW DNODES;
 ```
@@ -180,8 +185,9 @@ SHOW DNODES;
 
 为充分利用多核技术，并提供scalability，数据需要分片处理。因此TDengine会将一个DB的数据切分成多份，存放在多个vnode里。这些vnode可能分布在多个数据节点dnode里，这样就实现了水平扩展。一个vnode仅仅属于一个DB，但一个DB可以有多个vnode。vnode的是mnode根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
 
-执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，执行：
 ```mysql
+USE SOME_DATABASE;
 SHOW VGROUPS;
 ```
 

documentation20/cn/11.administrator/docs.md

@@ -652,7 +652,7 @@ rmtaos
 - 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字符，每行数据最大长度 16k 个字符
 - 表的列名：不能包含特殊字符，不能超过 64 个字符
 - 数据库名、表名、列名，都不能以数字开头，合法的可用字符集是“英文字符、数字和下划线”
-- 表的列数：不能超过 1024 列，最少需要 2 列，第一列必须是时间戳
+- 表的列数：不能超过 1024 列，最少需要 2 列，第一列必须是时间戳（从 2.1.7.0 版本开始，改为最多支持 4096 列）
 - 记录的最大长度：包括时间戳 8 byte，不能超过 16KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 byte 的存储位置）
 - 单条 SQL 语句默认最大字符串长度：65480 byte，但可通过系统配置参数 maxSQLLength 修改，最长可配置为 1048576 byte
 - 数据库副本数：不能超过 3
@@ -665,7 +665,7 @@ rmtaos
 - 库的个数：仅受节点个数限制
 - 单个库上虚拟节点个数：不能超过 64 个
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
-- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。
+- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。（从 2.1.7.0 版本开始，改为最多允许 4096 列）
 
 目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下：
 

documentation20/cn/12.taos-sql/docs.md

@@ -233,7 +233,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
     ```
     说明：
 
-    1) 列的最大个数为1024，最小个数为2；
+    1) 列的最大个数为1024，最小个数为2；（从 2.1.7.0 版本开始，改为最多允许 4096 列）
 
     2) 列名最大长度为64。
 
@@ -1064,7 +1064,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     ```mysql
     SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
-    功能说明：统计表/超级表中某列的值最后写入的非NULL值。
+    功能说明：统计表/超级表中某列的值最后写入的非 NULL 值。
 
     返回结果数据类型：同应用的字段。
 
@@ -1074,9 +1074,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     说明：
 
-    1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；
+    1）如果要返回各个列的最后（时间戳最大）一个非 NULL 值，可以使用 LAST(\*)；
 
-    2）如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；如果结果集中所有列全部为NULL值，则不返回结果。
+    2）如果结果集中的某列全部为 NULL 值，则该列的返回结果也是 NULL；如果结果集中所有列全部为 NULL 值，则不返回结果。
+
+    3）在用于超级表时，时间戳完全一样且同为最大的数据行可能有多个，那么会从中随机返回一条，而并不保证多次运行所挑选的数据行必然一致。
 
     示例：
     ```mysql
@@ -1225,7 +1227,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     适用于：**表、超级表**。
 
-    限制：LAST_ROW()不能与INTERVAL一起使用。
+    限制：LAST_ROW() 不能与 INTERVAL 一起使用。
+
+    说明：在用于超级表时，时间戳完全一样且同为最大的数据行可能有多个，那么会从中随机返回一条，而并不保证多次运行所挑选的数据行必然一致。
 
     示例：
     ```mysql
@@ -1454,10 +1458,10 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P
 
 - 数据库名最大长度为 32。
 - 表名最大长度为 192，每行数据最大长度 16k 个字符（注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）。
-- 列名最大长度为 64，最多允许 1024 列，最少需要 2 列，第一列必须是时间戳。
+- 列名最大长度为 64，最多允许 1024 列，最少需要 2 列，第一列必须是时间戳。（从 2.1.7.0 版本开始，改为最多允许 4096 列）
 - 标签名最大长度为 64，最多允许 128 个，可以 1 个，一个表中标签值的总长度不超过 16k 个字符。
 - SQL 语句最大长度 65480 个字符，但可通过系统配置参数 maxSQLLength 修改，最长可配置为 1M。
-- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。
+- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。（从 2.1.7.0 版本开始，改为最多允许 4096 列）
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制。
 
 ## TAOS SQL 其他约定

documentation20/cn/13.faq/docs.md

@@ -98,7 +98,7 @@ TDengine 目前尚不支持删除功能，未来根据用户需求可能会支
 
 ## 10. 我怎么创建超过1024列的表？
 
-使用2.0及其以上版本，默认支持1024列；2.0之前的版本，TDengine最大允许创建250列的表。但是如果确实超过限值，建议按照数据特性，逻辑地将这个宽表分解成几个小表。
+使用 2.0 及其以上版本，默认支持 1024 列；2.0 之前的版本，TDengine 最大允许创建 250 列的表。但是如果确实超过限值，建议按照数据特性，逻辑地将这个宽表分解成几个小表。（从 2.1.7.0 版本开始，表的最大列数增加到了 4096 列。）
 
 ## 11. 最有效的写入数据的方法是什么？
 

documentation20/en/00.index/docs.md

 # TDengine Documentation
 
-TDengine is a highly efficient platform to store, query, and analyze time-series data. It is specially designed and optimized for IoT, Internet of Vehicles, Industrial IoT, IT Infrastructure and Application Monitoring, etc. It works like a relational database, such as MySQL, but you are strongly encouraged to read through the following documentation before you experience it, especially the Data Model and Data Modeling sections. In addition to this document, you should also download and read our technology white paper. For the older TDengine version 1.6 documentation, please click here.
+TDengine is a highly efficient platform to store, query, and analyze time-series data. It is specially designed and optimized for IoT, Internet of Vehicles, Industrial IoT, IT Infrastructure and Application Monitoring, etc. It works like a relational database, such as MySQL, but you are strongly encouraged to read through the following documentation before you experience it, especially the Data Modeling sections. In addition to this document, you should also download and read the technology white paper. For the older TDengine version 1.6 documentation, please click [here](https://www.taosdata.com/en/documentation16/).
 
 ## [TDengine Introduction](/evaluation)
 
@@ -10,28 +10,41 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 
 ## [Getting Started](/getting-started)
 
-* [Quickly Install](/getting-started#install): install via source code/package / Docker within seconds
-
-- [Easy to Launch](/getting-started#start): start / stop TDengine with systemctl
-- [Command-line](/getting-started#console) : an easy way to access TDengine server
-- [Experience Lightning Speed](/getting-started#demo): running a demo, inserting/querying data to experience faster speed
-- [List of Supported Platforms](/getting-started#platforms): a list of platforms supported by TDengine server and client
-- [Deploy to Kubernetes](https://taosdata.github.io/TDengine-Operator/en/index.html)：a detailed guide for TDengine deployment in Kubernetes environment
+* [Quick Install](/getting-started#install): install via source code/package / Docker within seconds
+* [Quick Launch](/getting-started#start): start / stop TDengine quickly with systemctl
+* [Command-line](/getting-started#console) : an easy way to access TDengine server
+* [Experience Lightning Speed](/getting-started#demo): running a demo, inserting/querying data to experience faster speed
+* [List of Supported Platforms](/getting-started#platforms): a list of platforms supported by TDengine server and client
+* [Deploy to Kubernetes](https://taosdata.github.io/TDengine-Operator/en/index.html)：a detailed guide for TDengine deployment in Kubernetes environment
 
 ## [Overall Architecture](/architecture)
 
-- [Data Model](/architecture#model): relational database model, but one table for one device with static tags
-- [Cluster and Primary Logical Unit](/architecture#cluster): Take advantage of NoSQL, support scale-out and high-reliability
-- [Storage Model and Data Partitioning/Sharding](/architecture#sharding): tag data will be separated from time-series data, segmented by vnode and time
-- [Data Writing and Replication Process](/architecture#replication): records received are written to WAL, cached, with acknowledgement is sent back to client, while supporting multi-replicas
+- [Data Model](/architecture#model): relational database model, but one table for one data collection point with static tags
+- [Cluster and Primary Logical Unit](/architecture#cluster): Take advantage of NoSQL architecture, high availability and horizontal scalability
+- [Storage Model and Data Partitioning/Sharding](/architecture#sharding): tag data is separated from time-series data, sharded by vnodes and partitioned by time 
+- [Data Writing and Replication Process](/architecture#replication): records received are written to WAL, cached, with acknowledgement sent back to client, while supporting data replications
 - [Caching and Persistence](/architecture#persistence): latest records are cached in memory, but are written in columnar format with an ultra-high compression ratio
-- [Data Query](/architecture#query): support various functions, time-axis aggregation, interpolation, and multi-table aggregation
+- [Data Query](/architecture#query): support various SQL functions, downsampling, interpolation, and multi-table aggregation
 
 ## [Data Modeling](/model)
 
-- [Create a Database](/model#create-db): create a database for all data collection points with similar features
+- [Create a Database](/model#create-db): create a database for all data collection points with similar data characteristics
 - [Create a Super Table(STable)](/model#create-stable): create a STable for all data collection points with the same type
-- [Create a Table](/model#create-table): use STable as the template, to create a table for each data collecting point
+- [Create a Table](/model#create-table): use STable as the template to create a table for each data collecting point
+
+## [Efficient Data Ingestion](/insert)
+
+- [Data Writing via SQL](/insert#sql): write one or multiple records into one or multiple tables via SQL insert command
+- [Data Writing via Prometheus](/insert#prometheus): Configure Prometheus to write data directly without any code
+- [Data Writing via Telegraf](/insert#telegraf): Configure Telegraf to write collected data directly without any code
+- [Data Writing via EMQ X](/insert#emq): Configure EMQ X to write MQTT data directly without any code
+- [Data Writing via HiveMQ Broker](/insert#hivemq): Configure HiveMQ to write MQTT data directly without any code
+
+## [Efficient Data Querying](/queries)
+
+- [Major Features](/queries#queries): support various standard query functions, setting filter conditions, and querying per time segment
+- [Multi-table Aggregation](/queries#aggregation): use STable and set tag filter conditions to perform efficient aggregation
+- [Downsampling](/queries#sampling): aggregate data in successive time windows, support interpolation
 
 ## [TAOS SQL](/taos-sql)
 
@@ -40,27 +53,13 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 - [Table Management](/taos-sql#table): add, drop, check, alter tables
 - [STable Management](/taos-sql#super-table): add, drop, check, alter STables
 - [Tag Management](/taos-sql#tags): add, drop, alter tags
-- [Inserting Records](/taos-sql#insert): support to write single/multiple items per table, multiple items across tables, and support to write historical data
+- [Inserting Records](/taos-sql#insert): write single/multiple records a table, multiple records across tables, and historical data
 - [Data Query](/taos-sql#select): support time segment, value filtering, sorting, manual paging of query results, etc
 - [SQL Function](/taos-sql#functions): support various aggregation functions, selection functions, and calculation functions, such as avg, min, diff, etc
-- [Time Dimensions Aggregation](/taos-sql#aggregation): aggregate and reduce the dimension after cutting table data by time segment
+- [Cutting and Aggregation](/taos-sql#aggregation): aggregate and reduce the dimension after cutting table data by time segment
 - [Boundary Restrictions](/taos-sql#limitation): restrictions for the library, table, SQL, and others
 - [Error Code](/taos-sql/error-code): TDengine 2.0 error codes and corresponding decimal codes
 
-## [Efficient Data Ingestion](/insert)
-
-- [SQL Ingestion](/insert#sql): write one or multiple records into one or multiple tables via SQL insert command
-- [Prometheus Ingestion](/insert#prometheus): Configure Prometheus to write data directly without any code
-- [Telegraf Ingestion](/insert#telegraf): Configure Telegraf to write collected data directly without any code
-- [EMQ X Broker](/insert#emq): Configure EMQ X to write MQTT data directly without any code
-- [HiveMQ Broker](/insert#hivemq): Configure HiveMQ to write MQTT data directly without any code
-
-## [Efficient Data Querying](/queries)
-
-- [Main Query Features](/queries#queries): support various standard functions, setting filter conditions, and querying per time segment
-- [Multi-table Aggregation Query](/queries#aggregation): use STable and set tag filter conditions to perform efficient aggregation queries
-- [Downsampling to Query Value](/queries#sampling): aggregate data in successive time windows, support interpolation
-
 ## [Advanced Features](/advanced-features)
 
 - [Continuous Query](/advanced-features#continuous-query): Based on sliding windows, the data stream is automatically queried and calculated at regular intervals
@@ -88,12 +87,12 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 
 ## [Installation and Management of TDengine Cluster](/cluster)
 
-- [Preparation](/cluster#prepare): important considerations before deploying TDengine for production usage
-- [Create Your First Node](/cluster#node-one): simple to follow the quick setup
+- [Preparation](/cluster#prepare): important steps before deploying TDengine for production usage
+- [Create the First Node](/cluster#node-one): just follow the steps in quick start 
 - [Create Subsequent Nodes](/cluster#node-other): configure taos.cfg for new nodes to add more to the existing cluster
 - [Node Management](/cluster#management): add, delete, and check nodes in the cluster
-- [High-availability of Vnode](/cluster#high-availability): implement high-availability of Vnode through multi-replicas
-- [Mnode Management](/cluster#mnode): automatic system creation without any manual intervention
+- [High-availability of Vnode](/cluster#high-availability): implement high-availability of Vnode through replicas
+- [Mnode Management](/cluster#mnode): mnodes are created automatically without any manual intervention
 - [Load Balancing](/cluster#load-balancing): automatically performed once the number of nodes or load changes
 - [Offline Node Processing](/cluster#offline): any node that offline for more than a certain period will be removed from the cluster
 - [Arbitrator](/cluster#arbitrator): used in the case of an even number of replicas to prevent split-brain
@@ -108,27 +107,14 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 - [Export Data](/administrator#export): export data either from TDengine shell or from the taosdump tool
 - [System Monitor](/administrator#status): monitor the system connections, queries, streaming calculation, logs, and events
 - [File Directory Structure](/administrator#directories): directories where TDengine data files and configuration files located
-- [Parameter Restrictions and Reserved Keywords](/administrator#keywords): TDengine’s list of parameter restrictions and reserved keywords
-
-## TDengine Technical Design
-
-- [System Module]: taosd functions and modules partitioning
-- [Data Replication]: support real-time synchronous/asynchronous replication, to ensure high-availability of the system
-- [Technical Blog](https://www.taosdata.com/cn/blog/?categories=3): More technical analysis and architecture design articles
-
-## Common Tools
-
-- [TDengine sample import tools](https://www.taosdata.com/blog/2020/01/18/1166.html)
-- [TDengine performance comparison test tools](https://www.taosdata.com/blog/2020/01/18/1166.html)
-- [Use TDengine visually through IDEA Database Management Tool](https://www.taosdata.com/blog/2020/08/27/1767.html)
+- [Parameter Limitss and Reserved Keywords](/administrator#keywords): TDengine’s list of parameter limits and reserved keywords
 
 ## Performance: TDengine vs Others
 
-- [Performance: TDengine vs InfluxDB with InfluxDB’s open-source performance testing tool](https://www.taosdata.com/blog/2020/01/13/1105.html)
-- [Performance: TDengine vs OpenTSDB](https://www.taosdata.com/blog/2019/08/21/621.html)
-- [Performance: TDengine vs Cassandra](https://www.taosdata.com/blog/2019/08/14/573.html)
-- [Performance: TDengine vs InfluxDB](https://www.taosdata.com/blog/2019/07/19/419.html)
-- [Performance Test Reports of TDengine vs InfluxDB/OpenTSDB/Cassandra/MySQL/ClickHouse](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)
+- [Performance: TDengine vs OpenTSDB](https://www.taosdata.com/blog/2019/09/12/710.html)
+- [Performance: TDengine vs Cassandra](https://www.taosdata.com/blog/2019/09/12/708.html)
+- [Performance: TDengine vs InfluxDB](https://www.taosdata.com/blog/2019/09/12/706.html)
+- [Performance Test Reports of TDengine vs InfluxDB/OpenTSDB/Cassandra/MySQL/ClickHouse](https://www.taosdata.com/downloads/TDengine_Testing_Report_en.pdf)
 
 ## More on IoT Big Data
 
@@ -136,6 +122,7 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 - [Features and Functions of IoT Big Data platforms](https://www.taosdata.com/blog/2019/07/29/542.html)
 - [Why don’t General Big Data Platforms Fit IoT Scenarios?](https://www.taosdata.com/blog/2019/07/09/why-does-the-general-big-data-platform-not-fit-iot-data-processing/)
 - [Why TDengine is the best choice for IoT, Internet of Vehicles, and Industry Internet Big Data platforms?](https://www.taosdata.com/blog/2019/07/09/why-tdengine-is-the-best-choice-for-iot-big-data-processing/)
+- [Technical Blog](https://www.taosdata.com/cn/blog/?categories=3): More technical analysis and architecture design articles
 
 ## FAQ
 

documentation20/en/01.evaluation/docs.md

@@ -2,18 +2,18 @@
 
 ## <a class="anchor" id="intro"></a> About TDengine
 
-TDengine is an innovative Big Data processing product launched by Taos Data in the face of the fast-growing Internet of Things (IoT) Big Data market and technical challenges. It does not rely on any third-party software, nor does it optimize or package any open-source database or stream computing product. Instead, it is a product independently developed after absorbing the advantages of many traditional relational databases, NoSQL databases, stream computing engines, message queues, and other software. TDengine has its own unique Big Data processing advantages in time-series space.
+TDengine is an innovative Big Data processing product launched by TAOS Data in the face of the fast-growing Internet of Things (IoT) Big Data market and technical challenges. It does not rely on any third-party software, nor does it optimize or package any open-source database or stream computing product. Instead, it is a product independently developed after absorbing the advantages of many traditional relational databases, NoSQL databases, stream computing engines, message queues, and other software. TDengine has its own unique Big Data processing advantages in time-series space.
 
 One of the modules of TDengine is the time-series database. However, in addition to this,  to reduce the complexity of research and development and the difficulty of system operation, TDengine also provides functions such as caching, message queuing, subscription, stream computing, etc. TDengine provides a full-stack technical solution for the processing of IoT and Industrial Internet BigData. It is an efficient and easy-to-use IoT Big Data platform. Compared with typical Big Data platforms such as Hadoop, TDengine has the following distinct characteristics:
 
 - **Performance improvement over 10 times**: An innovative data storage structure is defined, with each single core can process at least 20,000 requests per second, insert millions of data points, and read more than 10 million data points, which is more than 10 times faster than other existing general database.
 - **Reduce the cost of hardware or cloud services to 1/5**: Due to its ultra-performance, TDengine’s computing resources consumption is less than 1/5 of other common Big Data solutions; through columnar storage and advanced compression algorithms, the storage consumption is less than 1/10 of other general databases.
 - **Full-stack time-series data processing engine**: Integrate database, message queue, cache, stream computing, and other functions, and the applications do not need to integrate with software such as Kafka/Redis/HBase/Spark/HDFS, thus greatly reducing the complexity cost of application development and maintenance.
-- **Powerful analysis functions**: Data from ten years ago or one second ago, can all be queried based on a specified time range. Data can be aggregated on a timeline or multiple devices. Ad-hoc queries can be made at any time through Shell, Python, R, and MATLAB.
-- **Seamless connection with third-party tools**: Integration with Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R, etc. without even one single line of code. OPC, Hadoop, Spark, etc. will be supported in the future, and more BI tools will be seamlessly connected to.
+- **Highly Available and Horizontal Scalable **: With the distributed architecture and consistency algorithm, via multi-replication and clustering features, TDengine ensures high availability and horizontal scalability to support the mission-critical applications.
 - **Zero operation cost & zero learning cost**: Installing clusters is simple and quick, with real-time backup built-in, and no need to split libraries or tables. Similar to standard SQL, TDengine can support RESTful, Python/Java/C/C++/C#/Go/Node.js, and similar to MySQL with zero learning cost.
+- **Core is Open Sourced:** Except some auxiliary features, the core of TDengine is open sourced. Enterprise won't be locked by the database anymore. Ecosystem is more strong, product is more stable, and developer communities are more active. 
 
-With TDengine, the total cost of ownership of typical IoT, Internet of Vehicles, and Industrial Internet Big Data platforms can be greatly reduced. However, it should be pointed out that due to making full use of the characteristics of IoT time-series data, TDengine cannot be used to process general data from web crawlers, microblogs, WeChat, e-commerce, ERP, CRM, and other sources.
+With TDengine, the total cost of ownership of typical IoT, Internet of Vehicles, and Industrial Internet Big Data platforms can be greatly reduced. However, since it makes full use of the characteristics of IoT time-series data, TDengine cannot be used to process general data from web crawlers, microblogs, WeChat, e-commerce, ERP, CRM, and other sources.
 
 ![TDengine Technology Ecosystem](page://images/eco_system.png)
 

documentation20/en/02.getting-started/docs.md

@@ -2,7 +2,7 @@
 
 ## <a class="anchor" id="install"></a>Quick Install
 
-TDengine software consists of 3 components: server, client, and alarm module. At the moment, TDengine server only runs on Linux (Windows, mac OS and more OS supports will come soon), but client can run on either Windows or Linux. TDengine client can be installed and run on Windows or Linux. Applications based-on any OSes can all connect to server taosd via a RESTful interface. About CPU, TDengine supports X64/ARM64/MIPS64/Alpha64, and ARM32、RISC-V, other more CPU architectures will be supported soon. You can set up and install TDengine server either from the [source code](https://www.taosdata.com/en/getting-started/#Install-from-Source) or the [packages](https://www.taosdata.com/en/getting-started/#Install-from-Package).
+TDengine software consists of 3 parts: server, client, and alarm module. At the moment, TDengine server only runs on Linux (Windows, mac OS and more OS supports will come soon), but client can run on either Windows or Linux. TDengine client can be installed and run on Windows or Linux. Applications based-on any OSes can all connect to server taosd via a RESTful interface. About CPU, TDengine supports X64/ARM64/MIPS64/Alpha64, and ARM32、RISC-V, other more CPU architectures will be supported soon. You can set up and install TDengine server either from the [source code](https://www.taosdata.com/en/getting-started/#Install-from-Source) or the [packages](https://www.taosdata.com/en/getting-started/#Install-from-Package).
 
 ### <a class="anchor" id="source-install"></a>Install from Source
 
@@ -16,7 +16,7 @@ Please refer to the detailed operation in [Quickly experience TDengine through D
 
 ### <a class="anchor" id="package-install"></a>Install from Package
 
-It’s extremely easy to install for TDengine, which takes only a few seconds from downloaded to successful installed. The server installation package includes clients and connectors. We provide 3 installation packages, which you can choose according to actual needs:
+Three different packages for TDengine server are provided, please pick up the one you like. (Lite packages only have execution files and connector of C/C++, but standard packages support connectors of nearly all programming languages.) Beta version has more features, but we suggest you to install stable version for production or testing.
 
 Click [here](https://www.taosdata.com/en/getting-started/#Install-from-Package) to download the install package.
 
@@ -131,7 +131,7 @@ After starting the TDengine server, you can execute the command `taosdemo` in th
 $ taosdemo
 ```
 
-Using this command, a STable named `meters` will be created in the database `test` There are 10k tables under this stable, named from `t0` to `t9999`. In each table there are 100k rows of records, each row with columns （`f1`, `f2` and `f3`. The timestamp is from "2017-07-14 10:40:00 000" to "2017-07-14 10:41:39 999". Each table also has tags `areaid` and `loc`: `areaid` is set from 1 to 10, `loc` is set to "beijing" or "shanghai".
+Using this command, a STable named `meters` will be created in the database `test`. There are 10k tables under this STable, named from `t0` to `t9999`. In each table there are 100k rows of records, each row with columns （`f1`, `f2` and `f3`. The timestamp is from "2017-07-14 10:40:00 000" to "2017-07-14 10:41:39 999". Each table also has tags `areaid` and `loc`: `areaid` is set from 1 to 10, `loc` is set to "beijing" or "shanghai".
 
 It takes about 10 minutes to execute this command. Once finished, 1 billion rows of records will be inserted.
 
@@ -201,7 +201,7 @@ Note: ● has been verified by official tests; ○ has been verified by unoffici
 
 List of platforms supported by TDengine client and connectors
 
-At the moment, TDengine connectors can support a wide range of platforms, including hardware platforms such as X64/X86/ARM64/ARM32/MIPS/Alpha, and development environments such as Linux/Win64/Win32.
+At the moment, TDengine connectors can support a wide range of platforms, including hardware platforms such as X64/X86/ARM64/ARM32/MIPS/Alpha, and operating system such as Linux/Win64/Win32.
 
 Comparison matrix as following:
 
@@ -218,4 +218,4 @@ Comparison matrix as following:
 
 Note: ● has been verified by official tests; ○ has been verified by unofficial tests.
 
-Please visit [Connectors](https://www.taosdata.com/en/documentation/connector) section for more detailed information.
+Please visit Connectors section for more detailed information.
\ No newline at end of file

documentation20/en/04.model/docs.md

@@ -2,17 +2,15 @@
 
 TDengine adopts a relational data model, so we need to build the "database" and "table". Therefore, for a specific application scenario, it is necessary to consider the design of the database, STable and ordinary table. This section does not discuss detailed syntax rules, but only concepts.
 
-Please watch the [video tutorial](https://www.taosdata.com/blog/2020/11/11/1945.html) for data modeling.
-
 ## <a class="anchor" id="create-db"></a> Create a Database
 
-Different types of data collection points often have different data characteristics, including frequency of data collecting, length of data retention time, number of replicas, size of data blocks, whether to update data or not, and so on. To ensure TDengine working with great efficiency in various scenarios, TDengine suggests creating tables with different data characteristics in different databases, because each database can be configured with different storage strategies. When creating a database, in addition to SQL standard options, the application can also specify a variety of parameters such as retention duration, number of replicas, number of memory blocks, time accuracy, max and min number of records in a file block, whether it is compressed or not, and number of days a data file will be overwritten. For example:
+Different types of data collection points often have different data characteristics, including data sampling rate, length of data retention time, number of replicas, size of data blocks, whether to update data or not, and so on. To ensure TDengine working with great efficiency in various scenarios, TDengine suggests creating tables with different data characteristics in different databases, because each database can be configured with different storage strategies. When creating a database, in addition to SQL standard options, the application can also specify a variety of parameters such as retention duration, number of replicas, number of memory blocks, time resolution, max and min number of records in a file block, whether it is compressed or not, and number of days covered by a data file. For example:
 
 ```mysql
 CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
 ```
 
-The above statement will create a database named “power”. The data of this database will be kept for 365 days (it will be automatically deleted 365 days later), one data file created per 10 days, and the number of memory blocks is 4 for data updating. For detailed syntax and parameters, please refer to [Data Management section of TAOS SQL](https://www.taosdata.com/en/documentation/taos-sql#management).
+The above statement will create a database named “power”. The data of this database will be kept for 365 days (data will be automatically deleted 365 days later), one data file will be created per 10 days, the number of memory blocks is 4, and data updating is allowed. For detailed syntax and parameters, please refer to [Data Management section of TAOS SQL](https://www.taosdata.com/en/documentation/taos-sql#management).
 
 After the database created, please use SQL command USE to switch to the new database, for example:
 
@@ -20,13 +18,12 @@ After the database created, please use SQL command USE to switch to the new data
 USE power;	
 ```
 
-Replace the database operating in the current connection with “power”, otherwise, before operating on a specific table, you need to use "database name. table name" to specify the name of database to use.
+Specify the database operating in the current connection with “power”, otherwise, before operating on a specific table, you need to use "database-name.table-name" to specify the name of database to use.
 
 **Note:**
 
 - Any table or STable belongs to a database. Before creating a table, a database must be created first.
 - Tables in two different databases cannot be JOIN.
-- You need to specify a timestamp when creating and inserting records, or querying history records.
 
 ## <a class="anchor" id="create-stable"></a> Create a STable
 
@@ -38,11 +35,11 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
 
 **Note:** The STABLE keyword in this instruction needs to be written as TABLE in versions before 2.0.15.
 
-Just like creating an ordinary table, you need to provide the table name (‘meters’ in the example) and the table structure Schema, that is, the definition of data columns. The first column must be a timestamp (‘ts’ in the example), the other columns are the physical metrics collected (current, volume, phase in the example), and the data types can be int, float, string, etc. In addition, you need to provide the schema of the tag (location, groupId in the example), and the data types of the tag can be int, float, string and so on. Static attributes of collection points can often be used as tags, such as geographic location of collection points, device model, device group ID, administrator ID, etc. The schema of the tag can be added, deleted and modified afterwards. Please refer to the [STable Management section of TAOS SQL](https://www.taosdata.com/cn/documentation/taos-sql#super-table) for specific definitions and details.
+Just like creating an ordinary table, you need to provide the table name (‘meters’ in the example) and the table structure Schema, that is, the definition of data columns. The first column must be a timestamp (‘ts’ in the example), the other columns are the physical metrics collected (current, volume, phase in the example), and the data types can be int, float, string, etc. In addition, you need to provide the schema of the tag (location, groupId in the example), and the data types of the tag can be int, float, string and so on. Static attributes of data collection points can often be used as tags, such as geographic location of collection points, device model, device group ID, administrator ID, etc. The schema of the tags can be added, deleted and modified afterwards. Please refer to the [STable Management section of TAOS SQL](https://www.taosdata.com/cn/documentation/taos-sql#super-table) for specific definitions and details.
 
-Each type of data collection point needs an established STable, so an IoT system often has multiple STables. For the power grid, we need to build a STable for smart meters, transformers, buses, switches, etc. For IoT, a device may have multiple data collection points (for example, a fan for wind-driven generator, some collection points capture parameters such as current and voltage, and some capture environmental parameters such as temperature, humidity and wind direction). In this case, multiple STables need to be established for corresponding types of devices. All collected physical metrics contained in one and the same STable must be collected at the same time (with a consistent timestamp).
+A STable must be created for each type of data collection point, so an IoT system often has multiple STables. For the power grid, we need to build a STable for smart meters, a STable for transformers, a STable for buses, a STable for switches, etc. For IoT, a device may have multiple data collection points (for example, a fan for wind-driven generator, one data collection point captures metrics such as current and voltage, and one data collection point captures environmental parameters such as temperature, humidity and wind direction). In this case, multiple STables need to be established for corresponding types of devices. All metrics contained in a STable must be collected at the same time (with the same timestamp).
 
-A STable allows up to 1024 columns. If the number of physical metrics collected at a collection point exceeds 1024, multiple STables need to be built to process them. A system can have multiple DBs, and a DB can have one or more STables.
+A STable allows up to 1024 columns. If the number of metrics collected at a data collection point exceeds 1024, multiple STables need to be built to process them. A system can have multiple DBs, and a DB can have one or more STables.
 
 ## <a class="anchor" id="create-table"></a> Create a Table
 
@@ -54,22 +51,23 @@ CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 
 Where d1001 is the table name, meters is the name of the STable, followed by the specific tag value of tag Location as "Beijing.Chaoyang", and the specific tag value of tag groupId 2. Although the tag value needs to be specified when creating the table, it can be modified afterwards. Please refer to the [Table Management section of TAOS SQL](https://www.taosdata.com/en/documentation/taos-sql#table) for details.
 
-**Note: ** At present, TDengine does not technically restrict the use of a STable of a database (dbA) as a template to create a sub-table of another database (dbB). This usage will be prohibited later, and it is not recommended to use this method to create a table.
+**Note: ** At present, TDengine does not technically restrict the use of a STable of a database (dbA) as a template to create a sub-table of another database (dbB). This usage will be prohibited later, and it is not recommended to use this way to create a table.
 
 TDengine suggests to use the globally unique ID of data collection point as a table name (such as device serial number). However, in some scenarios, there is no unique ID, and multiple IDs can be combined into a unique ID. It is not recommended to use a unique ID as tag value.
 
-**Automatic table creating** : In some special scenarios, user is not sure whether the table of a certain data collection point exists when writing data. In this case, the non-existent table can be created by using automatic table building syntax when writing data. If the table already exists, no new table will be created. For example:
+**Automatic table creating** : In some special scenarios, user is not sure whether the table of a certain data collection point exists when writing data. In this case, the non-existent table can be created by using automatic table creating syntax when writing data. If the table already exists, no new table will be created. For example:
 
 ```mysql
 INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
 ```
 
-The SQL statement above inserts records (now, 10.2, 219, 0.32) into table d1001. If table d1001 has not been created yet, the STable meters is used as the template to automatically create it, and the tag value "Beijing.Chaoyang", 2 is marked at the same time.
+The SQL statement above inserts records (now, 10.2, 219, 0.32) into table d1001. If table d1001 has not been created yet, the STable meters is used as the template to create it automatically, and the tag value "Beijing.Chaoyang", 2 is set at the same time.
 
 For detailed syntax of automatic table building, please refer to the "[Automatic Table Creation When Inserting Records](https://www.taosdata.com/en/documentation/taos-sql#auto_create_table)" section.
 
 ## Multi-column Model vs Single-column Model
 
-TDengine supports multi-column model. As long as physical metrics are collected simultaneously by a data collection point (with a consistent timestamp), these metrics can be placed in a STable as different columns. However, there is also an extreme design, a single-column model, in which each collected physical metric is set up separately, so each type of physical metrics is set up separately with a STable. For example, create 3 Stables, one each for current, voltage and phase.
+TDengine supports multi-column model. As long as metrics are collected simultaneously by a data collection point (with the same timestamp), these metrics can be placed in a STable as different columns. However, there is also an extreme design, a single-column model, in which a STable is created for each metric. For smart meter example, we need to create 3 Stables, one for current, one for voltage and one for phase.
+
+TDengine recommends using multi-column model as much as possible because of higher insertion and storage efficiency. However, for some scenarios, types of collected metrics often change. In this case, if multi-column model is adopted, the schema definition of STable needs to be modified frequently and the application becomes complicated. To avoid that, single-column model is recommended.
 
-TDengine recommends using multi-column model as much as possible because of higher insertion and storage efficiency. However, for some scenarios, types of collected metrics often change. In this case, if multi-column model is adopted, the structure definition of STable needs to be frequently modified so make the application complicated. To avoid that, single-column model is recommended.

documentation20/en/05.insert/docs.md

 # Efficient Data Writing
 
-TDengine supports multiple interfaces to write data, including SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV file, etc. Kafka, OPC and other interfaces will be provided in the future. Data can be inserted in a single piece or in batches, data from one or multiple data collection points can be inserted at the same time. TDengine supports multi-thread insertion, nonsequential data insertion, and also historical data insertion.
+TDengine supports multiple ways to write data, including SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV file, etc. Kafka, OPC and other interfaces will be provided in the future. Data can be inserted in one single record or in batches, data from one or multiple data collection points can be inserted at the same time. TDengine supports multi-thread insertion, out-of-order data insertion, and also historical data insertion.
 
-## <a class="anchor" id="sql"></a> SQL Writing
+## <a class="anchor" id="sql"></a> Data Writing via SQL 
 
-Applications insert data by executing SQL insert statements through C/C++, JDBC, GO, or Python Connector, and users can manually enter SQL insert statements to insert data through TAOS Shell. For example, the following insert writes a record to table d1001:
+Applications insert data by executing SQL insert statements through C/C++, JDBC, GO, C#, or Python Connector, and users can manually enter SQL insert statements to insert data through TAOS Shell. For example, the following insert writes a record to table d1001:
 
 ```mysql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
 ```
 
-TDengine supports writing multiple records at a time. For example, the following command writes two records to table d1001:
+TDengine supports writing multiple records in a single statement. For example, the following command writes two records to table d1001:
 
 ```mysql
 INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
 ```
 
-TDengine also supports writing data to multiple tables at a time. For example, the following command writes two records to d1001 and one record to d1002:
+TDengine also supports writing data to multiple tables in a single statement. For example, the following command writes two records to d1001 and one record to d1002:
 
 ```mysql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
@@ -26,22 +26,22 @@ For the SQL INSERT Grammar, please refer to  [Taos SQL insert](https://www.taosd
 
 **Tips:**
 
-- To improve writing efficiency, batch writing is required. The more records written in a batch, the higher the insertion efficiency. However, a record cannot exceed 16K, and the total length of an SQL statement cannot exceed 64K (it can be configured by parameter maxSQLLength, and the maximum can be configured to 1M).
-- TDengine supports multi-thread parallel writing. To further improve writing speed, a client needs to open more than 20 threads to write parallelly. However, after the number of threads reaches a certain threshold, it cannot be increased or even become decreased, because too much frequent thread switching brings extra overhead.
-- For a same table, if the timestamp of a newly inserted record already exists, (no database was created using UPDATE 1) the new record will be discarded as default, that is, the timestamp must be unique in a table. If an application automatically generates records, it is very likely that the generated timestamps will be the same, so the number of records successfully inserted will be smaller than the number of records the application try to insert. If you use UPDATE 1 option when creating a database, inserting a new record with the same timestamp will overwrite the original record.
+- To improve writing efficiency, batch writing is required. The more records written in a batch, the higher the insertion efficiency. However, a record size cannot exceed 16K, and the total length of an SQL statement cannot exceed 64K (it can be configured by parameter maxSQLLength, and the maximum can be configured to 1M).
+- TDengine supports multi-thread parallel writing. To further improve writing speed, a client needs to open more than 20 threads to write parallelly. However, after the number of threads reaches a certain threshold, it cannot be increased or even become decreased, because too much thread switching brings extra overhead.
+- For the same table, if the timestamp of a newly inserted record already exists, the new record will be discarded as default (database option update = 0), that is, the timestamp must be unique in a table. If an application automatically generates records, it is very likely that the generated timestamps will be the same, so the number of records successfully inserted will be smaller than the number of records the application try to insert. If you use UPDATE 1 option when creating a database, inserting a new record with the same timestamp will overwrite the original record.
 - The timestamp of written data must be greater than the current time minus the time of configuration parameter keep. If keep is configured for 3650 days, data older than 3650 days cannot be written. The timestamp for writing data cannot be greater than the current time plus configuration parameter days. If days is configured to 2, data 2 days later than the current time cannot be written.
 
-## <a class="anchor" id="prometheus"></a> Direct Writing of Prometheus
+## <a class="anchor" id="prometheus"></a> Data Writing via Prometheus
 
 As a graduate project of Cloud Native Computing Foundation, [Prometheus](https://www.prometheus.io/) is widely used in the field of performance monitoring and K8S performance monitoring. TDengine provides a simple tool [Bailongma](https://github.com/taosdata/Bailongma), which only needs to be simply configured in Prometheus without any code, and can directly write the data collected by Prometheus into TDengine, then automatically create databases and related table entries in TDengine according to rules. Blog post [Use Docker Container to Quickly Build a Devops Monitoring Demo](https://www.taosdata.com/blog/2020/02/03/1189.html), which is an example of using bailongma to write Prometheus and Telegraf data into TDengine.
 
 ### Compile blm_prometheus From Source
 
-Users need to download the source code of [Bailongma](https://github.com/taosdata/Bailongma) from github, then compile and generate an executable file using Golang language compiler. Before you start compiling, you need to complete following prepares:
+Users need to download the source code of [Bailongma](https://github.com/taosdata/Bailongma) from github, then compile and generate an executable file using Golang language compiler. Before you start compiling, you need to prepare:
 
 - A server running Linux OS
 - Golang version 1.10 and higher installed
-- An appropriated TDengine version. Because the client dynamic link library of TDengine is used, it is necessary to install the same version of TDengine as the server-side; for example, if the server version is TDengine 2.0. 0, ensure install the same version on the linux server where bailongma is located (can be on the same server as TDengine, or on a different server)
+- Since the client dynamic link library of TDengine is used, it is necessary to install the same version of TDengine as the server-side. For example, if the server version is TDengine 2.0. 0, ensure install the same version on the linux server where bailongma is located (can be on the same server as TDengine, or on a different server)
 
 Bailongma project has a folder, blm_prometheus, which holds the prometheus writing API. The compiling process is as follows:
 
@@ -134,7 +134,7 @@ The format of generated data by Prometheus is as follows:
 }
 ```
 
-Where apiserver_request_latencies_bucket is the name of the time-series data collected by prometheus, and the tag of the time-series data is in the following {}. blm_prometheus automatically creates a STable in TDengine with the name of the time series data, and converts the tag in {} into the tag value of TDengine, with Timestamp as the timestamp and value as the value of the time-series data. Therefore, in the client of TDEngine, you can check whether this data was successfully written through the following instruction.
+Where apiserver_request_latencies_bucket is the name of the time-series data collected by prometheus, and the tag of the time-series data is in the following {}. blm_prometheus automatically creates a STable in TDengine with the name of the time series data, and converts the tag in {} into the tag value of TDengine, with Timestamp as the timestamp and value as the value of the time-series data. Therefore, in the client of TDengine, you can check whether this data was successfully written through the following instruction.
 
 ```mysql
 use prometheus;
@@ -144,7 +144,7 @@ select * from apiserver_request_latencies_bucket;
 
 
 
-## <a class="anchor" id="telegraf"></a> Direct Writing of Telegraf
+## <a class="anchor" id="telegraf"></a> Data Writing via Telegraf
 
 [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/) is a popular open source tool for IT operation data collection. TDengine provides a simple tool [Bailongma](https://github.com/taosdata/Bailongma), which only needs to be simply configured in Telegraf without any code, and can directly write the data collected by Telegraf into TDengine, then automatically create databases and related table entries in TDengine according to rules. Blog post [Use Docker Container to Quickly Build a Devops Monitoring Demo](https://www.taosdata.com/blog/2020/02/03/1189.html), which is an example of using bailongma to write Prometheus and Telegraf data into TDengine.
 
@@ -271,12 +271,12 @@ select * from cpu;
 
 MQTT is a popular data transmission protocol in the IoT. TDengine can easily access the data received by MQTT Broker and write it to TDengine.
 
-## <a class="anchor" id="emq"></a> Direct Writing of EMQ Broker
+## <a class="anchor" id="emq"></a> Data Writing via EMQ Broker
 
 [EMQ](https://github.com/emqx/emqx) is an open source MQTT Broker software, with no need of coding, only to use "rules" in EMQ Dashboard for simple configuration, and MQTT data can be directly written into TDengine. EMQ X supports storing data to the TDengine by sending it to a Web service, and also provides a native TDengine driver on Enterprise Edition for direct data store. Please refer to [EMQ official documents](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine) for more details.
 
 
 
-## <a class="anchor" id="hivemq"></a> Direct Writing of HiveMQ Broker
+## <a class="anchor" id="hivemq"></a> Data Writing via HiveMQ Broker
 
 [HiveMQ](https://www.hivemq.com/) is an MQTT agent that provides Free Personal and Enterprise Edition versions. It is mainly used for enterprises, emerging machine-to-machine(M2M) communication and internal transmission to meet scalability, easy management and security features. HiveMQ provides an open source plug-in development kit. You can store data to TDengine via HiveMQ extension-TDengine. Refer to the [HiveMQ extension-TDengine documentation](https://github.com/huskar-t/hivemq-tdengine-extension/blob/b62a26ecc164a310104df57691691b237e091c89/README.md) for more details.
\ No newline at end of file

documentation20/en/06.queries/docs.md

@@ -28,7 +28,7 @@ For specific query syntax, please see the [Data Query section of TAOS SQL](https
 
 ## <a class="anchor" id="aggregation"></a> Multi-table Aggregation Query
 
-In an IoT scenario, there are often multiple data collection points in a same type. TDengine uses the concept of STable to describe a certain type of data collection point, and an ordinary table to describe a specific data collection point. At the same time, TDengine uses tags to describe the statical attributes of data collection points. A given data collection point has a specific tag value. By specifying the filters of tags, TDengine provides an efficient method to aggregate and query the sub-tables of STables (data collection points of a certain type). Aggregation functions and most operations on ordinary tables are applicable to STables, and the syntax is exactly the same.
+In an IoT scenario, there are often multiple data collection points in a same type. TDengine uses the concept of STable to describe a certain type of data collection point, and an ordinary table to describe a specific data collection point. At the same time, TDengine uses tags to describe the static attributes of data collection points. A given data collection point has a specific tag value. By specifying the filters of tags, TDengine provides an efficient method to aggregate and query the sub-tables of STables (data collection points of a certain type). Aggregation functions and most operations on ordinary tables are applicable to STables, and the syntax is exactly the same.
 
 **Example 1**: In TAOS Shell, look up the average voltages collected by all smart meters in Beijing and group them by location
 
@@ -55,7 +55,7 @@ TDengine only allows aggregation queries between tables belonging to a same STab
 
 ## <a class="anchor" id="sampling"></a> Down Sampling Query, Interpolation
 
-In a scenario of IoT, it is often necessary to aggregate the collected data by intervals through down sampling. TDengine provides a simple keyword interval, which makes query operations according to time windows extremely simple. For example, the current values collected by smart meter d1001 are summed every 10 seconds.
+In a scenario of IoT, it is often necessary to aggregate the collected data by intervals through down sampling. TDengine provides a simple keyword `interval`, which makes query operations according to time windows extremely simple. For example, the current values collected by smart meter d1001 are summed every 10 seconds.
 
 ```mysql
 taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
@@ -94,6 +94,6 @@ taos> SELECT SUM(current) FROM meters INTERVAL(1s, 500a);
 Query OK, 5 row(s) in set (0.001521s)
 ```
 
-In a scenario of IoT, it is difficult to synchronize the time stamp of collected data at each point, but many analysis algorithms (such as FFT) need to align the collected data strictly at equal intervals of time. In many systems, it’s required to write their own programs to process, but the down sampling operation of TDengine can be easily solved. If there is no collected data in an interval, TDengine also provides interpolation calculation function.
+In IoT scenario, it is difficult to synchronize the time stamp of collected data at each point, but many analysis algorithms (such as FFT) need to align the collected data strictly at equal intervals of time. In many systems, it’s required to write their own programs to process, but the down sampling operation of TDengine can be used to solve the problem easily. If there is no collected data in an interval, TDengine also provides interpolation calculation function.
 
 For details of syntax rules, please refer to the [Time-dimension Aggregation section of TAOS SQL](https://www.taosdata.com/en/documentation/taos-sql#aggregation).
\ No newline at end of file

documentation20/en/07.advanced-features/docs.md

@@ -9,8 +9,8 @@ Continuous query of TDengine adopts time-driven mode, which can be defined direc
 The continuous query provided by TDengine differs from the time window calculation in ordinary stream computing in the following ways:
 
 - Unlike the real-time feedback calculated results of stream computing, continuous query only starts calculation after the time window is closed. For example, if the time period is 1 day, the results of that day will only be generated after 23:59:59.
-- If a history record is written to the time interval that has been calculated, the continuous query will not recalculate and will not push the results to the user again. For the mode of writing back to TDengine, the existing calculated results will not be updated.
-- Using the mode of continuous query pushing results, the server does not cache the client's calculation status, nor does it provide Exactly-Once semantic guarantee. If the user's application side crashed, the continuous query pulled up again would only recalculate the latest complete time window from the time pulled up again. If writeback mode is used, TDengine can ensure the validity and continuity of data writeback.
+- If a history record is written to the time interval that has been calculated, the continuous query will not re-calculate and will not push the new results to the user again. 
+- TDengine server does not cache or save the client's status, nor does it provide Exactly-Once semantic guarantee. If the application crashes, the continuous query will be pull up again and starting time must be provided by the application. 
 
 ### How to use continuous query
 
@@ -29,7 +29,7 @@ We already know that the average voltage of these meters can be counted with one
 select avg(voltage) from meters interval(1m) sliding(30s);
 ```
 
-Every time this statement is executed, all data will be recalculated. If you need to execute every 30 seconds to incrementally calculate the data of the latest minute, you can improve the above statement as following, using a different `startTime` each time and executing it regularly:
+Every time this statement is executed, all data will be re-calculated. If you need to execute every 30 seconds to incrementally calculate the data of the latest minute, you can improve the above statement as following, using a different `startTime` each time and executing it regularly:
 
 ```sql
 select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s);
@@ -65,7 +65,7 @@ It should be noted that now in the above example refers to the time when continu
 
 ### Manage the Continuous Query
 
-Users can view all continuous queries running in the system through the show streams command in the console, and can kill the corresponding continuous queries through the kill stream command. Subsequent versions will provide more finer-grained and convenient continuous query management commands.
+Users can view all continuous queries running in the system through the `show streams` command in the console, and can kill the corresponding continuous queries through the `kill stream` command. Subsequent versions will provide more finer-grained and convenient continuous query management commands.
 
 ## <a class="anchor" id="subscribe"></a> Publisher/Subscriber
 
@@ -101,7 +101,7 @@ Another method is to query the STable. In this way, no matter how many meters th
 select * from meters where ts > {last_timestamp} and current > 10;
 ```
 
-However, how to choose `last_timestamp` has become a new problem. Because, on the one hand, the time of data generation (the data timestamp) and the time of data storage are generally not the same, and sometimes the deviation is still very large; On the other hand, the time when the data of different meters arrive at TDengine will also vary. Therefore, if we use the timestamp of the data from the slowest meter as `last_timestamp` in the query, we may repeatedly read the data of other meters; If the timestamp of the fastest meter is used, the data of other meters may be missed.
+However, how to choose `last_timestamp` has become a new problem. Because, on the one hand, the time of data generation (the data timestamp) and the time of data writing are generally not the same, and sometimes the deviation is still very large; On the other hand, the time when the data of different meters arrive at TDengine will also vary. Therefore, if we use the timestamp of the data from the slowest meter as `last_timestamp` in the query, we may repeatedly read the data of other meters; If the timestamp of the fastest meter is used, the data of other meters may be missed.
 
 The subscription function of TDengine provides a thorough solution to the above problem.
 

documentation20/en/08.connector/docs.md

@@ -179,7 +179,7 @@ Clean up the running environment and call this API before the application exits.
 
 - `int taos_options(TSDB_OPTION option, const void * arg, ...)`
 
-Set client options, currently only time zone setting (`_TSDB_OPTIONTIMEZONE`) and encoding setting (`_TSDB_OPTIONLOCALE`) are supported. The time zone and encoding default to the current operating system settings.
+Set client options, currently only time zone setting (_TSDB_OPTIONTIMEZONE) and encoding setting (_TSDB_OPTIONLOCALE) are supported. The time zone and encoding default to the current operating system settings.
 
 - `char *taos_get_client_info()`
 

documentation20/en/09.connections/docs.md

@@ -2,7 +2,7 @@
 
 ## <a class="anchor" id="grafana"></a> Grafana
 
-TDengine can quickly integrate with [Grafana](https://www.grafana.com/), an open source data visualization system, to build a data monitoring and alarming system. The whole process does not require any code to write. The contents of the data table in TDengine can be visually showed on DashBoard.
+TDengine can be quickly integrated with [Grafana](https://www.grafana.com/), an open source data visualization system, to build a data monitoring and alarming system. The whole process does not require any code to write. The contents of the data table in TDengine can be visually showed on DashBoard.
 
 ### Install Grafana
 

documentation20/en/10.cluster/docs.md

 # TDengine Cluster Management
 
-Multiple TDengine servers, that is, multiple running instances of taosd, can form a cluster to ensure the highly reliable operation of TDengine and provide scale-out features. To understand cluster management in TDengine 2.0, it is necessary to understand the basic concepts of clustering. Please refer to the chapter "Overall Architecture of TDengine 2.0". And before installing the cluster, please follow the chapter ["Getting started"](https://www.taosdata.com/en/documentation/getting-started/) to install and experience the single node function.
+Multiple TDengine servers, that is, multiple running instances of taosd, can form a cluster to ensure the highly reliable operation of TDengine and provide scale-out features. To understand cluster management in TDengine 2.0, it is necessary to understand the basic concepts of clustering. Please refer to the chapter "Overall Architecture of TDengine 2.0". And before installing the cluster, please follow the chapter ["Getting started"](https://www.taosdata.com/en/documentation/getting-started/) to install and experience the single node TDengine.
 
-Each data node of the cluster is uniquely identified by End Point, which is composed of FQDN (Fully Qualified Domain Name) plus Port, such as [h1.taosdata.com](http://h1.taosdata.com/):6030. The general FQDN is the hostname of the server, which can be obtained through the Linux command `hostname -f` (how to configure FQDN, please refer to: [All about FQDN of TDengine](https://www.taosdata.com/blog/2020/09/11/1824.html)). Port is the external service port number of this data node. The default is 6030, but it can be modified by configuring the parameter serverPort in taos.cfg. A physical node may be configured with multiple hostnames, and TDengine will automatically get the first one, but it can also be specified through the configuration parameter fqdn in taos.cfg. If you are accustomed to direct IP address access, you can set the parameter fqdn to the IP address of this node.
+Each data node of the cluster is uniquely identified by End Point, which is composed of FQDN (Fully Qualified Domain Name) plus Port, such as [h1.taosdata.com](http://h1.taosdata.com/):6030. The general FQDN is the hostname of the server, which can be obtained through the Linux command `hostname -f` (how to configure FQDN, please refer to: [All about FQDN of TDengine](https://www.taosdata.com/blog/2020/09/11/1824.html)). Port is the external service port number of this data node. The default is 6030, but it can be modified by configuring the parameter serverPort in taos.cfg. A physical node may be configured with multiple hostnames, and TDengine will automatically get the first one, but it can also be specified through the configuration parameter `fqdn` in taos.cfg. If you want to access via direct IP address, you can set the parameter `fqdn` to the IP address of this node.
 
 The cluster management of TDengine is extremely simple. Except for manual intervention in adding and deleting nodes, all other tasks are completed automatically, thus minimizing the workload of operation. This chapter describes the operations of cluster management in detail.
 
@@ -12,7 +12,7 @@ Please refer to the [video tutorial](https://www.taosdata.com/blog/2020/11/11/19
 
 **Step 0:** Plan FQDN of all physical nodes in the cluster, and add the planned FQDN to /etc/hostname of each physical node respectively; modify the /etc/hosts of each physical node, and add the corresponding IP and FQDN of all cluster physical nodes. [If DNS is deployed, contact your network administrator to configure it on DNS]
 
-**Step 1:** If the physical nodes have previous test data, installed with version 1. x, or installed with other versions of TDengine, please delete it first and drop all data. For specific steps, please refer to the blog "[Installation and Uninstallation of Various Packages of TDengine](https://www.taosdata.com/blog/2019/08/09/566.html)"
+**Step 1:** If the physical nodes have previous test data, installed with version 1. x, or installed with other versions of TDengine, please backup all data, then delete it and drop all data. For specific steps, please refer to the blog "[Installation and Uninstallation of Various Packages of TDengine](https://www.taosdata.com/blog/2019/08/09/566.html)"
 
 **Note 1:** Because the information of FQDN will be written into a file, if FQDN has not been configured or changed before, and TDengine has been started, be sure to clean up the previous data （`rm -rf /var/lib/taos/*`）on the premise of ensuring that the data is useless or backed up;
 
@@ -136,7 +136,7 @@ Execute the CLI program taos, log in to the TDengine system using the root accou
 DROP DNODE "fqdn:port";
 ```
 
-Where fqdn is the FQDN of the deleted node, and port is the port number of its external server.
+Where fqdn is the FQDN of the deleted node, and port is the port number.
 
 <font color=green>**【Note】**</font>
 
@@ -185,7 +185,7 @@ Because of the introduction of vnode, it is impossible to simply draw a conclusi
 
 TDengine cluster is managed by mnode (a module of taosd, management node). In order to ensure the high-availability of mnode, multiple mnode replicas can be configured. The number of replicas is determined by system configuration parameter numOfMnodes, and the effective range is 1-3. In order to ensure the strong consistency of metadata, mnode replicas are duplicated synchronously.
 
-A cluster has multiple data node dnodes, but a dnode runs at most one mnode instance. In the case of multiple dnodes, which dnode can be used as an mnode? This is automatically specified by the system according to the resource situation on the whole. User can execute the following command in the console of TDengine through the CLI program taos:
+A cluster has multiple data node dnodes, but a dnode runs at most one mnode instance. In the case of multiple dnodes, which dnode can be used as an mnode? This is automatically selected by the system based on the resource on the whole. User can execute the following command in the console of TDengine through the CLI program taos:
 
 ```
 SHOW MNODES;
@@ -213,7 +213,7 @@ When the above three situations occur, the system will start a load computing of
 
 If a data node is offline, the TDengine cluster will automatically detect it. There are two detailed situations:
 
-- If the data node is offline for more than a certain period of time (configuration parameter offlineThreshold in taos.cfg controls the duration), the system will automatically delete the data node, generate system alarm information and trigger the load balancing process. If the deleted data node is online again, it will not be able to join the cluster, and the system administrator will need to add it to the cluster again.
+- If the data node is offline for more than a certain period of time (configuration parameter `offlineThreshold` in taos.cfg controls the duration), the system will automatically delete the data node, generate system alarm information and trigger the load balancing process. If the deleted data node is online again, it will not be able to join the cluster, and the system administrator will need to add it to the cluster again.
 - After offline, the system will automatically start the data recovery process if it goes online again within the duration of offlineThreshold. After the data is fully recovered, the node will start to work normally.
 
 **Note:** If each data node belonging to a virtual node group (including mnode group) is in offline or unsynced state, Master can only be elected after all data nodes in the virtual node group are online and can exchange status information, and the virtual node group can serve externally. For example, the whole cluster has 3 data nodes with 3 replicas. If all 3 data nodes go down and then 2 data nodes restart, it will not work. Only when all 3 data nodes restart successfully can serve externally again.
@@ -229,7 +229,7 @@ The name of the executable for Arbitrator is tarbitrator. The executable has alm
 
 
 1. Click [Package Download](https://www.taosdata.com/cn/all-downloads/), and in the TDengine Arbitrator Linux section, select the appropriate version to download and install.
-2. The command line parameter  -p of this application can specify the port number of its external service, and the default is 6042.
+2. The command line parameter  -p of this application can specify the port number of its service, and the default is 6042.
 3. Modify the configuration file of each taosd instance, and set parameter arbitrator to the End Point corresponding to the tarbitrator in taos.cfg. (If this parameter is configured, when the number of replicas is even, the system will automatically connect the configured Arbitrator. If the number of replicas is odd, even if the Arbitrator is configured, the system will not establish a connection.)
 4. The Arbitrator configured in the configuration file will appear in the return result of instruction `SHOW DNODES`; the value of the corresponding role column will be "arb".
 

documentation20/en/11.administrator/docs.md

@@ -22,8 +22,8 @@ If there is plenty of memory, the configuration of Blocks can be increased so th
 
 CPU requirements depend on the following two aspects:
 
-- **Data insertion** TDengine single core can handle at least 10,000 insertion requests per second. Each insertion request can take multiple records, and inserting one record at a time is almost the same as inserting 10 records in computing resources consuming. Therefore, the larger the number of inserts, the higher the insertion efficiency. If an insert request has more than 200 records, a single core can insert 1 million records per second. However, the faster the insertion speed, the higher the requirement for front-end data collection, because records need to be cached and then inserted in batches.
-- **Query requirements** TDengine to provide efficient queries, but the queries in each scenario vary greatly and the query frequency too, making it difficult to give objective figures. Users need to write some query statements for their own scenes to determine.
+- **Data insertion**: TDengine single core can handle at least 10,000 insertion requests per second. Each insertion request can take multiple records, and inserting one record at a time is almost the same as inserting 10 records in computing resources consuming. Therefore, the larger the number of records per insert, the higher the insertion efficiency. If an insert request has more than 200 records, a single core can insert 1 million records per second. However, the faster the insertion speed, the higher the requirement for front-end data collection, because records need to be cached and then inserted in batches.
+- **Query**: TDengine provides efficient queries, but the queries in each scenario vary greatly and the query frequency too, making it difficult to give objective figures. Users need to write some query statements for their own scenes to estimate.
 
 Therefore, only for data insertion, CPU can be estimated, but the computing resources consumed by query cannot be that clear. In the actual operation, it is not recommended to make CPU utilization rate over 50%. After that, new nodes need to be added to bring more computing resources.
 
@@ -78,7 +78,7 @@ When the nodes in TDengine cluster are deployed on different physical machines a
 
 ## <a class="anchor" id="config"></a> Server-side Configuration
 
-The background service of TDengine system is provided by taosd, and the configuration parameters can be modified in the configuration file taos.cfg to meet the requirements of different scenarios. The default location of the configuration file is the /etc/taos directory, which can be specified by executing the parameter -c from the taosd command line. Such as taosd-c/home/user, to specify that the configuration file is located in the /home/user directory.
+The background service of TDengine system is provided by taosd, and the configuration parameters can be modified in the configuration file taos.cfg to meet the requirements of different scenarios. The default location of the configuration file is the /etc/taos directory, which can be specified by executing the parameter `-c` from the taosd command line. Such as `taosd -c /home/user`, to specify that the configuration file is located in the /home/user directory.
 
 You can also use “-C” to show the current server configuration parameters:
 
@@ -88,14 +88,14 @@ taosd -C
 
 Only some important configuration parameters are listed below. For more parameters, please refer to the instructions in the configuration file. Please refer to the previous chapters for detailed introduction and function of each parameter, and the default of these parameters is working and generally does not need to be set. **Note: After the configuration is modified, \*taosd service\* needs to be restarted to take effect.**
 
-- firstEp: end point of the first dnode in the actively connected cluster when taosd starts, the default value is localhost: 6030.
-- fqdn: FQDN of the data node, which defaults to the first hostname configured by the operating system. If you are accustomed to IP address access, you can set it to the IP address of the node.
+- firstEp: end point of the first dnode which will be connected in the cluster when taosd starts, the default value is localhost: 6030.
+- fqdn: FQDN of the data node, which defaults to the first hostname configured by the operating system. If you want to access via IP address directly, you can set it to the IP address of the node.
 - serverPort: the port number of the external service after taosd started, the default value is 6030.
 - httpPort: the port number used by the RESTful service to which all HTTP requests (TCP) require a query/write request. The default value is 6041.
 - dataDir: the data file directory to which all data files will be written. [Default:/var/lib/taos](http://default/var/lib/taos).
 - logDir: the log file directory to which the running log files of the client and server will be written. [Default:/var/log/taos](http://default/var/log/taos).
-- arbitrator: the end point of the arbiter in the system; the default value is null.
-- role: optional role for dnode. 0-any; it can be used as an mnode and to allocate vnodes; 1-mgmt; It can only be an mnode, but not to allocate vnodes; 2-dnode; caannot be an mnode, only vnode can be allocated
+- arbitrator: the end point of the arbitrator in the system; the default value is null.
+- role: optional role for dnode. 0-any; it can be used as an mnode and to allocate vnodes; 1-mgmt; It can only be an mnode, but not to allocate vnodes; 2-dnode; cannot be an mnode, only vnode can be allocated
 - debugFlage: run the log switch. 131 (output error and warning logs), 135 (output error, warning, and debug logs), 143 (output error, warning, debug, and trace logs). Default value: 131 or 135 (different modules have different default values).
 - numOfLogLines: the maximum number of lines allowed for a single log file. Default: 10,000,000 lines.
 - logKeepDays: the maximum retention time of the log file. When it is greater than 0, the log file will be renamed to taosdlog.xxx, where xxx is the timestamp of the last modification of the log file in seconds. Default: 0 days.
@@ -161,18 +161,18 @@ For example:
 
 ## <a class="anchor" id="client"></a> Client Configuration
 
-The foreground interactive client application of TDengine system is taos and application driver, which shares the same configuration file taos.cfg with taosd. When running taos, use the parameter -c to specify the configuration file directory, such as taos-c/home/cfg, which means using the parameters in the taos.cfg configuration file under the /home/cfg/ directory. The default directory is /etc/taos. For more information on how to use taos, see the help information taos --help. This section mainly describes the parameters used by the taos client application in the configuration file taos.cfg.
+The foreground interactive client application of TDengine system is taos and application driver, which shares the same configuration file taos.cfg with taosd. When running taos, use the parameter `-c` to specify the configuration file directory, such as `taos -c /home/cfg`, which means using the parameters in the taos.cfg configuration file under the /home/cfg/ directory. The default directory is /etc/taos. For more information on how to use taos, see the help information `taos --help`. This section mainly describes the parameters used by the taos client application in the configuration file taos.cfg.
 
 **Versions after 2.0. 10.0 support the following parameters on command line to display the current client configuration parameters**
 
 ```bash
-taos -C  或  taos --dump-config
+taos -C  or  taos --dump-config
 ```
 
 Client configuration parameters:
 
 - firstEp: end point of the first taosd instance in the actively connected cluster when taos is started, the default value is localhost: 6030.
-- secondEp: when taos starts, if not impossible to connect to firstEp, it will try to connect to secondEp.
+- secondEp: when taos starts, if unable to connect to firstEp, it will try to connect to secondEp.
 - locale
     Default value: obtained dynamically from the system. If the automatic acquisition fails, user needs to set it in the configuration file or through API
     

documentation20/en/12.taos-sql/docs.md

 # TAOS SQL
 
-TDengine provides a SQL-style language, TAOS SQL, to insert or query data, and support other common tips. To finish this document, you should have some understanding about SQL.
+TDengine provides a SQL-style language, TAOS SQL, to insert or query data. To read through this document, you should have some basic understanding about SQL.
 
-TAOS SQL is the main tool for users to write and query data to TDengine. TAOS SQL provides a style and mode similar to standard SQL to facilitate users to get started quickly. Strictly speaking, TAOS SQL is not and does not attempt to provide SQL standard syntax. In addition, since TDengine does not provide deletion function for temporal structured data, the relevant function of data deletion is non-existent in TAO SQL.
+TAOS SQL is the main way for users to write and query data to TDengine. TAOS SQL is similar to standard SQL to facilitate users to get started quickly. Strictly speaking, TAOS SQL is not and does not attempt to provide SQL standard syntax. In addition, since TDengine does not provide deletion function for time-series data, the relevant function of data deletion is non-existent in TAO SQL.
 
 Let’s take a look at the conventions used for syntax descriptions.
 
@@ -138,14 +138,17 @@ Note:
 
 ## <a class="anchor" id="table"></a> Table Management
 
-- Create a table
-Note:
+- **Create a table**
 
-1. The first field must be a timestamp, and system will set it as the primary key;
-2. The max length of table name is 192;
-3. The length of each row of the table cannot exceed 16k characters;
-4. Sub-table names can only consist of letters, numbers, and underscores, and cannot begin with numbers
-5. If the data type binary or nchar is used, the maximum number of bytes should be specified, such as binary (20), which means 20 bytes;
+    ```mysql
+    CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
+    ```
+  Note:
+   1. The first field must be a timestamp, and system will set it as the primary key;
+   2. The max length of table name is 192;
+   3. The length of each row of the table cannot exceed 16k characters;
+   4. Sub-table names can only consist of letters, numbers, and underscores, and cannot begin with numbers
+   5. If the data type binary or nchar is used, the maximum number of bytes should be specified, such as binary (20), which means 20 bytes;
 
 - **Create a table via STable**
 
@@ -171,7 +174,7 @@ Note:
    
    Note:
    1. The method of batch creating tables requires that the data table must use STable as a template.
-   2. On the premise of not exceeding the length limit of SQL statements, it is suggested that the number of tables in a single statement should be controlled between 1000 and 3000, which will obtain an ideal speed of table building.
+   2. On the premise of not exceeding the length limit of SQL statements, it is suggested that the number of tables in a single statement should be controlled between 1000 and 3000, which will obtain an ideal speed of table creating.
 
 - **Drop a table**
   
@@ -218,7 +221,7 @@ Note:
 
 ## <a class="anchor" id="super-table"></a> STable Management
 
-Note: In 2.0. 15.0 and later versions, STABLE reserved words are supported. That is, in the instruction description later in this section, the three instructions of CREATE, DROP and ALTER need to write TABLE instead of STABLE in the old version as the reserved word.
+Note: In 2.0.15.0 and later versions, STABLE reserved words are supported. That is, in the instruction description later in this section, the three instructions of CREATE, DROP and ALTER need to write TABLE instead of STABLE in the old version as the reserved word.
 
 - **Create a STable**
 
@@ -421,7 +424,7 @@ taos> SELECT * FROM d1001;
 Query OK, 3 row(s) in set (0.001165s)
 ```
 
-For Stables, wildcards contain *tag columns*.
+For STables, wildcards contain *tag columns*.
 
 ```mysql
 taos> SELECT * FROM meters;
@@ -937,8 +940,6 @@ TDengine supports aggregations over data, they are listed below:
    Query OK, 1 row(s) in set (0.001023s)
    ```
 
-- 
-
 - **LAST**
 
    ```mysql
@@ -1172,7 +1173,7 @@ TDengine supports aggregations over data, they are listed below:
 
 ## <a class="anchor" id="aggregation"></a> Time-dimension Aggregation
 
-TDengine supports aggregating by intervals. Data in a table can partitioned by intervals and aggregated to generate results. For example, a temperature sensor collects data once per second, but the average temperature needs to be queried every 10 minutes. This aggregation is suitable for down sample operation, and the syntax is as follows:
+TDengine supports aggregating by intervals (time range). Data in a table can partitioned by intervals and aggregated to generate results. For example, a temperature sensor collects data once per second, but the average temperature needs to be queried every 10 minutes. This aggregation is suitable for down sample operation, and the syntax is as follows:
 
 ```mysql
 SELECT function_list FROM tb_name
@@ -1235,11 +1236,11 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P
 
 **Restrictions on group by**
 
-TAOS SQL supports group by operation on tags, tbnames and ordinary columns, required that only one column and whichhas less than 100,000 unique values.
+TAOS SQL supports group by operation on tags, tbnames and ordinary columns, required that only one column and which has less than 100,000 unique values.
 
 **Restrictions on join operation**
 
-TAOS SQL supports join columns of two tables by Primary Key timestamp between them, and does not support four operations after tables aggregated for the time being.
+TAOS SQL supports join columns of two tables by Primary Key timestamp between them, and does not support four arithmetic operations after tables aggregated for the time being.
 
 **Availability of is no null**
 

packaging/tools/make_install.sh

@@ -20,43 +20,32 @@ fi
 
 # Dynamic directory
 
-
 if [ "$osType" != "Darwin" ]; then
     data_dir="/var/lib/taos"
     log_dir="/var/log/taos"
-else
-    data_dir="/usr/local/var/lib/taos"
-    log_dir="/usr/local/var/log/taos"
-fi
 
-if [ "$osType" != "Darwin" ]; then
     cfg_install_dir="/etc/taos"
-else
-    cfg_install_dir="/usr/local/etc/taos"
-fi
 
-if [ "$osType" != "Darwin" ]; then
     bin_link_dir="/usr/bin"
     lib_link_dir="/usr/lib"
     lib64_link_dir="/usr/lib64"
     inc_link_dir="/usr/include"
+
+    install_main_dir="/usr/local/taos"
+
+    bin_dir="/usr/local/taos/bin"
 else
+    data_dir="/usr/local/var/lib/taos"
+    log_dir="/usr/local/var/log/taos"
+
+    cfg_install_dir="/usr/local/etc/taos"
+
     bin_link_dir="/usr/local/bin"
     lib_link_dir="/usr/local/lib"
     inc_link_dir="/usr/local/include"
-fi
 
-#install main path
-if [ "$osType" != "Darwin" ]; then
-    install_main_dir="/usr/local/taos"
-else
     install_main_dir="/usr/local/Cellar/tdengine/${verNumber}"
-fi
 
-# old bin dir
-if [ "$osType" != "Darwin" ]; then
-     bin_dir="/usr/local/taos/bin"
-else
     bin_dir="/usr/local/Cellar/tdengine/${verNumber}/bin"
 fi
 
@@ -254,7 +243,10 @@ function install_lib() {
           ${csudo} ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so
         fi
     else
-        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
+        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
+
+        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
+        ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
     fi
     
     install_jemalloc

src/client/inc/tscUtil.h

@@ -318,6 +318,7 @@ void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex, SSqlC
 
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid);
 int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId);
+int32_t doInitSubState(SSqlObj* pSql, int32_t numOfSubqueries);
 
 void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex);
 

src/client/src/tscSQLParser.c

@@ -22,6 +22,7 @@
 
 #include <qSqlparser.h>
 #include "os.h"
+#include "regex.h"
 #include "qPlan.h"
 #include "qSqlparser.h"
 #include "qTableMeta.h"
@@ -278,6 +279,8 @@ static uint8_t convertRelationalOperator(SStrToken *pToken) {
       return TSDB_BINARY_OP_REMAINDER;
     case TK_LIKE:
       return TSDB_RELATION_LIKE;
+    case TK_MATCH:
+      return TSDB_RELATION_MATCH;
     case TK_ISNULL:
       return TSDB_RELATION_ISNULL;
     case TK_NOTNULL:
@@ -3776,6 +3779,9 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
     case TK_LIKE:
       pColumnFilter->lowerRelOptr = TSDB_RELATION_LIKE;
       break;
+    case TK_MATCH:
+      pColumnFilter->lowerRelOptr = TSDB_RELATION_MATCH;
+      break;
     case TK_ISNULL:
       pColumnFilter->lowerRelOptr = TSDB_RELATION_ISNULL;
       break;
@@ -3839,9 +3845,15 @@ static int32_t tablenameListToString(tSqlExpr* pExpr, SStringBuilder* sb) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tablenameCondToString(tSqlExpr* pExpr, SStringBuilder* sb) {
+static int32_t tablenameCondToString(tSqlExpr* pExpr, uint32_t opToken, SStringBuilder* sb) {
+  assert(opToken == TK_LIKE || opToken == TK_MATCH);
+  if (opToken == TK_LIKE) {
     taosStringBuilderAppendStringLen(sb, QUERY_COND_REL_PREFIX_LIKE, QUERY_COND_REL_PREFIX_LIKE_LEN);
     taosStringBuilderAppendString(sb, pExpr->value.pz);
+  } else if (opToken == TK_MATCH) {
+    taosStringBuilderAppendStringLen(sb, QUERY_COND_REL_PREFIX_MATCH, QUERY_COND_REL_PREFIX_MATCH_LEN);
+    taosStringBuilderAppendString(sb, pExpr->value.pz);
+  }
 
   return TSDB_CODE_SUCCESS;
 }
@@ -3862,7 +3874,7 @@ static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCol
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
   SSchema*    pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
   int32_t     ret = 0;
-  const char* msg1 = "non binary column not support like operator";
+  const char* msg1 = "non binary column not support like/match operator";
   const char* msg2 = "binary column not support this operator";  
   const char* msg3 = "bool column not support this operator";
   const char* msg4 = "primary key not support this operator";
@@ -3890,12 +3902,13 @@ static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCol
       && pExpr->tokenId != TK_ISNULL
       && pExpr->tokenId != TK_NOTNULL
       && pExpr->tokenId != TK_LIKE
+      && pExpr->tokenId != TK_MATCH
       && pExpr->tokenId != TK_IN) {
       ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       goto _err_ret;
     }
   } else {
-    if (pExpr->tokenId == TK_LIKE) {
+    if (pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH) {
       ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       goto _err_ret;
     }
@@ -3943,12 +3956,12 @@ static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr*
 
   if (pTableCond->tokenId == TK_IN) {
     ret = tablenameListToString(pRight, sb);
-  } else if (pTableCond->tokenId == TK_LIKE) {
+  } else if (pTableCond->tokenId == TK_LIKE || pTableCond->tokenId == TK_MATCH) {
     if (pRight->tokenId != TK_STRING) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
     
-    ret = tablenameCondToString(pRight, sb);
+    ret = tablenameCondToString(pRight, pTableCond->tokenId, sb);
   }
 
   if (ret != TSDB_CODE_SUCCESS) {
@@ -4397,7 +4410,7 @@ static bool validateJoinExprNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr
 }
 
 static bool validTableNameOptr(tSqlExpr* pExpr) {
-  const char nameFilterOptr[] = {TK_IN, TK_LIKE};
+  const char nameFilterOptr[] = {TK_IN, TK_LIKE, TK_MATCH};
 
   for (int32_t i = 0; i < tListLen(nameFilterOptr); ++i) {
     if (pExpr->tokenId == nameFilterOptr[i]) {
@@ -4489,6 +4502,45 @@ static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
+// check for match expression
+static int32_t validateMatchExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t index, char* msgBuf) {
+  const char* msg1 = "regular expression string should be less than %d characters";
+  const char* msg2 = "illegal column type for match";
+  const char* msg3 = "invalid regular expression";
+
+  tSqlExpr* pLeft  = pExpr->pLeft;
+  tSqlExpr* pRight = pExpr->pRight;
+
+  if (pExpr->tokenId == TK_MATCH) {
+    if (pRight->value.nLen > tsMaxRegexStringLen) {
+      char tmp[64] = {0};
+      sprintf(tmp, msg1, tsMaxRegexStringLen);
+      return invalidOperationMsg(msgBuf, tmp);
+    }
+
+    SSchema* pSchema = tscGetTableSchema(pTableMeta);
+    if ((!isTablenameToken(&pLeft->columnName)) && !IS_VAR_DATA_TYPE(pSchema[index].type)) {
+      return invalidOperationMsg(msgBuf, msg2);
+    }
+
+    int errCode = 0;
+    regex_t regex;
+    char    regErrBuf[256] = {0};
+
+    const char* pattern = pRight->value.pz;
+    int cflags = REG_EXTENDED;
+    if ((errCode = regcomp(&regex, pattern, cflags)) != 0) {
+      regerror(errCode, &regex, regErrBuf, sizeof(regErrBuf));
+      tscError("Failed to compile regex pattern %s. reason %s", pattern, regErrBuf);
+      return invalidOperationMsg(msgBuf, msg3);
+    }
+    regfree(&regex);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t handleNeOptr(tSqlExpr** rexpr, tSqlExpr* expr) {
   tSqlExpr* left = tSqlExprClone(expr);
   tSqlExpr* right = expr;
@@ -4540,6 +4592,12 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
     return code;
   }
 
+  // validate the match expression
+  code = validateMatchExpr(*pExpr, pTableMeta, index.columnIndex, tscGetErrorMsgPayload(pCmd));
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
   SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
   if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP && index.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) {  // query on time range
     if (!validateJoinExprNode(pCmd, pQueryInfo, *pExpr, &index)) {
@@ -4867,16 +4925,16 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
   STagCond* pTagCond = &pQueryInfo->tagCond;
   pTagCond->tbnameCond.uid = pTableMetaInfo->pTableMeta->id.uid;
 
-  assert(pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_IN);
+  assert(pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH || pExpr->tokenId == TK_IN);
 
-  if (pExpr->tokenId == TK_LIKE) {
+  if (pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH) {
     char* str = taosStringBuilderGetResult(sb, NULL);
     pQueryInfo->tagCond.tbnameCond.cond = strdup(str);
     pQueryInfo->tagCond.tbnameCond.len = (int32_t) strlen(str);
     return TSDB_CODE_SUCCESS;
-  }
-
-  SStringBuilder sb1; memset(&sb1, 0, sizeof(sb1));
+  } else {
+    SStringBuilder sb1;
+    memset(&sb1, 0, sizeof(sb1));
     taosStringBuilderAppendStringLen(&sb1, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN);
 
     // remove the duplicated input table names
@@ -4896,7 +4954,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
 
     char name[TSDB_DB_NAME_LEN] = {0};
     tNameGetDbName(&pTableMetaInfo->name, name);
-  SStrToken dbToken = { .type = TK_STRING, .z = name, .n = (uint32_t)strlen(name) };
+    SStrToken dbToken = {.type = TK_STRING, .z = name, .n = (uint32_t)strlen(name)};
 
     for (int32_t i = 0; i < num; ++i) {
       if (i >= 1) {
@@ -4921,11 +4979,12 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
 
     char* str = taosStringBuilderGetResult(&sb1, NULL);
     pQueryInfo->tagCond.tbnameCond.cond = strdup(str);
-  pQueryInfo->tagCond.tbnameCond.len = (int32_t) strlen(str);
+    pQueryInfo->tagCond.tbnameCond.len = (int32_t)strlen(str);
 
     taosStringBuilderDestroy(&sb1);
     tfree(segments);
     return TSDB_CODE_SUCCESS;
+  }
 }
 
 int32_t mergeTimeRange(SSqlCmd* pCmd, STimeWindow* res, STimeWindow* win, int32_t optr) {
@@ -8112,7 +8171,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
 }
 
 static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNodeList, tSqlExpr* pExpr, int32_t sqlOptr) {
-  const char* msg1 = "non binary column not support like operator";
+  const char* msg1 = "non binary column not support like/match operator";
   const char* msg2 = "invalid operator for binary column in having clause";
   const char* msg3 = "invalid operator for bool column in having clause";
 
@@ -8164,11 +8223,12 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, S
         && pExpr->tokenId != TK_ISNULL
         && pExpr->tokenId != TK_NOTNULL
         && pExpr->tokenId != TK_LIKE
+        && pExpr->tokenId != TK_MATCH
         ) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else {
-    if (pExpr->tokenId == TK_LIKE) {
+    if (pExpr->tokenId == TK_LIKE || pExpr->tokenId == TK_MATCH) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 

src/client/src/tscSubquery.c

@@ -2459,11 +2459,48 @@ static void doSendQueryReqs(SSchedMsg* pSchedMsg) {
   tfree(p);
 }
 
+static void doConcurrentlySendSubQueries(SSqlObj* pSql) {
+  SSubqueryState *pState = &pSql->subState;
+
+  // concurrently sent the query requests.
+  const int32_t MAX_REQUEST_PER_TASK = 8;
+
+  int32_t numOfTasks = (pState->numOfSub + MAX_REQUEST_PER_TASK - 1)/MAX_REQUEST_PER_TASK;
+  assert(numOfTasks >= 1);
+
+  int32_t num;
+  if (pState->numOfSub / numOfTasks == MAX_REQUEST_PER_TASK) {
+    num = MAX_REQUEST_PER_TASK;
+  } else {
+    num = pState->numOfSub / numOfTasks + 1;
+  }
+  tscDebug("0x%"PRIx64 " query will be sent by %d threads", pSql->self, numOfTasks);
+
+  for(int32_t j = 0; j < numOfTasks; ++j) {
+    SSchedMsg schedMsg = {0};
+    schedMsg.fp      = doSendQueryReqs;
+    schedMsg.ahandle = (void*)pSql;
+
+    schedMsg.thandle = NULL;
+    SPair* p = calloc(1, sizeof(SPair));
+    p->first  = j * num;
+
+    if (j == numOfTasks - 1) {
+      p->second = pState->numOfSub;
+    } else {
+      p->second = (j + 1) * num;
+    }
+
+    schedMsg.msg = p;
+    taosScheduleTask(tscQhandle, &schedMsg);
+  }
+}
+
 int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
   
-  // pRes->code check only serves in launching metric sub-queries
+  // pRes->code check only serves in launching super table sub-queries
   if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
     pCmd->command = TSDB_SQL_RETRIEVE_GLOBALMERGE;  // enable the abort of kill super table function.
     return pRes->code;
@@ -2474,22 +2511,23 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
 
   pRes->qId = 0x1;  // hack the qhandle check
 
-  const uint32_t nBufferSize = (1u << 18u);  // 256KB
+  const uint32_t nBufferSize = (1u << 18u);  // 256KB, default buffer size
 
   SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
   SSubqueryState *pState = &pSql->subState;
 
-  pState->numOfSub = 0;
-  if (pTableMetaInfo->pVgroupTables == NULL) {
-    pState->numOfSub = pTableMetaInfo->vgroupList->numOfVgroups;
-  } else {
-    pState->numOfSub = (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
-  }
+  int32_t numOfSub = (pTableMetaInfo->pVgroupTables == NULL) ? pTableMetaInfo->vgroupList->numOfVgroups
+                                                             : (int32_t)taosArrayGetSize(pTableMetaInfo->pVgroupTables);
 
-  assert(pState->numOfSub > 0);
+  int32_t ret = doInitSubState(pSql, numOfSub);
+  if (ret != 0) {
+    tscAsyncResultOnError(pSql);
+    return ret;
+  }
 
-  int32_t ret = tscCreateGlobalMergerEnv(pQueryInfo, &pMemoryBuf, pSql->subState.numOfSub, &pDesc, nBufferSize, pSql->self);
+  ret = tscCreateGlobalMergerEnv(pQueryInfo, &pMemoryBuf, pSql->subState.numOfSub, &pDesc, nBufferSize, pSql->self);
   if (ret != 0) {
     pRes->code = ret;
     tscAsyncResultOnError(pSql);
@@ -2499,32 +2537,6 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   }
 
   tscDebug("0x%"PRIx64" retrieved query data from %d vnode(s)", pSql->self, pState->numOfSub);
-  pSql->pSubs = calloc(pState->numOfSub, POINTER_BYTES);
-  if (pSql->pSubs == NULL) {
-    tfree(pSql->pSubs);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tscDestroyGlobalMergerEnv(pMemoryBuf, pDesc,pState->numOfSub);
-
-    tscAsyncResultOnError(pSql);
-    return ret;
-  }
-
-  if (pState->states == NULL) {
-    pState->states = calloc(pState->numOfSub, sizeof(*pState->states));
-    if (pState->states == NULL) {
-      pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-      tscDestroyGlobalMergerEnv(pMemoryBuf, pDesc,pState->numOfSub);
-
-      tscAsyncResultOnError(pSql);
-      return ret;
-    }
-
-    pthread_mutex_init(&pState->mutex, NULL);
-  }
-
-  memset(pState->states, 0, sizeof(*pState->states) * pState->numOfSub);
-  tscDebug("0x%"PRIx64" reset all sub states to 0", pSql->self);
-  
   pRes->code = TSDB_CODE_SUCCESS;
   
   int32_t i = 0;
@@ -2582,39 +2594,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     return pRes->code;
   }
 
-  // concurrently sent the query requests.
-  const int32_t MAX_REQUEST_PER_TASK = 8;
-
-  int32_t numOfTasks = (pState->numOfSub + MAX_REQUEST_PER_TASK - 1)/MAX_REQUEST_PER_TASK;
-  assert(numOfTasks >= 1);
-
-  int32_t num;
-  if (pState->numOfSub / numOfTasks == MAX_REQUEST_PER_TASK) {
-    num = MAX_REQUEST_PER_TASK;
-  } else {
-    num = pState->numOfSub / numOfTasks + 1;
-  }
-  tscDebug("0x%"PRIx64 " query will be sent by %d threads", pSql->self, numOfTasks);
-
-  for(int32_t j = 0; j < numOfTasks; ++j) {
-    SSchedMsg schedMsg = {0};
-    schedMsg.fp      = doSendQueryReqs;
-    schedMsg.ahandle = (void*)pSql;
-
-    schedMsg.thandle = NULL;
-    SPair* p = calloc(1, sizeof(SPair));
-    p->first  = j * num;
-
-    if (j == numOfTasks - 1) {
-      p->second = pState->numOfSub;
-    } else {
-      p->second = (j + 1) * num;
-    }
-
-    schedMsg.msg = p;
-    taosScheduleTask(tscQhandle, &schedMsg);
-  }
-
+  doConcurrentlySendSubQueries(pSql);
   return TSDB_CODE_SUCCESS;
 }
 

src/client/src/tscSystem.c

@@ -123,6 +123,10 @@ int32_t tscAcquireRpc(const char *key, const char *user, const char *secretEncry
 void taos_init_imp(void) {
   char temp[128] = {0};
 
+  // In the APIs of other program language, taos_cleanup is not available yet.
+  // So, to make sure taos_cleanup will be invoked to clean up the allocated resource to suppress the valgrind warning.
+  atexit(taos_cleanup);
+  
   errno = TSDB_CODE_SUCCESS;
   srand(taosGetTimestampSec());
   deltaToUtcInitOnce();
@@ -197,10 +201,6 @@ void taos_init_imp(void) {
 
   tscRefId = taosOpenRef(200, tscCloseTscObj);
 
-  // In the APIs of other program language, taos_cleanup is not available yet.
-  // So, to make sure taos_cleanup will be invoked to clean up the allocated resource to suppress the valgrind warning.
-  atexit(taos_cleanup);
-
   tscDebug("client is initialized successfully");
 }
 

src/client/src/tscUtil.c

@@ -3944,6 +3944,21 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
   taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
 }
 
+int32_t doInitSubState(SSqlObj* pSql, int32_t numOfSubqueries) {
+  assert(pSql->subState.numOfSub == 0 && pSql->pSubs == NULL && pSql->subState.states == NULL);
+  pSql->subState.numOfSub = numOfSubqueries;
+
+  pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
+  pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
+
+  int32_t code = pthread_mutex_init(&pSql->subState.mutex, NULL);
+  if (pSql->pSubs == NULL || pSql->subState.states == NULL || code != 0) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 // do execute the query according to the query execution plan
 void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   int32_t code = TSDB_CODE_SUCCESS;
@@ -3959,16 +3974,8 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 
   if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // nest query. do execute it firstly
-    assert(pSql->subState.numOfSub == 0);
-    pSql->subState.numOfSub = (int32_t) taosArrayGetSize(pQueryInfo->pUpstream);
-    assert(pSql->pSubs == NULL);
-    pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
-    assert(pSql->subState.states == NULL);
-    pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
-    code = pthread_mutex_init(&pSql->subState.mutex, NULL);
-
-    if (pSql->pSubs == NULL || pSql->subState.states == NULL || code != TSDB_CODE_SUCCESS) {
-      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    code = doInitSubState(pSql, (int32_t) taosArrayGetSize(pQueryInfo->pUpstream));
+    if (code != TSDB_CODE_SUCCESS) {
       goto _error;
     }
 
@@ -4315,7 +4322,9 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   }
 
   tfree(pSql->pSubs);
+  tfree(pSql->subState.states);
   pSql->subState.numOfSub = 0;
+  pthread_mutex_destroy(&pSql->subState.mutex);
 
   pSql->fp = fp;
 

src/common/inc/texpr.h

@@ -33,9 +33,11 @@ struct SSchema;
 
 #define QUERY_COND_REL_PREFIX_IN "IN|"
 #define QUERY_COND_REL_PREFIX_LIKE "LIKE|"
+#define QUERY_COND_REL_PREFIX_MATCH "MATCH|"
 
 #define QUERY_COND_REL_PREFIX_IN_LEN   3
 #define QUERY_COND_REL_PREFIX_LIKE_LEN 5
+#define QUERY_COND_REL_PREFIX_MATCH_LEN 6
 
 typedef bool (*__result_filter_fn_t)(const void *, void *);
 typedef void (*__do_filter_suppl_fn_t)(void *, void *);

src/common/inc/tglobal.h

@@ -74,6 +74,7 @@ extern int8_t   tsKeepOriginalColumnName;
 // client
 extern int32_t tsMaxSQLStringLen;
 extern int32_t tsMaxWildCardsLen;
+extern int32_t tsMaxRegexStringLen;
 extern int8_t  tsTscEnableRecordSql;
 extern int32_t tsMaxNumOfOrderedResults;
 extern int32_t tsMinSlidingTime;

src/common/src/texpr.c

@@ -430,6 +430,17 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
     pVal->nType = TSDB_DATA_TYPE_BINARY;
     pVal->nLen = (int32_t)len;
 
+  } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_MATCH, QUERY_COND_REL_PREFIX_MATCH_LEN) == 0) {
+    right->nodeType = TSQL_NODE_VALUE;
+    expr->_node.optr = TSDB_RELATION_MATCH;
+    tVariant* pVal = exception_calloc(1, sizeof(tVariant));
+    right->pVal = pVal;
+    size_t len = strlen(tbnameCond + QUERY_COND_REL_PREFIX_MATCH_LEN) + 1;
+    pVal->pz = exception_malloc(len);
+    memcpy(pVal->pz, tbnameCond + QUERY_COND_REL_PREFIX_MATCH_LEN, len);
+    pVal->nType = TSDB_DATA_TYPE_BINARY;
+    pVal->nLen = (int32_t)len;
+
   } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN) == 0) {
     right->nodeType = TSQL_NODE_VALUE;
     expr->_node.optr = TSDB_RELATION_IN;

src/common/src/tglobal.c

@@ -85,6 +85,8 @@ int32_t tsCompressColData = -1;
 // client
 int32_t tsMaxSQLStringLen = TSDB_MAX_ALLOWED_SQL_LEN;
 int32_t tsMaxWildCardsLen = TSDB_PATTERN_STRING_DEFAULT_LEN;
+int32_t tsMaxRegexStringLen = TSDB_REGEX_STRING_DEFAULT_LEN;
+
 int8_t  tsTscEnableRecordSql = 0;
 
 // the maximum number of results for projection query on super table that are returned from

src/inc/taosdef.h

@@ -164,6 +164,8 @@ do { \
 #define TSDB_RELATION_OR          12
 #define TSDB_RELATION_NOT         13
 
+#define TSDB_RELATION_MATCH       14
+
 #define TSDB_BINARY_OP_ADD        30
 #define TSDB_BINARY_OP_SUBTRACT   31
 #define TSDB_BINARY_OP_MULTIPLY   32

src/inc/ttokendef.h

@@ -37,160 +37,160 @@
 #define TK_NOTNULL                         19
 #define TK_IS                              20
 #define TK_LIKE                            21
-#define TK_GLOB                            22
-#define TK_BETWEEN                         23
-#define TK_IN                              24
-#define TK_GT                              25
-#define TK_GE                              26
-#define TK_LT                              27
-#define TK_LE                              28
-#define TK_BITAND                          29
-#define TK_BITOR                           30
-#define TK_LSHIFT                          31
-#define TK_RSHIFT                          32
-#define TK_PLUS                            33
-#define TK_MINUS                           34
-#define TK_DIVIDE                          35
-#define TK_TIMES                           36
-#define TK_STAR                            37
-#define TK_SLASH                           38
-#define TK_REM                             39
-#define TK_CONCAT                          40
-#define TK_UMINUS                          41
-#define TK_UPLUS                           42
-#define TK_BITNOT                          43
-#define TK_SHOW                            44
-#define TK_DATABASES                       45
-#define TK_TOPICS                          46
-#define TK_FUNCTIONS                       47
-#define TK_MNODES                          48
-#define TK_DNODES                          49
-#define TK_ACCOUNTS                        50
-#define TK_USERS                           51
-#define TK_MODULES                         52
-#define TK_QUERIES                         53
-#define TK_CONNECTIONS                     54
-#define TK_STREAMS                         55
-#define TK_VARIABLES                       56
-#define TK_SCORES                          57
-#define TK_GRANTS                          58
-#define TK_VNODES                          59
-#define TK_DOT                             60
-#define TK_CREATE                          61
-#define TK_TABLE                           62
-#define TK_STABLE                          63
-#define TK_DATABASE                        64
-#define TK_TABLES                          65
-#define TK_STABLES                         66
-#define TK_VGROUPS                         67
-#define TK_DROP                            68
-#define TK_TOPIC                           69
-#define TK_FUNCTION                        70
-#define TK_DNODE                           71
-#define TK_USER                            72
-#define TK_ACCOUNT                         73
-#define TK_USE                             74
-#define TK_DESCRIBE                        75
-#define TK_DESC                            76
-#define TK_ALTER                           77
-#define TK_PASS                            78
-#define TK_PRIVILEGE                       79
-#define TK_LOCAL                           80
-#define TK_COMPACT                         81
-#define TK_LP                              82
-#define TK_RP                              83
-#define TK_IF                              84
-#define TK_EXISTS                          85
-#define TK_AS                              86
-#define TK_OUTPUTTYPE                      87
-#define TK_AGGREGATE                       88
-#define TK_BUFSIZE                         89
-#define TK_PPS                             90
-#define TK_TSERIES                         91
-#define TK_DBS                             92
-#define TK_STORAGE                         93
-#define TK_QTIME                           94
-#define TK_CONNS                           95
-#define TK_STATE                           96
-#define TK_COMMA                           97
-#define TK_KEEP                            98
-#define TK_CACHE                           99
-#define TK_REPLICA                        100
-#define TK_QUORUM                         101
-#define TK_DAYS                           102
-#define TK_MINROWS                        103
-#define TK_MAXROWS                        104
-#define TK_BLOCKS                         105
-#define TK_CTIME                          106
-#define TK_WAL                            107
-#define TK_FSYNC                          108
-#define TK_COMP                           109
-#define TK_PRECISION                      110
-#define TK_UPDATE                         111
-#define TK_CACHELAST                      112
-#define TK_PARTITIONS                     113
-#define TK_UNSIGNED                       114
-#define TK_TAGS                           115
-#define TK_USING                          116
-#define TK_NULL                           117
-#define TK_NOW                            118
-#define TK_SELECT                         119
-#define TK_UNION                          120
-#define TK_ALL                            121
-#define TK_DISTINCT                       122
-#define TK_FROM                           123
-#define TK_VARIABLE                       124
-#define TK_INTERVAL                       125
-#define TK_EVERY                          126
-#define TK_SESSION                        127
-#define TK_STATE_WINDOW                   128
-#define TK_FILL                           129
-#define TK_SLIDING                        130
-#define TK_ORDER                          131
-#define TK_BY                             132
-#define TK_ASC                            133
-#define TK_GROUP                          134
-#define TK_HAVING                         135
-#define TK_LIMIT                          136
-#define TK_OFFSET                         137
-#define TK_SLIMIT                         138
-#define TK_SOFFSET                        139
-#define TK_WHERE                          140
-#define TK_RESET                          141
-#define TK_QUERY                          142
-#define TK_SYNCDB                         143
-#define TK_ADD                            144
-#define TK_COLUMN                         145
-#define TK_MODIFY                         146
-#define TK_TAG                            147
-#define TK_CHANGE                         148
-#define TK_SET                            149
-#define TK_KILL                           150
-#define TK_CONNECTION                     151
-#define TK_STREAM                         152
-#define TK_COLON                          153
-#define TK_ABORT                          154
-#define TK_AFTER                          155
-#define TK_ATTACH                         156
-#define TK_BEFORE                         157
-#define TK_BEGIN                          158
-#define TK_CASCADE                        159
-#define TK_CLUSTER                        160
-#define TK_CONFLICT                       161
-#define TK_COPY                           162
-#define TK_DEFERRED                       163
-#define TK_DELIMITERS                     164
-#define TK_DETACH                         165
-#define TK_EACH                           166
-#define TK_END                            167
-#define TK_EXPLAIN                        168
-#define TK_FAIL                           169
-#define TK_FOR                            170
-#define TK_IGNORE                         171
-#define TK_IMMEDIATE                      172
-#define TK_INITIALLY                      173
-#define TK_INSTEAD                        174
-#define TK_MATCH                          175
+#define TK_MATCH                           22
+#define TK_GLOB                            23
+#define TK_BETWEEN                         24
+#define TK_IN                              25
+#define TK_GT                              26
+#define TK_GE                              27
+#define TK_LT                              28
+#define TK_LE                              29
+#define TK_BITAND                          30
+#define TK_BITOR                           31
+#define TK_LSHIFT                          32
+#define TK_RSHIFT                          33
+#define TK_PLUS                            34
+#define TK_MINUS                           35
+#define TK_DIVIDE                          36
+#define TK_TIMES                           37
+#define TK_STAR                            38
+#define TK_SLASH                           39
+#define TK_REM                             40
+#define TK_CONCAT                          41
+#define TK_UMINUS                          42
+#define TK_UPLUS                           43
+#define TK_BITNOT                          44
+#define TK_SHOW                            45
+#define TK_DATABASES                       46
+#define TK_TOPICS                          47
+#define TK_FUNCTIONS                       48
+#define TK_MNODES                          49
+#define TK_DNODES                          50
+#define TK_ACCOUNTS                        51
+#define TK_USERS                           52
+#define TK_MODULES                         53
+#define TK_QUERIES                         54
+#define TK_CONNECTIONS                     55
+#define TK_STREAMS                         56
+#define TK_VARIABLES                       57
+#define TK_SCORES                          58
+#define TK_GRANTS                          59
+#define TK_VNODES                          60
+#define TK_DOT                             61
+#define TK_CREATE                          62
+#define TK_TABLE                           63
+#define TK_STABLE                          64
+#define TK_DATABASE                        65
+#define TK_TABLES                          66
+#define TK_STABLES                         67
+#define TK_VGROUPS                         68
+#define TK_DROP                            69
+#define TK_TOPIC                           70
+#define TK_FUNCTION                        71
+#define TK_DNODE                           72
+#define TK_USER                            73
+#define TK_ACCOUNT                         74
+#define TK_USE                             75
+#define TK_DESCRIBE                        76
+#define TK_DESC                            77
+#define TK_ALTER                           78
+#define TK_PASS                            79
+#define TK_PRIVILEGE                       80
+#define TK_LOCAL                           81
+#define TK_COMPACT                         82
+#define TK_LP                              83
+#define TK_RP                              84
+#define TK_IF                              85
+#define TK_EXISTS                          86
+#define TK_AS                              87
+#define TK_OUTPUTTYPE                      88
+#define TK_AGGREGATE                       89
+#define TK_BUFSIZE                         90
+#define TK_PPS                             91
+#define TK_TSERIES                         92
+#define TK_DBS                             93
+#define TK_STORAGE                         94
+#define TK_QTIME                           95
+#define TK_CONNS                           96
+#define TK_STATE                           97
+#define TK_COMMA                           98
+#define TK_KEEP                            99
+#define TK_CACHE                          100
+#define TK_REPLICA                        101
+#define TK_QUORUM                         102
+#define TK_DAYS                           103
+#define TK_MINROWS                        104
+#define TK_MAXROWS                        105
+#define TK_BLOCKS                         106
+#define TK_CTIME                          107
+#define TK_WAL                            108
+#define TK_FSYNC                          109
+#define TK_COMP                           110
+#define TK_PRECISION                      111
+#define TK_UPDATE                         112
+#define TK_CACHELAST                      113
+#define TK_PARTITIONS                     114
+#define TK_UNSIGNED                       115
+#define TK_TAGS                           116
+#define TK_USING                          117
+#define TK_NULL                           118
+#define TK_NOW                            119
+#define TK_SELECT                         120
+#define TK_UNION                          121
+#define TK_ALL                            122
+#define TK_DISTINCT                       123
+#define TK_FROM                           124
+#define TK_VARIABLE                       125
+#define TK_INTERVAL                       126
+#define TK_EVERY                          127
+#define TK_SESSION                        128
+#define TK_STATE_WINDOW                   129
+#define TK_FILL                           130
+#define TK_SLIDING                        131
+#define TK_ORDER                          132
+#define TK_BY                             133
+#define TK_ASC                            134
+#define TK_GROUP                          135
+#define TK_HAVING                         136
+#define TK_LIMIT                          137
+#define TK_OFFSET                         138
+#define TK_SLIMIT                         139
+#define TK_SOFFSET                        140
+#define TK_WHERE                          141
+#define TK_RESET                          142
+#define TK_QUERY                          143
+#define TK_SYNCDB                         144
+#define TK_ADD                            145
+#define TK_COLUMN                         146
+#define TK_MODIFY                         147
+#define TK_TAG                            148
+#define TK_CHANGE                         149
+#define TK_SET                            150
+#define TK_KILL                           151
+#define TK_CONNECTION                     152
+#define TK_STREAM                         153
+#define TK_COLON                          154
+#define TK_ABORT                          155
+#define TK_AFTER                          156
+#define TK_ATTACH                         157
+#define TK_BEFORE                         158
+#define TK_BEGIN                          159
+#define TK_CASCADE                        160
+#define TK_CLUSTER                        161
+#define TK_CONFLICT                       162
+#define TK_COPY                           163
+#define TK_DEFERRED                       164
+#define TK_DELIMITERS                     165
+#define TK_DETACH                         166
+#define TK_EACH                           167
+#define TK_END                            168
+#define TK_EXPLAIN                        169
+#define TK_FAIL                           170
+#define TK_FOR                            171
+#define TK_IGNORE                         172
+#define TK_IMMEDIATE                      173
+#define TK_INITIALLY                      174
+#define TK_INSTEAD                        175
 #define TK_KEY                            176
 #define TK_OF                             177
 #define TK_RAISE                          178

src/query/inc/sql.y

@@ -11,7 +11,7 @@
 %left OR.
 %left AND.
 %right NOT.
-%left EQ NE ISNULL NOTNULL IS LIKE GLOB BETWEEN IN.
+%left EQ NE ISNULL NOTNULL IS LIKE MATCH GLOB BETWEEN IN.
 %left GT GE LT LE.
 %left BITAND BITOR LSHIFT RSHIFT.
 %left PLUS MINUS.
@@ -751,6 +751,9 @@ expr(A) ::= expr(X) REM   expr(Y).   {A = tSqlExprCreate(X, Y, TK_REM);   }
 // like expression
 expr(A) ::= expr(X) LIKE expr(Y).    {A = tSqlExprCreate(X, Y, TK_LIKE);  }
 
+// match expression
+expr(A) ::= expr(X) MATCH expr(Y).    {A = tSqlExprCreate(X, Y, TK_MATCH);  }
+
 //in expression
 expr(A) ::= expr(X) IN LP exprlist(Y) RP.   {A = tSqlExprCreate(X, (tSqlExpr*)Y, TK_IN); }
 

src/query/src/qFilter.c

@@ -28,6 +28,7 @@ OptrStr gOptrStr[] = {
   {TSDB_RELATION_GREATER_EQUAL,            ">="},
   {TSDB_RELATION_NOT_EQUAL,                "!="},
   {TSDB_RELATION_LIKE,                     "like"},
+  {TSDB_RELATION_MATCH,                    "match"},
   {TSDB_RELATION_ISNULL,                   "is null"},
   {TSDB_RELATION_NOTNULL,                  "not null"},
   {TSDB_RELATION_IN,                       "in"},
@@ -156,7 +157,7 @@ int8_t filterGetRangeCompFuncFromOptrs(uint8_t optr, uint8_t optr2) {
 __compar_fn_t gDataCompare[] = {compareInt32Val, compareInt8Val, compareInt16Val, compareInt64Val, compareFloatVal,
   compareDoubleVal, compareLenPrefixedStr, compareStrPatternComp, compareFindItemInSet, compareWStrPatternComp, 
   compareLenPrefixedWStr, compareUint8Val, compareUint16Val, compareUint32Val, compareUint64Val,
-  setCompareBytes1, setCompareBytes2, setCompareBytes4, setCompareBytes8
+  setCompareBytes1, setCompareBytes2, setCompareBytes4, setCompareBytes8, compareStrRegexComp,
 };
 
 int8_t filterGetCompFuncIdx(int32_t type, int32_t optr) {
@@ -195,7 +196,9 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr) {
     case TSDB_DATA_TYPE_FLOAT:     comparFn = 4;  break;
     case TSDB_DATA_TYPE_DOUBLE:    comparFn = 5; break;
     case TSDB_DATA_TYPE_BINARY: {
-      if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
+      if (optr == TSDB_RELATION_MATCH) {
+        comparFn = 19;
+      } else if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
         comparFn = 7;
       } else if (optr == TSDB_RELATION_IN) {
         comparFn = 8;
@@ -207,7 +210,9 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr) {
     }
   
     case TSDB_DATA_TYPE_NCHAR: {
-      if (optr == TSDB_RELATION_LIKE) {
+      if (optr == TSDB_RELATION_MATCH) {
+        comparFn = 19;
+      } else if (optr == TSDB_RELATION_LIKE) {
         comparFn = 9;
       } else if (optr == TSDB_RELATION_IN) {
         comparFn = 8;
@@ -1871,6 +1876,9 @@ bool filterDoCompare(__compar_fn_t func, uint8_t optr, void *left, void *right)
     case TSDB_RELATION_LIKE: {
       return ret == 0;
     }
+    case TSDB_RELATION_MATCH: {
+      return ret == 0;
+    }
     case TSDB_RELATION_IN: {
       return ret == 1;
     }
@@ -2641,7 +2649,7 @@ int32_t filterRmUnitByRange(SFilterInfo *info, SDataStatis *pDataStatis, int32_t
     }
 
     if (cunit->optr == TSDB_RELATION_ISNULL || cunit->optr == TSDB_RELATION_NOTNULL 
-     || cunit->optr == TSDB_RELATION_IN || cunit->optr == TSDB_RELATION_LIKE
+     || cunit->optr == TSDB_RELATION_IN || cunit->optr == TSDB_RELATION_LIKE || cunit->optr == TSDB_RELATION_MATCH
      || cunit->optr == TSDB_RELATION_NOT_EQUAL) {
       continue;
     }

src/tsdb/src/tsdbRead.c

@@ -3709,6 +3709,9 @@ static bool tableFilterFp(const void* pNode, void* param) {
     case TSDB_RELATION_LIKE: {
       return ret == 0;
     }
+    case TSDB_RELATION_MATCH: {
+      return ret == 0;
+    }
     case TSDB_RELATION_IN: {
       return ret == 1;
     }
@@ -4042,6 +4045,8 @@ static int32_t setQueryCond(tQueryInfo *queryColInfo, SQueryCond* pCond) {
     pCond->start->v    = queryColInfo->q; 
   } else if (optr == TSDB_RELATION_LIKE) {
     assert(0);
+  } else if (optr == TSDB_RELATION_MATCH) {
+    assert(0);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -4199,7 +4204,7 @@ static void queryIndexlessColumn(SSkipList* pSkipList, tQueryInfo* pQueryInfo, S
     if (pQueryInfo->sch.colId == TSDB_TBNAME_COLUMN_INDEX) {
       if (pQueryInfo->optr == TSDB_RELATION_IN) {
         addToResult = pQueryInfo->compare(name, pQueryInfo->q);
-      } else if (pQueryInfo->optr == TSDB_RELATION_LIKE) {
+      } else if (pQueryInfo->optr == TSDB_RELATION_LIKE || pQueryInfo->optr == TSDB_RELATION_MATCH) {
         addToResult = !pQueryInfo->compare(name, pQueryInfo->q);
       }
     } else {
@@ -4231,7 +4236,8 @@ void getTableListfromSkipList(tExprNode *pExpr, SSkipList *pSkipList, SArray *re
     param->setupInfoFn(pExpr, param->pExtInfo);
 
     tQueryInfo *pQueryInfo = pExpr->_node.info;
-    if (pQueryInfo->indexed && (pQueryInfo->optr != TSDB_RELATION_LIKE && pQueryInfo->optr != TSDB_RELATION_IN)) {
+    if (pQueryInfo->indexed && (pQueryInfo->optr != TSDB_RELATION_LIKE && pQueryInfo->optr != TSDB_RELATION_MATCH
+                                && pQueryInfo->optr != TSDB_RELATION_IN)) {
       queryIndexedColumn(pSkipList, pQueryInfo, result);
     } else {
       queryIndexlessColumn(pSkipList, pQueryInfo, result, param->nodeFilterFn);

src/util/inc/tcompare.h

@@ -26,6 +26,7 @@ extern "C" {
 #define TSDB_PATTERN_NOMATCH 1
 #define TSDB_PATTERN_NOWILDCARDMATCH 2
 #define TSDB_PATTERN_STRING_DEFAULT_LEN 100
+#define TSDB_REGEX_STRING_DEFAULT_LEN 128
 
 #define FLT_COMPAR_TOL_FACTOR    4
 #define FLT_EQUAL(_x, _y)        (fabs((_x) - (_y)) <= (FLT_COMPAR_TOL_FACTOR * FLT_EPSILON))
@@ -82,6 +83,7 @@ int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight);
 
 int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight);
 int32_t compareStrPatternComp(const void* pLeft, const void* pRight);
+int32_t compareStrRegexComp(const void* pLeft, const void* pRight);
 int32_t compareFindItemInSet(const void *pLeft, const void* pRight);
 int32_t compareWStrPatternComp(const void* pLeft, const void* pRight);
 

src/util/src/tarray.c

@@ -112,14 +112,15 @@ void taosArrayRemoveBatch(SArray *pArray, const int32_t* pData, int32_t numOfEle
     i += 1;
   }
 
-  assert(i == pData[numOfElems - 1] + 1);
+  assert(i == pData[numOfElems - 1] + 1 && i <= size);
 
-  int32_t dstIndex = pData[numOfElems - 1] - numOfElems + 1;
   int32_t srcIndex = pData[numOfElems - 1] + 1;
-
+  int32_t dstIndex = pData[numOfElems - 1] - numOfElems + 1;
+  if (pArray->size - srcIndex > 0) {
     char* dst = TARRAY_GET_ELEM(pArray, dstIndex);
     char* src = TARRAY_GET_ELEM(pArray, srcIndex);
-  memmove(dst, src, pArray->elemSize * (pArray->size - numOfElems));
+    memmove(dst, src, pArray->elemSize * (pArray->size - srcIndex));
+  }
 
   pArray->size -= numOfElems;
 }

src/util/src/tcache.c

@@ -71,6 +71,8 @@ static pthread_once_t cacheThreadInit = PTHREAD_ONCE_INIT;
 static pthread_mutex_t guard          = PTHREAD_MUTEX_INITIALIZER;
 static SArray* pCacheArrayList        = NULL;
 static bool    stopRefreshWorker      = false;
+static bool    refreshWorkerNormalStopped       = false;
+static bool    refreshWorkerUnexpectedStopped   = false;
 
 static void doInitRefreshThread(void) {
   pCacheArrayList = taosArrayInit(4, POINTER_BYTES);
@@ -537,8 +539,10 @@ void taosCacheCleanup(SCacheObj *pCacheObj) {
   pCacheObj->deleting = 1;
 
   // wait for the refresh thread quit before destroying the cache object.
-  // But in the dll, the child thread will be killed before atexit takes effect.So here we only wait for 2 seconds.
-  for (int i = 0; i < 40&&atomic_load_8(&pCacheObj->deleting) != 0; i++) {
+  // But in the dll, the child thread will be killed before atexit takes effect.
+  while(atomic_load_8(&pCacheObj->deleting) != 0) {
+    if (refreshWorkerNormalStopped) break;    
+    if (refreshWorkerUnexpectedStopped) return;    
     taosMsleep(50);
   }
 
@@ -677,6 +681,12 @@ static void doCacheRefresh(SCacheObj* pCacheObj, int64_t time, __cache_free_fn_t
   taosHashCondTraverse(pCacheObj->pHashTable, travHashTableFn, &sup);
 }
 
+void taosCacheRefreshWorkerUnexpectedStopped(void) {
+  if(!refreshWorkerNormalStopped) {
+    refreshWorkerUnexpectedStopped=true;
+  }
+}
+
 void* taosCacheTimedRefresh(void *handle) {
   assert(pCacheArrayList != NULL);
   uDebug("cache refresh thread starts");
@@ -685,6 +695,7 @@ void* taosCacheTimedRefresh(void *handle) {
 
   const int32_t SLEEP_DURATION = 500; //500 ms
   int64_t count = 0;
+  atexit(taosCacheRefreshWorkerUnexpectedStopped);
 
   while(1) {
     taosMsleep(SLEEP_DURATION);
@@ -749,6 +760,7 @@ void* taosCacheTimedRefresh(void *handle) {
 
   pCacheArrayList = NULL;
   pthread_mutex_destroy(&guard);
+  refreshWorkerNormalStopped=true;
 
   uDebug("cache refresh thread quits");
   return NULL;
@@ -763,6 +775,6 @@ void taosCacheRefresh(SCacheObj *pCacheObj, __cache_free_fn_t fp) {
   doCacheRefresh(pCacheObj, now, fp);
 }
 
-void taosStopCacheRefreshWorker() {
-  stopRefreshWorker = false;
+void taosStopCacheRefreshWorker(void) {
+  stopRefreshWorker = true;
 }
\ No newline at end of file

src/util/src/tcompare.c

@@ -12,11 +12,17 @@
  * 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 _BSD_SOURCE
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE
+#define _DEFAULT_SOURCE
 
-#include "os.h"
-#include "ttype.h"
 #include "tcompare.h"
+#include "tulog.h"
 #include "hash.h"
+#include "regex.h"
+#include "os.h"
+#include "ttype.h"
 
 int32_t setCompareBytes1(const void *pLeft, const void *pRight) {
   return NULL != taosHashGet((SHashObj *)pRight, pLeft, 1) ? 1 : 0;
@@ -344,6 +350,43 @@ int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
   return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
 
+int32_t compareStrRegexComp(const void* pLeft, const void* pRight) {
+  size_t sz = varDataLen(pRight);
+  char *pattern = malloc(sz + 1);
+  memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
+  pattern[sz] = 0;
+
+  sz = varDataLen(pLeft);
+  char *str = malloc(sz + 1);
+  memcpy(str, varDataVal(pLeft), sz);
+  str[sz] = 0;
+
+  int errCode = 0;
+  regex_t regex;
+  char    msgbuf[256] = {0};
+
+  int cflags = REG_EXTENDED;
+  if ((errCode = regcomp(&regex, pattern, cflags)) != 0) {
+    regerror(errCode, &regex, msgbuf, sizeof(msgbuf));
+    uError("Failed to compile regex pattern %s. reason %s", pattern, msgbuf);
+    regfree(&regex);
+    free(str);
+    free(pattern);
+    return 1;
+  }
+
+  errCode = regexec(&regex, str, 0, NULL, 0);
+  if (errCode != 0 && errCode != REG_NOMATCH) {
+    regerror(errCode, &regex, msgbuf, sizeof(msgbuf));
+    uDebug("Failed to match %s with pattern %s, reason %s", str, pattern, msgbuf)
+  }
+  int32_t result = (errCode == 0) ? 0 : 1;
+  regfree(&regex);
+  free(str);
+  free(pattern);
+  return result;
+}
+
 int32_t taosArrayCompareString(const void* a, const void* b) {
   const char* x = *(const char**)a;
   const char* y = *(const char**)b;
@@ -405,7 +448,9 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
     case TSDB_DATA_TYPE_FLOAT:     comparFn = compareFloatVal;  break;
     case TSDB_DATA_TYPE_DOUBLE:    comparFn = compareDoubleVal; break;
     case TSDB_DATA_TYPE_BINARY: {
-      if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
+      if (optr == TSDB_RELATION_MATCH) {
+        comparFn = compareStrRegexComp;
+      } else if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
         comparFn = compareStrPatternComp;
       } else if (optr == TSDB_RELATION_IN) {
         comparFn = compareFindItemInSet;
@@ -417,7 +462,9 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
     }
 
     case TSDB_DATA_TYPE_NCHAR: {
-      if (optr == TSDB_RELATION_LIKE) {
+      if (optr == TSDB_RELATION_MATCH) {
+        comparFn = compareStrRegexComp;
+      } else if (optr == TSDB_RELATION_LIKE) {
         comparFn = compareWStrPatternComp;
       } else if (optr == TSDB_RELATION_IN) {
         comparFn = compareFindItemInSet;

src/util/src/ttokenizer.c

@@ -53,6 +53,7 @@ static SKeyword keywordTable[] = {
     {"NOTNULL",      TK_NOTNULL},
     {"IS",           TK_IS},
     {"LIKE",         TK_LIKE},
+    {"MATCH",        TK_MATCH},
     {"GLOB",         TK_GLOB},
     {"BETWEEN",      TK_BETWEEN},
     {"IN",           TK_IN},

tests/connectorTest/C#Test/nanosupport/TDengineDriver.cs

+/*
+ * 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/>.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace TDengineDriver
+{
+    enum TDengineDataType
+    {
+        TSDB_DATA_TYPE_NULL = 0,     // 1 bytes
+        TSDB_DATA_TYPE_BOOL = 1,     // 1 bytes
+        TSDB_DATA_TYPE_TINYINT = 2,  // 1 bytes
+        TSDB_DATA_TYPE_SMALLINT = 3, // 2 bytes
+        TSDB_DATA_TYPE_INT = 4,      // 4 bytes
+        TSDB_DATA_TYPE_BIGINT = 5,   // 8 bytes
+        TSDB_DATA_TYPE_FLOAT = 6,    // 4 bytes
+        TSDB_DATA_TYPE_DOUBLE = 7,   // 8 bytes
+        TSDB_DATA_TYPE_BINARY = 8,   // string
+        TSDB_DATA_TYPE_TIMESTAMP = 9,// 8 bytes
+        TSDB_DATA_TYPE_NCHAR = 10,   // unicode string
+        TSDB_DATA_TYPE_UTINYINT = 11,// 1 byte
+        TSDB_DATA_TYPE_USMALLINT= 12,// 2 bytes
+        TSDB_DATA_TYPE_UINT = 13,    // 4 bytes
+        TSDB_DATA_TYPE_UBIGINT= 14   // 8 bytes
+    }
+
+    enum TDengineInitOption
+    {
+        TSDB_OPTION_LOCALE = 0,
+        TSDB_OPTION_CHARSET = 1,
+        TSDB_OPTION_TIMEZONE = 2,
+        TDDB_OPTION_CONFIGDIR = 3,
+        TDDB_OPTION_SHELL_ACTIVITY_TIMER = 4
+    }
+
+    class TDengineMeta
+    {
+        public string name;
+        public short size;
+        public byte type;
+        public string TypeName()
+        {
+            switch ((TDengineDataType)type)
+            {
+                case TDengineDataType.TSDB_DATA_TYPE_BOOL:
+                    return "BOOL";
+                case TDengineDataType.TSDB_DATA_TYPE_TINYINT:
+                    return "TINYINT";
+                case TDengineDataType.TSDB_DATA_TYPE_SMALLINT:
+                    return "SMALLINT";
+                case TDengineDataType.TSDB_DATA_TYPE_INT:
+                    return "INT";
+                case TDengineDataType.TSDB_DATA_TYPE_BIGINT:
+                    return "BIGINT";
+                case TDengineDataType.TSDB_DATA_TYPE_UTINYINT:
+                    return "TINYINT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_USMALLINT:
+                    return "SMALLINT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_UINT:
+                    return "INT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_UBIGINT:
+                    return "BIGINT UNSIGNED";
+                case TDengineDataType.TSDB_DATA_TYPE_FLOAT:
+                    return "FLOAT";
+                case TDengineDataType.TSDB_DATA_TYPE_DOUBLE:
+                    return "DOUBLE";
+                case TDengineDataType.TSDB_DATA_TYPE_BINARY:
+                    return "STRING";
+                case TDengineDataType.TSDB_DATA_TYPE_TIMESTAMP:
+                    return "TIMESTAMP";
+                case TDengineDataType.TSDB_DATA_TYPE_NCHAR:
+                    return "NCHAR";
+                default:
+                    return "undefine";
+            }
+        }
+    }
+
+    class TDengine
+    {
+        public const int TSDB_CODE_SUCCESS = 0;
+
+        [DllImport("taos", EntryPoint = "taos_init", CallingConvention = CallingConvention.Cdecl)]
+        static extern public void Init();
+
+        [DllImport("taos", EntryPoint = "taos_cleanup", CallingConvention = CallingConvention.Cdecl)]
+        static extern public void Cleanup();
+
+        [DllImport("taos", EntryPoint = "taos_options", CallingConvention = CallingConvention.Cdecl)]
+        static extern public void Options(int option, string value);
+
+        [DllImport("taos", EntryPoint = "taos_connect", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr Connect(string ip, string user, string password, string db, short port);
+
+        [DllImport("taos", EntryPoint = "taos_errstr", CallingConvention = CallingConvention.Cdecl)]
+        static extern private IntPtr taos_errstr(IntPtr res);
+        static public string Error(IntPtr res)
+        {
+            IntPtr errPtr = taos_errstr(res);
+            return Marshal.PtrToStringAnsi(errPtr);
+        }
+
+        [DllImport("taos", EntryPoint = "taos_errno", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int ErrorNo(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_query", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr Query(IntPtr conn, string sqlstr);
+
+        [DllImport("taos", EntryPoint = "taos_affected_rows", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int AffectRows(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_field_count", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int FieldCount(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_fetch_fields", CallingConvention = CallingConvention.Cdecl)]
+        static extern private IntPtr taos_fetch_fields(IntPtr res);
+        static public List<TDengineMeta> FetchFields(IntPtr res)
+        {
+            const int fieldSize = 68;
+
+            List<TDengineMeta> metas = new List<TDengineMeta>();
+            if (res == IntPtr.Zero)
+            {
+                return metas;
+            }
+
+            int fieldCount = FieldCount(res);
+            IntPtr fieldsPtr = taos_fetch_fields(res);
+
+            for (int i = 0; i < fieldCount; ++i)
+            {
+                int offset = i * fieldSize;
+
+                TDengineMeta meta = new TDengineMeta();
+                meta.name = Marshal.PtrToStringAnsi(fieldsPtr + offset);
+                meta.type = Marshal.ReadByte(fieldsPtr + offset + 65);
+                meta.size = Marshal.ReadInt16(fieldsPtr + offset + 66);
+                metas.Add(meta);
+            }
+
+            return metas;
+        }
+
+        [DllImport("taos", EntryPoint = "taos_fetch_row", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr FetchRows(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_free_result", CallingConvention = CallingConvention.Cdecl)]
+        static extern public IntPtr FreeResult(IntPtr res);
+
+        [DllImport("taos", EntryPoint = "taos_close", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int Close(IntPtr taos);
+        //get precisionin parameter restultset
+        [DllImport("taos", EntryPoint = "taos_result_precision", CallingConvention = CallingConvention.Cdecl)]
+        static extern public int ResultPrecision(IntPtr taos);
+    }
+}

tests/connectorTest/nodejsTest/nanosupport/nanosecondTest.js

+const taos = require('td2.0-connector');
+var conn = taos.connect({host:"localhost", user:"root", password:"taosdata", config:"/etc/taos",port:6030})
+var c1 = conn.cursor();
+
+
+function checkData(sql,row,col,data){
+
+
+    console.log(sql)
+    c1.execute(sql)
+    var d = c1.fetchall();
+    let checkdata = d[row][col];
+    if (checkdata == data)  {
+        
+        console.log('check pass')
+    }
+    else{
+        console.log('check failed')
+        console.log('checked is :',checkdata) 
+        console.log("expected is :",data)
+        
+
+    }
+}
+
+
+// nano basic case
+
+c1.execute('reset query cache')
+c1.execute('drop database if exists db')
+c1.execute('create database db precision "ns";')
+c1.execute('use db');
+c1.execute('create table tb (ts timestamp, speed int)')
+c1.execute('insert into tb values(\'2021-06-10 00:00:00.100000001\', 1);')
+c1.execute('insert into tb values(1623254400150000000, 2);')
+c1.execute('import into tb values(1623254400300000000, 3);')
+c1.execute('import into tb values(1623254400299999999, 4);')
+c1.execute('insert into tb values(1623254400300000001, 5);')
+c1.execute('insert into tb values(1623254400999999999, 7);')
+c1.execute('insert into tb values(1623254400123456789, 8);')
+sql = 'select * from tb;'
+
+console.log('*******************************************')
+console.log('this is area about checkdata result')
+//check data about insert data
+checkData(sql,0,0,'2021-06-10 00:00:00.100000001')
+checkData(sql,1,0,'2021-06-10 00:00:00.123456789') 
+checkData(sql,2,0,'2021-06-10 00:00:00.150000000')
+checkData(sql,3,0,'2021-06-10 00:00:00.299999999') 
+checkData(sql,4,0,'2021-06-10 00:00:00.300000000')
+checkData(sql,5,0,'2021-06-10 00:00:00.300000001')
+checkData(sql,6,0,'2021-06-10 00:00:00.999999999') 
+checkData(sql,0,1,1) 
+checkData(sql,1,1,8)
+checkData(sql,2,1,2)
+checkData(sql,5,1,5)
+
+
+
+// us basic case
+
+c1.execute('reset query cache')
+c1.execute('drop database if exists usdb')
+c1.execute('create database usdb precision "us";')
+c1.execute('use usdb');
+c1.execute('create table tb (ts timestamp, speed int)')
+c1.execute('insert into tb values(\'2021-06-10 00:00:00.100001\', 1);')
+c1.execute('insert into tb values(1623254400150000, 2);')
+c1.execute('import into tb values(1623254400300000, 3);')
+c1.execute('import into tb values(1623254400299999, 4);')
+c1.execute('insert into tb values(1623254400300001, 5);')
+c1.execute('insert into tb values(1623254400999999, 7);')
+c1.execute('insert into tb values(1623254400123789, 8);')
+sql = 'select * from tb;'
+
+console.log('*******************************************')
+
+//check data about insert data
+checkData(sql,0,0,'2021-06-10 00:00:00.100001')
+checkData(sql,1,0,'2021-06-10 00:00:00.123789') 
+checkData(sql,2,0,'2021-06-10 00:00:00.150000')
+checkData(sql,3,0,'2021-06-10 00:00:00.299999') 
+checkData(sql,4,0,'2021-06-10 00:00:00.300000')
+checkData(sql,5,0,'2021-06-10 00:00:00.300001')
+checkData(sql,6,0,'2021-06-10 00:00:00.999999') 
+checkData(sql,0,1,1) 
+checkData(sql,1,1,8)
+checkData(sql,2,1,2)
+checkData(sql,5,1,5)
+
+console.log('*******************************************')
+
+// ms basic case
+
+c1.execute('reset query cache')
+c1.execute('drop database if exists msdb')
+c1.execute('create database msdb precision "ms";')
+c1.execute('use msdb');
+c1.execute('create table tb (ts timestamp, speed int)')
+c1.execute('insert into tb values(\'2021-06-10 00:00:00.101\', 1);')
+c1.execute('insert into tb values(1623254400150, 2);')
+c1.execute('import into tb values(1623254400300, 3);')
+c1.execute('import into tb values(1623254400299, 4);')
+c1.execute('insert into tb values(1623254400301, 5);')
+c1.execute('insert into tb values(1623254400789, 7);')
+c1.execute('insert into tb values(1623254400999, 8);')
+sql = 'select * from tb;'
+
+console.log('*******************************************')
+console.log('this is area about checkdata result')
+//check data about insert data
+checkData(sql,0,0,'2021-06-10 00:00:00.101')
+checkData(sql,1,0,'2021-06-10 00:00:00.150') 
+checkData(sql,2,0,'2021-06-10 00:00:00.299')
+checkData(sql,3,0,'2021-06-10 00:00:00.300') 
+checkData(sql,4,0,'2021-06-10 00:00:00.301')
+checkData(sql,5,0,'2021-06-10 00:00:00.789')
+checkData(sql,6,0,'2021-06-10 00:00:00.999')
+checkData(sql,0,1,1) 
+checkData(sql,1,1,2)
+checkData(sql,2,1,4)
+checkData(sql,5,1,7) 
+
+console.log('*******************************************')
+
+// offfical query result to show 
+// console.log('this is area about fetch all data')
+// var query = c1.query(sql)
+// var promise = query.execute();
+// promise.then(function(result) {
+//   result.pretty(); 
+// });
+
+console.log('*******************************************')
+c1.execute('use db')
+
+sql2 = 'select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400100000002;'
+checkData(sql2,0,0,1)
+
+sql3 = 'select count(*) from tb where ts > \'2021-06-10 0:00:00.100000001\' and ts < \'2021-06-10 0:00:00.160000000\';'
+checkData(sql3,0,0,2)
+
+sql4 = 'select count(*) from tb where ts > 1623254400100000000 and ts < 1623254400150000000;'
+checkData(sql4,0,0,2)
+
+sql5 = 'select count(*) from tb where ts > \'2021-06-10 0:00:00.100000000\' and ts < \'2021-06-10 0:00:00.150000000\';'
+checkData(sql5,0,0,2)
+
+sql6 = 'select count(*) from tb where ts > 1623254400400000000;'
+checkData(sql6,0,0,1)
+
+sql7 = 'select count(*) from tb where ts < \'2021-06-10 00:00:00.400000000\';'
+checkData(sql7,0,0,6)
+
+sql8 = 'select count(*) from tb where ts > now + 400000000b;'
+c1.execute(sql8)
+
+sql9 = 'select count(*) from tb where ts >= \'2021-06-10 0:00:00.100000001\';'
+checkData(sql9,0,0,7)
+
+sql10 = 'select count(*) from tb where ts <= 1623254400300000000;'
+checkData(sql10,0,0,5)
+
+sql11 = 'select count(*) from tb where ts = \'2021-06-10 0:00:00.000000000\';'
+c1.execute(sql11)
+
+sql12 = 'select count(*) from tb where ts = 1623254400150000000;'
+checkData(sql12,0,0,1)
+
+sql13 = 'select count(*) from tb where ts = \'2021-06-10 0:00:00.100000001\';'
+checkData(sql13,0,0,1)
+
+sql14 = 'select count(*) from tb where ts between 1623254400000000000 and 1623254400400000000;'
+checkData(sql14,0,0,6)
+
+sql15 = 'select count(*) from tb where ts between \'2021-06-10 0:00:00.299999999\' and \'2021-06-10 0:00:00.300000001\';'
+checkData(sql15,0,0,3)
+
+sql16 = 'select avg(speed) from tb interval(5000000000b);'
+checkData(sql16,0,0,'2021-06-10 00:00:00.000000000')
+
+sql17 = 'select avg(speed) from tb interval(100000000b)'
+checkData(sql17,0,1,3.6666666666666665)
+checkData(sql17,1,1,4.000000000)
+
+checkData(sql17,2,0,'2021-06-10 00:00:00.300000000')
+checkData(sql17,3,0,'2021-06-10 00:00:00.900000000')
+
+console.log("print break ")
+
+// sql18 = 'select avg(speed) from tb interval(999b)'
+// c1.execute(sql18)
+
+console.log("print break2 ")
+sql19 = 'select avg(speed) from tb interval(1u);'
+checkData(sql19,2,1,2.000000000)
+checkData(sql19,3,0,'2021-06-10 00:00:00.299999000')
+
+sql20 = 'select avg(speed) from tb interval(100000000b) sliding (100000000b);'
+checkData(sql20,2,1,4.000000000)
+checkData(sql20,3,0,'2021-06-10 00:00:00.900000000')
+
+sql21 = 'select last(*) from tb;'
+checkData(sql21,0,0,'2021-06-10 00:00:00.999999999')
+
+sql22 = 'select first(*) from tb;'
+checkData(sql22,0,0,'2021-06-10 00:00:00.100000001')
+
+// timezone support 
+
+console.log('testing nanosecond support in other timestamps')
+
+c1.execute('create table tb2 (ts timestamp, speed int, ts2 timestamp);')
+c1.execute('insert into tb2 values(\'2021-06-10 0:00:00.100000001\', 1, \'2021-06-11 0:00:00.100000001\');')
+c1.execute('insert into tb2 values(1623254400150000000, 2, 1623340800150000000);')
+c1.execute('import into tb2 values(1623254400300000000, 3, 1623340800300000000);')
+c1.execute('import into tb2 values(1623254400299999999, 4, 1623340800299999999);')
+c1.execute('insert into tb2 values(1623254400300000001, 5, 1623340800300000001);')
+c1.execute('insert into tb2 values(1623254400999999999, 7, 1623513600999999999);')
+
+sql23 = 'select * from tb2;'
+checkData(sql23,0,0,'2021-06-10 00:00:00.100000001')
+checkData(sql23,1,0,'2021-06-10 00:00:00.150000000')
+checkData(sql23,2,1,4)
+checkData(sql23,3,1,3)
+checkData(sql23,4,2,'2021-06-11 00:00:00.300000001')
+checkData(sql23,5,2,'2021-06-13 00:00:00.999999999')
+
+sql24 = 'select count(*) from tb2 where ts2 >= \'2021-06-11 0:00:00.100000001\';'
+checkData(sql24,0,0,6)
+
+sql25 = 'select count(*) from tb2 where ts2 <= 1623340800400000000;'
+checkData(sql25,0,0,5)
+
+sql26 = 'select count(*) from tb2 where ts2 = \'2021-06-11 0:00:00.300000001\';'
+checkData(sql26,0,0,1)
+
+sql27 = 'select count(*) from tb2 where ts2 = 1623340800300000001;'
+checkData(sql27,0,0,1)
+
+sql28 = 'select count(*) from tb2 where ts2 between 1623340800000000000 and 1623340800450000000;'
+checkData(sql28,0,0,5)
+
+sql29 = 'select count(*) from tb2 where ts2 between \'2021-06-11 0:00:00.299999999\' and \'2021-06-11 0:00:00.300000001\';'
+checkData(sql29,0,0,3)
+
+sql30 = 'select count(*) from tb2 where ts2 <> 1623513600999999999;'
+checkData(sql30,0,0,5)
+
+sql31 = 'select count(*) from tb2 where ts2 <> \'2021-06-11 0:00:00.100000001\';'
+checkData(sql31,0,0,5)
+
+sql32 = 'select count(*) from tb2 where ts2 != 1623513600999999999;'
+checkData(sql32,0,0,5)
+
+sql33 = 'select count(*) from tb2 where ts2 != \'2021-06-11 0:00:00.100000001\';'
+checkData(sql33,0,0,5)
+
+c1.execute('insert into tb2 values(now + 500000000b, 6, now +2d);')
+
+sql34 = 'select count(*) from tb2;'
+checkData(sql34,0,0,7)
+
+
+// check timezone support 
+
+c1.execute('use db;')
+c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
+c1.execute('insert into stb1 using st tags("2021-06-10 0:00:00.123456789" , 1 ) values("2021-06-10T0:00:00.123456789+07:00" , 1.0);' )
+sql35 = 'select first(*) from stb1;'
+checkData(sql35,0,0,'2021-06-10 01:00:00.123456789')
+
+c1.execute('use usdb;')
+c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
+c1.execute('insert into stb1 using st tags("2021-06-10 0:00:00.123456" , 1 ) values("2021-06-10T0:00:00.123456+07:00" , 1.0);' )
+sql36 = 'select first(*) from stb1;'
+checkData(sql36,0,0,'2021-06-10 01:00:00.123456')
+
+c1.execute('use msdb;')
+c1.execute('create stable st (ts timestamp ,speed float ) tags(time timestamp ,id int);')
+c1.execute('insert into stb1 using st tags("2021-06-10 0:00:00.123456" , 1 ) values("2021-06-10T0:00:00.123456+07:00" , 1.0);' )
+sql36 = 'select first(*) from stb1;'
+checkData(sql36,0,0,'2021-06-10 01:00:00.123')
+
+
+
+
+
+
+

tests/connectorTest/nodejsTest/nodetaos/connection.js

+const TDengineCursor = require('./cursor')
+const CTaosInterface = require('./cinterface')
+module.exports = TDengineConnection;
+
+/**
+ * TDengine Connection Class
+ * @param {object} options - Options for configuring the connection with TDengine
+ * @return {TDengineConnection}
+ * @class TDengineConnection
+ * @constructor
+ * @example
+ * //Initialize a new connection
+ * var conn = new TDengineConnection({host:"127.0.0.1", user:"root", password:"taosdata", config:"/etc/taos",port:0})
+ *
+ */
+function TDengineConnection(options) {
+  this._conn = null;
+  this._host = null;
+  this._user = "root"; //The default user
+  this._password = "taosdata"; //The default password
+  this._database = null;
+  this._port = 0;
+  this._config = null;
+  this._chandle = null;
+  this._configConn(options)
+  return this;
+}
+/**
+ * Configure the connection to TDengine
+ * @private
+ * @memberof TDengineConnection
+ */
+TDengineConnection.prototype._configConn = function _configConn(options) {
+  if (options['host']) {
+    this._host = options['host'];
+  }
+  if (options['user']) {
+    this._user = options['user'];
+  }
+  if (options['password']) {
+    this._password = options['password'];
+  }
+  if (options['database']) {
+    this._database = options['database'];
+  }
+  if (options['port']) {
+    this._port = options['port'];
+  }
+  if (options['config']) {
+    this._config = options['config'];
+  }
+  this._chandle = new CTaosInterface(this._config);
+  this._conn = this._chandle.connect(this._host, this._user, this._password, this._database, this._port);
+}
+/** Close the connection to TDengine */
+TDengineConnection.prototype.close = function close() {
+  this._chandle.close(this._conn);
+}
+/**
+ * Initialize a new cursor to interact with TDengine with
+ * @return {TDengineCursor}
+ */
+TDengineConnection.prototype.cursor = function cursor() {
+  //Pass the connection object to the cursor
+  return new TDengineCursor(this);
+}
+TDengineConnection.prototype.commit = function commit() {
+  return this;
+}
+TDengineConnection.prototype.rollback = function rollback() {
+  return this;
+}
+/**
+ * Clear the results from connector
+ * @private
+ */
+/*
+ TDengineConnection.prototype._clearResultSet = function _clearResultSet() {
+  var result = this._chandle.useResult(this._conn).result;
+  if (result) {
+    this._chandle.freeResult(result)
+  }
+}
+*/

tests/connectorTest/nodejsTest/nodetaos/constants.js

+/**
+ * Contains the the definitions/values assigned to various field types
+ * @module FieldTypes
+ */
+/**
+ * TDengine Field Types and their type codes
+ * @typedef {Object} FieldTypes
+ * @global
+ * @property {number} C_NULL - Null
+ * @property {number} C_BOOL - Boolean. Note, 0x02 is the C_BOOL_NULL value.
+ * @property {number} C_TINYINT - Tiny Int, values in the range [-2^7+1, 2^7-1]. Note, -2^7 has been used as the C_TINYINT_NULL value
+ * @property {number} C_SMALLINT - Small Int, values in the range [-2^15+1, 2^15-1]. Note, -2^15 has been used as the C_SMALLINT_NULL value
+ * @property {number} C_INT - Int, values in the range [-2^31+1, 2^31-1]. Note, -2^31 has been used as the C_INT_NULL value
+ * @property {number} C_BIGINT - Big Int, values in the range [-2^59, 2^59].
+ * @property {number} C_FLOAT - Float, values in the range [-3.4E38, 3.4E38], accurate up to 6-7 decimal places.
+ * @property {number} C_DOUBLE - Double, values in the range [-1.7E308, 1.7E308], accurate up to 15-16 decimal places.
+ * @property {number} C_BINARY - Binary, encoded in utf-8.
+ * @property {number} C_TIMESTAMP - Timestamp in format "YYYY:MM:DD HH:MM:SS.MMM". Measured in number of milliseconds passed after
+                                    1970-01-01 08:00:00.000 GMT.
+ * @property {number} C_NCHAR - NChar field type encoded in ASCII, a wide string.
+ *
+ *
+ *
+ * @property {number} C_TIMESTAMP_MILLI - The code for millisecond timestamps, as returned by libtaos.taos_result_precision(result).
+ * @property {number} C_TIMESTAMP_MICRO - The code for microsecond timestamps, as returned by libtaos.taos_result_precision(result).
+ */
+module.exports = {
+    C_NULL : 0,
+    C_BOOL : 1,
+    C_TINYINT : 2,
+    C_SMALLINT : 3,
+    C_INT : 4,
+    C_BIGINT : 5,
+    C_FLOAT : 6,
+    C_DOUBLE : 7,
+    C_BINARY : 8,
+    C_TIMESTAMP : 9,
+    C_NCHAR : 10,
+    // NULL value definition
+    // NOTE: These values should change according to C definition in tsdb.h
+    C_BOOL_NULL : 2,
+    C_TINYINT_NULL : -128,
+    C_SMALLINT_NULL : -32768,
+    C_INT_NULL : -2147483648,
+    C_BIGINT_NULL : -9223372036854775808,
+    C_FLOAT_NULL : 2146435072,
+    C_DOUBLE_NULL : -9223370937343148032,
+    C_NCHAR_NULL : 4294967295,
+    C_BINARY_NULL : 255,
+    C_TIMESTAMP_MILLI : 0,
+    C_TIMESTAMP_MICRO : 1,
+    getType,
+}
+
+const typeCodesToName = {
+  0 : 'Null',
+  1 : 'Boolean',
+  2 : 'Tiny Int',
+  3 : 'Small Int',
+  4 : 'Int',
+  5 : 'Big Int',
+  6 : 'Float',
+  7 : 'Double',
+  8 : 'Binary',
+  9 : 'Timestamp',
+  10 : 'Nchar',
+}
+
+/**
+ * @function
+ * @param {number} typecode - The code to get the name of the type for
+ * @return {string} Name of the field type
+ */
+function getType(typecode) {
+  return typeCodesToName[typecode];
+}

tests/connectorTest/nodejsTest/nodetaos/cursor.js

+const ref = require('ref-napi');
+require('./globalfunc.js')
+const CTaosInterface = require('./cinterface')
+const errors = require('./error')
+const TaosQuery = require('./taosquery')
+const { PerformanceObserver, performance } = require('perf_hooks');
+module.exports = TDengineCursor;
+
+/**
+ * @typedef {Object} Buffer - A Node.js buffer. Please refer to {@link https://nodejs.org/api/buffer.html} for more details
+ * @global
+ */
+
+/**
+ * @class TDengineCursor
+ * @classdesc  The TDengine Cursor works directly with the C Interface which works with TDengine. It refrains from
+ * returning parsed data and majority of functions return the raw data such as cursor.fetchall() as compared to the TaosQuery class which
+ * has functions that "prettify" the data and add more functionality and can be used through cursor.query("your query"). Instead of
+ * promises, the class and its functions use callbacks.
+ * @param {TDengineConnection} - The TDengine Connection this cursor uses to interact with TDengine
+ * @property {data} - Latest retrieved data from query execution. It is an empty array by default
+ * @property {fields} - Array of the field objects in order from left to right of the latest data retrieved
+ * @since 1.0.0
+ */
+function TDengineCursor(connection = null) {
+  //All parameters are store for sync queries only.
+  this._rowcount = -1;
+  this._connection = null;
+  this._result = null;
+  this._fields = null;
+  this.data = [];
+  this.fields = null;
+  if (connection != null) {
+    this._connection = connection
+    this._chandle = connection._chandle //pass through, just need library loaded.
+  }
+  else {
+    throw new errors.ProgrammingError("A TDengineConnection object is required to be passed to the TDengineCursor");
+  }
+
+}
+/**
+ * Get the row counts of the latest query
+ * @since 1.0.0
+ * @return {number} Rowcount
+ */
+TDengineCursor.prototype.rowcount = function rowcount() {
+  return this._rowcount;
+}
+/**
+ * Close the cursor by setting its connection to null and freeing results from the connection and resetting the results it has stored
+ * @return {boolean} Whether or not the cursor was succesfully closed
+ * @since 1.0.0
+ */
+TDengineCursor.prototype.close = function close() {
+  if (this._connection == null) {
+    return false;
+  }
+  this._connection._clearResultSet();
+  this._reset_result();
+  this._connection = null;
+  return true;
+}
+/**
+ * Create a TaosQuery object to perform a query to TDengine and retrieve data.
+ * @param {string} operation - The operation string to perform a query on
+ * @param {boolean} execute - Whether or not to immedietely perform the query. Default is false.
+ * @return {TaosQuery | Promise<TaosResult>} A TaosQuery object
+ * @example
+ * var query = cursor.query("select count(*) from meterinfo.meters");
+ * query.execute();
+ * @since 1.0.6
+ */
+TDengineCursor.prototype.query = function query(operation, execute = false) {
+  return new TaosQuery(operation, this, execute);
+}
+
+/**
+ * Execute a query. Also stores all the field meta data returned from the query into cursor.fields. It is preferable to use cursor.query() to create
+ * queries and execute them instead of using the cursor object directly.
+ * @param {string} operation - The query operation to execute in the taos shell
+ * @param {Object} options - Execution options object. quiet : true turns off logging from queries
+ * @param {boolean} options.quiet - True if you want to surpress logging such as "Query OK, 1 row(s) ..."
+ * @param {function} callback - A callback function to execute after the query is made to TDengine
+ * @return {number | Buffer} Number of affected rows or a Buffer that points to the results of the query
+ * @since 1.0.0
+ */
+TDengineCursor.prototype.execute = function execute(operation, options, callback) {
+  if (operation == undefined) {
+    throw new errors.ProgrammingError('No operation passed as argument');
+    return null;
+  }
+
+  if (typeof options == 'function') {
+    callback = options;
+  }
+  if (typeof options != 'object') options = {}
+  if (this._connection == null) {
+    throw new errors.ProgrammingError('Cursor is not connected');
+  }
+
+  this._reset_result();
+
+  let stmt = operation;
+  let time = 0;
+  let res;
+  if (options['quiet'] != true) {
+    const obs = new PerformanceObserver((items) => {
+      time = items.getEntries()[0].duration;
+      performance.clearMarks();
+    });
+    obs.observe({ entryTypes: ['measure'] });
+    performance.mark('A');
+    this._result = this._chandle.query(this._connection._conn, stmt);
+    performance.mark('B');
+    performance.measure('query', 'A', 'B');
+  }
+  else {
+    this._result = this._chandle.query(this._connection._conn, stmt);
+  }
+  res = this._chandle.errno(this._result);
+  if (res == 0) {
+    let fieldCount = this._chandle.fieldsCount(this._result);
+    if (fieldCount == 0) {
+      let affectedRowCount = this._chandle.affectedRows(this._result);
+      let response = this._createAffectedResponse(affectedRowCount, time)
+      if (options['quiet'] != true) {
+        console.log(response);
+      }
+      wrapCB(callback);
+      return affectedRowCount; //return num of affected rows, common with insert, use statements
+    }
+    else {
+      this._fields = this._chandle.useResult(this._result);
+      this.fields = this._fields;
+      wrapCB(callback);
+
+      return this._result; //return a pointer to the result
+    }
+  }
+  else {
+    throw new errors.ProgrammingError(this._chandle.errStr(this._result))
+  }
+
+}
+TDengineCursor.prototype._createAffectedResponse = function (num, time) {
+  return "Query OK, " + num + " row(s) affected (" + (time * 0.001).toFixed(8) + "s)";
+}
+TDengineCursor.prototype._createSetResponse = function (num, time) {
+  return "Query OK, " + num + " row(s) in set (" + (time * 0.001).toFixed(8) + "s)";
+}
+TDengineCursor.prototype.executemany = function executemany() {
+
+}
+TDengineCursor.prototype.fetchone = function fetchone() {
+
+}
+TDengineCursor.prototype.fetchmany = function fetchmany() {
+
+}
+/**
+ * Fetches all results from a query and also stores results into cursor.data. It is preferable to use cursor.query() to create
+ * queries and execute them instead of using the cursor object directly.
+ * @param {function} callback - callback function executing on the complete fetched data
+ * @return {Array<Array>} The resultant array, with entries corresponding to each retreived row from the query results, sorted in
+ * order by the field name ordering in the table.
+ * @since 1.0.0
+ * @example
+ * cursor.execute('select * from db.table');
+ * var data = cursor.fetchall(function(results) {
+ *   results.forEach(row => console.log(row));
+ * })
+ */
+TDengineCursor.prototype.fetchall = function fetchall(options, callback) {
+  if (this._result == null || this._fields == null) {
+    throw new errors.OperationalError("Invalid use of fetchall, either result or fields from query are null. First execute a query first");
+  }
+
+  let num_of_rows = this._chandle.affectedRows(this._result);
+  let data = new Array(num_of_rows);
+
+  this._rowcount = 0;
+
+  let time = 0;
+  const obs = new PerformanceObserver((items) => {
+    time += items.getEntries()[0].duration;
+    performance.clearMarks();
+  });
+  obs.observe({ entryTypes: ['measure'] });
+  performance.mark('A');
+  while (true) {
+    let blockAndRows = this._chandle.fetchBlock(this._result, this._fields);
+    // console.log(blockAndRows);
+    // break;
+    let block = blockAndRows.blocks;
+    let num_of_rows = blockAndRows.num_of_rows;
+    if (num_of_rows == 0) {
+      break;
+    }
+    this._rowcount += num_of_rows;
+    let numoffields = this._fields.length;
+    for (let i = 0; i < num_of_rows; i++) {
+      // data.push([]);
+
+      let rowBlock = new Array(numoffields);
+      for (let j = 0; j < numoffields; j++) {
+        rowBlock[j] = block[j][i];
+      }
+      data[this._rowcount - num_of_rows + i] = (rowBlock);
+      // data.push(rowBlock);
+    }
+
+  }
+  
+  performance.mark('B');
+  performance.measure('query', 'A', 'B');
+  let response = this._createSetResponse(this._rowcount, time)
+  console.log(response);
+
+  // this._connection._clearResultSet();
+  let fields = this.fields;
+  this._reset_result();
+  this.data = data;
+  this.fields = fields;
+
+  wrapCB(callback, data);
+
+  return data;
+}
+/**
+ * Asynchrnously execute a query to TDengine. NOTE, insertion requests must be done in sync if on the same table.
+ * @param {string} operation - The query operation to execute in the taos shell
+ * @param {Object} options - Execution options object. quiet : true turns off logging from queries
+ * @param {boolean} options.quiet - True if you want to surpress logging such as "Query OK, 1 row(s) ..."
+ * @param {function} callback - A callback function to execute after the query is made to TDengine
+ * @return {number | Buffer} Number of affected rows or a Buffer that points to the results of the query
+ * @since 1.0.0
+ */
+TDengineCursor.prototype.execute_a = function execute_a(operation, options, callback, param) {
+  if (operation == undefined) {
+    throw new errors.ProgrammingError('No operation passed as argument');
+    return null;
+  }
+  if (typeof options == 'function') {
+    //we expect the parameter after callback to be param
+    param = callback;
+    callback = options;
+  }
+  if (typeof options != 'object') options = {}
+  if (this._connection == null) {
+    throw new errors.ProgrammingError('Cursor is not connected');
+  }
+  if (typeof callback != 'function') {
+    throw new errors.ProgrammingError("No callback function passed to execute_a function");
+  }
+  // Async wrapper for callback;
+  var cr = this;
+
+  let asyncCallbackWrapper = function (param2, res2, resCode) {
+    if (typeof callback == 'function') {
+      callback(param2, res2, resCode);
+    }
+
+    if (resCode >= 0) {
+      //      let fieldCount = cr._chandle.numFields(res2);
+      //      if (fieldCount == 0) {
+      //        //cr._chandle.freeResult(res2);
+      //        return res2;
+      //      } 
+      //      else {
+      //        return res2;
+      //      }
+      return res2;
+
+    }
+    else {
+      throw new errors.ProgrammingError("Error occuring with use of execute_a async function. Status code was returned with failure");
+    }
+  }
+
+  let stmt = operation;
+  let time = 0;
+
+  // Use ref module to write to buffer in cursor.js instead of taosquery to maintain a difference in levels. Have taosquery stay high level
+  // through letting it pass an object as param
+  var buf = ref.alloc('Object');
+  ref.writeObject(buf, 0, param);
+  const obs = new PerformanceObserver((items) => {
+    time = items.getEntries()[0].duration;
+    performance.clearMarks();
+  });
+  obs.observe({ entryTypes: ['measure'] });
+  performance.mark('A');
+  this._chandle.query_a(this._connection._conn, stmt, asyncCallbackWrapper, buf);
+  performance.mark('B');
+  performance.measure('query', 'A', 'B');
+  return param;
+
+
+}
+/**
+ * Fetches all results from an async query. It is preferable to use cursor.query_a() to create
+ * async queries and execute them instead of using the cursor object directly.
+ * @param {Object} options - An options object containing options for this function
+ * @param {function} callback - callback function that is callbacked on the COMPLETE fetched data (it is calledback only once!).
+ * Must be of form function (param, result, rowCount, rowData)
+ * @param {Object} param - A parameter that is also passed to the main callback function. Important! Param must be an object, and the key "data" cannot be used
+ * @return {{param:Object, result:Buffer}} An object with the passed parameters object and the buffer instance that is a pointer to the result handle.
+ * @since 1.2.0
+ * @example
+ * cursor.execute('select * from db.table');
+ * var data = cursor.fetchall(function(results) {
+ *   results.forEach(row => console.log(row));
+ * })
+ */
+TDengineCursor.prototype.fetchall_a = function fetchall_a(result, options, callback, param = {}) {
+  if (typeof options == 'function') {
+    //we expect the parameter after callback to be param
+    param = callback;
+    callback = options;
+  }
+  if (typeof options != 'object') options = {}
+  if (this._connection == null) {
+    throw new errors.ProgrammingError('Cursor is not connected');
+  }
+  if (typeof callback != 'function') {
+    throw new errors.ProgrammingError('No callback function passed to fetchall_a function')
+  }
+  if (param.data) {
+    throw new errors.ProgrammingError("You aren't allowed to set the key 'data' for the parameters object");
+  }
+  let buf = ref.alloc('Object');
+  param.data = [];
+  var cr = this;
+
+  // This callback wrapper accumulates the data from the fetch_rows_a function from the cinterface. It is accumulated by passing the param2
+  // object which holds accumulated data in the data key.
+  let asyncCallbackWrapper = function asyncCallbackWrapper(param2, result2, numOfRows2, rowData) {
+    param2 = ref.readObject(param2); //return the object back from the pointer
+    if (numOfRows2 > 0 && rowData.length != 0) {
+      // Keep fetching until now rows left.
+      let buf2 = ref.alloc('Object');
+      param2.data.push(rowData);
+      ref.writeObject(buf2, 0, param2);
+      cr._chandle.fetch_rows_a(result2, asyncCallbackWrapper, buf2);
+    }
+    else {
+      let finalData = param2.data;
+      let fields = cr._chandle.fetchFields_a(result2);
+      let data = [];
+      for (let i = 0; i < finalData.length; i++) {
+        let num_of_rows = finalData[i][0].length; //fetched block number i;
+        let block = finalData[i];
+        for (let j = 0; j < num_of_rows; j++) {
+          data.push([]);
+          let rowBlock = new Array(fields.length);
+          for (let k = 0; k < fields.length; k++) {
+            rowBlock[k] = block[k][j];
+          }
+          data[data.length - 1] = rowBlock;
+        }
+      }
+      cr._chandle.freeResult(result2); // free result, avoid seg faults and mem leaks!
+      callback(param2, result2, numOfRows2, { data: data, fields: fields });
+
+    }
+  }
+  ref.writeObject(buf, 0, param);
+  param = this._chandle.fetch_rows_a(result, asyncCallbackWrapper, buf); //returned param
+  return { param: param, result: result };
+}
+/**
+ * Stop a query given the result handle.
+ * @param {Buffer} result - The buffer that acts as the result handle
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.stopQuery = function stopQuery(result) {
+  this._chandle.stopQuery(result);
+}
+TDengineCursor.prototype._reset_result = function _reset_result() {
+  this._rowcount = -1;
+  if (this._result != null) {
+    this._chandle.freeResult(this._result);
+  }
+  this._result = null;
+  this._fields = null;
+  this.data = [];
+  this.fields = null;
+}
+/**
+ * Get server info such as version number
+ * @return {string}
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.getServerInfo = function getServerInfo() {
+  return this._chandle.getServerInfo(this._connection._conn);
+}
+/**
+ * Get client info such as version number
+ * @return {string}
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.getClientInfo = function getClientInfo() {
+  return this._chandle.getClientInfo();
+}
+/**
+ * Subscribe to a table from a database in TDengine.
+ * @param {Object} config - A configuration object containing the configuration options for the subscription
+ * @param {string} config.restart - whether or not to continue a subscription if it already exits, otherwise start from beginning
+ * @param {string} config.topic - The unique identifier of a subscription
+ * @param {string} config.sql - A sql statement for data query
+ * @param {string} config.interval - The pulling interval
+ * @return {Buffer} A buffer pointing to the subscription session handle
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.subscribe = function subscribe(config) {
+  let restart = config.restart ? 1 : 0;
+  return this._chandle.subscribe(this._connection._conn, restart, config.topic, config.sql, config.interval);
+};
+/**
+ * An infinite loop that consumes the latest data and calls a callback function that is provided.
+ * @param {Buffer} subscription - A buffer object pointing to the subscription session handle
+ * @param {function} callback - The callback function that takes the row data, field/column meta data, and the subscription session handle as input
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.consumeData = async function consumeData(subscription, callback) {
+  while (true) {
+    let { data, fields, result } = this._chandle.consume(subscription);
+    callback(data, fields, result);
+  }
+}
+/**
+ * Unsubscribe the provided buffer object pointing to the subscription session handle
+ * @param {Buffer} subscription - A buffer object pointing to the subscription session handle that is to be unsubscribed
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.unsubscribe = function unsubscribe(subscription) {
+  this._chandle.unsubscribe(subscription);
+}
+/**
+ * Open a stream with TDengine to run the sql query periodically in the background
+ * @param {string} sql - The query to run
+ * @param {function} callback - The callback function to run after each query, accepting inputs as param, result handle, data, fields meta data
+ * @param {number} stime - The time of the stream starts in the form of epoch milliseconds. If 0 is given, the start time is set as the current time.
+ * @param {function} stoppingCallback - The callback function to run when the continuous query stops. It takes no inputs
+ * @param {object} param - A parameter that is passed to the main callback function
+ * @return {Buffer} A buffer pointing to the stream handle
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.openStream = function openStream(sql, callback, stime = 0, stoppingCallback, param = {}) {
+  let buf = ref.alloc('Object');
+  ref.writeObject(buf, 0, param);
+
+  let asyncCallbackWrapper = function (param2, result2, blocks, fields) {
+    let data = [];
+    let num_of_rows = blocks[0].length;
+    for (let j = 0; j < num_of_rows; j++) {
+      data.push([]);
+      let rowBlock = new Array(fields.length);
+      for (let k = 0; k < fields.length; k++) {
+        rowBlock[k] = blocks[k][j];
+      }
+      data[data.length - 1] = rowBlock;
+    }
+    callback(param2, result2, blocks, fields);
+  }
+  return this._chandle.openStream(this._connection._conn, sql, asyncCallbackWrapper, stime, stoppingCallback, buf);
+}
+/**
+ * Close a stream
+ * @param {Buffer} - A buffer pointing to the handle of the stream to be closed
+ * @since 1.3.0
+ */
+TDengineCursor.prototype.closeStream = function closeStream(stream) {
+  this._chandle.closeStream(stream);
+}

tests/connectorTest/nodejsTest/nodetaos/error.js

+
+/**
+ * TDengine Error Class
+ * @ignore
+ */
+class TDError extends Error {
+  constructor(args) {
+    super(args)
+    this.name = "TDError";
+  }
+}
+/** Exception raised for important warnings like data truncations while inserting.
+ * @ignore
+ */
+class Warning extends Error {
+  constructor(args) {
+    super(args)
+    this.name = "Warning";
+  }
+}
+/** Exception raised for errors that are related to the database interface rather than the database itself.
+ * @ignore
+ */
+class InterfaceError extends TDError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.InterfaceError";
+  }
+}
+/** Exception raised for errors that are related to the database.
+ * @ignore
+ */
+class DatabaseError extends TDError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError";
+  }
+}
+/** Exception raised for errors that are due to problems with the processed data like division by zero, numeric value out of range.
+ * @ignore
+ */
+class DataError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.DataError";
+  }
+}
+/** Exception raised for errors that are related to the database's operation and not necessarily under the control of the programmer
+ * @ignore
+ */
+class OperationalError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.OperationalError";
+  }
+}
+/** Exception raised when the relational integrity of the database is affected.
+ * @ignore
+ */
+class IntegrityError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.IntegrityError";
+  }
+}
+/** Exception raised when the database encounters an internal error.
+ * @ignore
+ */
+class InternalError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.InternalError";
+  }
+}
+/**  Exception raised for programming errors.
+ * @ignore
+ */
+class ProgrammingError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.ProgrammingError";
+  }
+}
+/** Exception raised in case a method or database API was used which is not supported by the database.
+ * @ignore
+ */
+class NotSupportedError extends DatabaseError {
+  constructor(args) {
+    super(args)
+    this.name = "TDError.DatabaseError.NotSupportedError";
+  }
+}
+
+module.exports = {
+  TDError, Warning, InterfaceError, DatabaseError, DataError, OperationalError, IntegrityError, InternalError, ProgrammingError, NotSupportedError
+};

tests/connectorTest/nodejsTest/nodetaos/globalfunc.js

+/* Wrap a callback, reduce code amount */
+function wrapCB(callback, input) {
+  if (typeof callback === 'function') {
+    callback(input);
+  }
+  return;
+}
+global.wrapCB = wrapCB;
+function toTaosTSString(date) {
+  date = new Date(date);
+  let tsArr = date.toISOString().split("T")
+  return tsArr[0] + " " + tsArr[1].substring(0, tsArr[1].length-1);
+}
+global.toTaosTSString = toTaosTSString;

tests/connectorTest/nodejsTest/nodetaos/taosobjects.js

+const FieldTypes = require('./constants');
+const util = require('util');
+/**
+ * Various objects such as TaosRow and TaosColumn that help make parsing data easier
+ * @module TaosObjects
+ *
+ */
+
+/**
+ * The TaosRow object. Contains the data from a retrieved row from a database and functions that parse the data.
+ * @typedef {Object} TaosRow - A row of data retrieved from a table.
+ * @global
+ * @example
+ * var trow = new TaosRow(row);
+ * console.log(trow.data);
+ */
+function TaosRow(row) {
+  this.data = row;
+  this.length = row.length;
+  return this;
+}
+
+/**
+ * @typedef {Object} TaosField - A field/column's metadata from a table.
+ * @global
+ * @example
+ * var tfield = new TaosField(field);
+ * console.log(tfield.name);
+ */
+
+function TaosField(field) {
+  this._field = field;
+  this.name = field.name;
+  this.type = FieldTypes.getType(field.type);
+  return this;
+}
+
+/**
+ * A TaosTimestamp object, which is the standard date object with added functionality
+ * @global
+ * @memberof TaosObjects
+ * @param {Date} date - A Javascript date time object or the time in milliseconds past 1970-1-1 00:00:00.000
+ */
+class TaosTimestamp extends Date {
+  constructor(date, precision = 0) {
+    if (precision === 1) {
+      super(Math.floor(date / 1000));
+      this.precisionExtras = date % 1000;
+    } else if (precision === 2) {
+      // use BigInt to fix: 1623254400999999999 / 1000000 = 1623254401000 which not expected
+      super(parseInt(BigInt(date) / 1000000n));
+      // use BigInt to fix: 1625801548423914405 % 1000000 = 914496 which not expected (914405)
+      this.precisionExtras = parseInt(BigInt(date) % 1000000n);
+    } else {
+      super(parseInt(date));
+    }
+    this.precision = precision;
+  }
+
+  /**
+   * TDengine raw timestamp.
+   * @returns raw taos timestamp (int64)
+   */
+  taosTimestamp() {
+    if (this.precision == 1) {
+      return (this * 1000 + this.precisionExtras);
+    } else if (this.precision == 2) {
+      return (this * 1000000 + this.precisionExtras);
+    } else {
+      return Math.floor(this);
+    }
+  }
+
+  /**
+   * Gets the microseconds of a Date.
+   * @return {Int} A microseconds integer
+   */
+  getMicroseconds() {
+    if (this.precision == 1) {
+      return this.getMilliseconds() * 1000 + this.precisionExtras;
+    } else if (this.precision == 2) {
+      return this.getMilliseconds() * 1000 + this.precisionExtras / 1000;
+    } else {
+      return 0;
+    }
+  }
+  /**
+   * Gets the nanoseconds of a TaosTimestamp.
+   * @return {Int} A nanoseconds integer
+   */
+  getNanoseconds() {
+    if (this.precision == 1) {
+      return this.getMilliseconds() * 1000000 + this.precisionExtras * 1000;
+    } else if (this.precision == 2) {
+      return this.getMilliseconds() * 1000000 + this.precisionExtras;
+    } else {
+      return 0;
+    }
+  }
+
+  /**
+   * @returns {String} a string for timestamp string format
+   */
+  _precisionExtra() {
+    if (this.precision == 1) {
+      return String(this.precisionExtras).padStart(3, '0');
+    } else if (this.precision == 2) {
+      return String(this.precisionExtras).padStart(6, '0');
+    } else {
+      return '';
+    }
+  }
+  /**
+   * @function Returns the date into a string usable by TDengine
+   * @return {string} A Taos Timestamp String
+   */
+  toTaosString() {
+    var tzo = -this.getTimezoneOffset(),
+      dif = tzo >= 0 ? '+' : '-',
+      pad = function (num) {
+        var norm = Math.floor(Math.abs(num));
+        return (norm < 10 ? '0' : '') + norm;
+      },
+      pad2 = function (num) {
+        var norm = Math.floor(Math.abs(num));
+        if (norm < 10) return '00' + norm;
+        if (norm < 100) return '0' + norm;
+        if (norm < 1000) return norm;
+      };
+    return this.getFullYear() +
+      '-' + pad(this.getMonth() + 1) +
+      '-' + pad(this.getDate()) +
+      ' ' + pad(this.getHours()) +
+      ':' + pad(this.getMinutes()) +
+      ':' + pad(this.getSeconds()) +
+      '.' + pad2(this.getMilliseconds()) +
+      '' + this._precisionExtra();
+  }
+
+  /**
+   * Custom console.log
+   * @returns {String} string format for debug
+   */
+  [util.inspect.custom](depth, opts) {
+    return this.toTaosString() + JSON.stringify({ precision: this.precision, precisionExtras: this.precisionExtras }, opts);
+  }
+  toString() {
+    return this.toTaosString();
+  }
+}
+
+module.exports = { TaosRow, TaosField, TaosTimestamp }

tests/connectorTest/nodejsTest/nodetaos/taosquery.js

+var TaosResult = require('./taosresult')
+require('./globalfunc.js')
+module.exports = TaosQuery;
+
+
+/**
+ * @class TaosQuery
+ * @classdesc The TaosQuery class is one level above the TDengine Cursor in that it makes sure to generally return promises from functions, and wrap
+ * all data with objects such as wrapping a row of data with Taos Row. This is meant to enable an higher level API that allows additional
+ * functionality and save time whilst also making it easier to debug and enter less problems with the use of promises.
+ * @param {string} query - Query to construct object from
+ * @param {TDengineCursor} cursor - The cursor from which this query will execute from
+ * @param {boolean} execute - Whether or not to immedietely execute the query synchronously and fetch all results. Default is false.
+ * @property {string} query - The current query in string format the TaosQuery object represents
+ * @return {TaosQuery}
+ * @since 1.0.6
+ */
+function TaosQuery(query = "", cursor = null, execute = false) {
+  this.query = query;
+  this._cursor = cursor;
+  if (execute == true) {
+    return this.execute();
+  }
+  return this;
+}
+
+/**
+ * Executes the query object and returns a Promise
+ * @memberof TaosQuery
+ * @return {Promise<TaosResult>} A promise that resolves with a TaosResult object, or rejects with an error
+ * @since 1.0.6
+ */
+TaosQuery.prototype.execute = async function execute() {
+  var taosQuery = this; //store the current instance of taosQuery to avoid async issues?
+  var executionPromise = new Promise(function(resolve, reject) {
+    let data = [];
+    let fields = [];
+    let result;
+    try {
+      taosQuery._cursor.execute(taosQuery.query);
+      if (taosQuery._cursor._fields) fields = taosQuery._cursor._fields;
+      if (taosQuery._cursor._result != null) data = taosQuery._cursor.fetchall();
+      result = new TaosResult(data, fields)
+    }
+    catch(err) {
+      reject(err);
+    }
+    resolve(result)
+
+  });
+  return executionPromise;
+}
+
+/**
+ * Executes the query object asynchronously and returns a Promise. Completes query to completion.
+ * @memberof TaosQuery
+ * @param {Object} options - Execution options
+ * @return {Promise<TaosResult>} A promise that resolves with a TaosResult object, or rejects with an error
+ * @since 1.2.0
+ */
+TaosQuery.prototype.execute_a = async function execute_a(options = {}) {
+  var executionPromise =  new Promise( (resolve, reject) => {
+
+  });
+  var fres;
+  var frej;
+  var fetchPromise =  new Promise( (resolve, reject) => {
+    fres = resolve;
+    frej = reject;
+  });
+  let asyncCallbackFetchall = async function(param, res, numOfRows, blocks) {
+    if (numOfRows > 0) {
+      // Likely a query like insert
+      fres();
+    }
+    else {
+      fres(new TaosResult(blocks.data, blocks.fields));
+    }
+  }
+  let asyncCallback = async function(param, res, code) {
+    //upon success, we fetchall results
+    this._cursor.fetchall_a(res, options, asyncCallbackFetchall, {});
+  }
+  this._cursor.execute_a(this.query, asyncCallback.bind(this), {});
+  return fetchPromise;
+}
+
+/**
+ * Bind arguments to the query and automatically parses them into the right format
+ * @param {array | ...args} args - A number of arguments to bind to each ? in the query
+ * @return {TaosQuery}
+ * @example
+ * // An example of binding a javascript date and a number to a query
+ * var query = cursor.query("select count(*) from meterinfo.meters where ts <= ? and areaid = ?").bind(new Date(), 3);
+ * var promise1 = query.execute();
+ * promise1.then(function(result) {
+ *   result.pretty(); // Log the prettified version of the results.
+ * });
+ * @since 1.0.6
+ */
+TaosQuery.prototype.bind = function bind(f, ...args) {
+  if (typeof f == 'object' && f.constructor.name != 'Array') args.unshift(f); //param is not an array object
+  else if (typeof f != 'object') args.unshift(f);
+  else { args = f; }
+  args.forEach(function(arg) {
+    if (arg.constructor.name == 'TaosTimestamp') arg = "\"" + arg.toTaosString() + "\"";
+    else if (arg.constructor.name == 'Date') arg = "\"" + toTaosTSString(arg) + "\"";
+    else if (typeof arg == 'string') arg = "\"" + arg + "\"";
+    this.query = this.query.replace(/\?/,arg);
+  }, this);
+  return this;
+}

tests/connectorTest/nodejsTest/nodetaos/taosresult.js

+require('./globalfunc.js')
+const TaosObjects = require('./taosobjects');
+const TaosRow = TaosObjects.TaosRow;
+const TaosField = TaosObjects.TaosField;
+
+module.exports = TaosResult;
+/**
+ * @class TaosResult
+ * @classdesc A TaosResult class consts of the row data and the fields metadata, all wrapped under various objects for higher functionality.
+ * @param {Array<TaosRow>} data - Array of result rows
+ * @param {Array<TaosField>} fields - Array of field meta data
+ * @property {Array<TaosRow>} data - Array of TaosRows forming the result data (this does not include field meta data)
+ * @property {Array<TaosField>} fields - Array of TaosFields forming the fields meta data array.
+ * @return {TaosResult}
+ * @since 1.0.6
+ */
+function TaosResult(data, fields) {
+  this.data = data.map(row => new TaosRow(row));
+  this.rowcount = this.data.length;
+  this.fields = fields.map(field => new TaosField(field));
+}
+/**
+ * Pretty print data and the fields meta data as if you were using the taos shell
+ * @memberof TaosResult
+ * @function pretty
+ * @since 1.0.6
+ */
+
+TaosResult.prototype.pretty = function pretty() {
+  let fieldsStr = "";
+  let sizing = [];
+  this.fields.forEach((field,i) => {
+    if (field._field.type == 8 || field._field.type == 10){
+      sizing.push(Math.max(field.name.length, field._field.bytes));
+    }
+    else {
+      sizing.push(Math.max(field.name.length, suggestedMinWidths[field._field.type]));
+    }
+    fieldsStr += fillEmpty(Math.floor(sizing[i]/2 - field.name.length / 2)) + field.name + fillEmpty(Math.ceil(sizing[i]/2 - field.name.length / 2)) + " | ";
+  });
+  var sumLengths = sizing.reduce((a,b)=> a+=b,(0)) + sizing.length * 3;
+
+  console.log("\n" + fieldsStr);
+  console.log(printN("=",sumLengths));
+  this.data.forEach(row => {
+    let rowStr = "";
+    row.data.forEach((entry, i) => {
+      if (this.fields[i]._field.type == 9) {
+        entry = entry.toTaosString();
+      } else {
+        entry = entry == null ? 'null' : entry.toString();
+      }
+      rowStr += entry
+      rowStr += fillEmpty(sizing[i] - entry.length) + " | ";
+    });
+    console.log(rowStr);
+  });
+}
+const suggestedMinWidths = {
+  0: 4,
+  1: 4,
+  2: 4,
+  3: 6,
+  4: 11,
+  5: 12,
+  6: 24,
+  7: 24,
+  8: 10,
+  9: 25,
+  10: 10,
+}
+function printN(s, n) {
+  let f = "";
+  for (let i = 0; i < n; i ++) {
+    f += s;
+  }
+  return f;
+}
+function fillEmpty(n) {
+  let str = "";
+  for (let i = 0; i < n; i++) {
+    str += " ";
+  }
+  return str;
+}

tests/connectorTest/nodejsTest/tdengine.js

+var TDengineConnection = require('./nodetaos/connection.js')
+module.exports.connect = function (connection={}) {
+  return new TDengineConnection(connection);
+}

tests/connectorTest/nodejsTest/test/testMicroseconds.js

+const taos = require('../tdengine');
+var conn = taos.connect();
+var c1 = conn.cursor();
+let stime = new Date();
+let interval = 1000;
+
+function convertDateToTS(date) {
+  let tsArr = date.toISOString().split("T")
+  return "\"" + tsArr[0] + " " + tsArr[1].substring(0, tsArr[1].length - 1) + "\"";
+}
+function R(l, r) {
+  return Math.random() * (r - l) - r;
+}
+function randomBool() {
+  if (Math.random() < 0.5) {
+    return true;
+  }
+  return false;
+}
+
+// Initialize
+//c1.execute('drop database td_connector_test;');
+const dbname = 'nodejs_test_us';
+c1.execute('create database if not exists ' + dbname + ' precision "us"');
+c1.execute('use ' + dbname)
+c1.execute('create table if not exists tstest (ts timestamp, _int int);');
+c1.execute('insert into tstest values(1625801548423914, 0)');
+// Select
+console.log('select * from tstest');
+c1.execute('select * from tstest');
+
+var d = c1.fetchall();
+console.log(c1.fields);
+let ts = d[0][0];
+console.log(ts);
+
+if (ts.taosTimestamp() != 1625801548423914) {
+  throw "microseconds not match!";
+}
+if (ts.getMicroseconds() % 1000 !== 914) {
+  throw "micronsecond precision error";
+}
+setTimeout(function () {
+  c1.query('drop database nodejs_us_test;');
+}, 200);
+
+setTimeout(function () {
+  conn.close();
+}, 2000);

tests/connectorTest/nodejsTest/test/testSubscribe.js

+const taos = require('../tdengine');
+var conn = taos.connect({host:"127.0.0.1", user:"root", password:"taosdata", config:"/etc/taos",port:10});
+var c1 = conn.cursor();
+let stime = new Date();
+let interval = 1000;
+c1.execute('use td_connector_test');
+let sub = c1.subscribe({
+  restart: true,
+  sql: "select AVG(_int) from td_connector_test.all_Types;",
+  topic: 'all_Types',
+  interval: 1000
+});
+
+c1.consumeData(sub, (data, fields) => {
+  console.log(data);
+});
\ No newline at end of file

tests/gotest/batchtest.sh

@@ -19,3 +19,6 @@ go env -w GOPROXY=https://goproxy.io,direct
 bash ./case001/case001.sh $severIp $serverPort
 bash ./case002/case002.sh $severIp $serverPort
 #bash ./case003/case003.sh $severIp $serverPort
+
+cd nanosupport
+go run main.go

tests/gotest/case001/case001.go

@@ -12,7 +12,6 @@
  * 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/>.
  */
-
 package main
 
 import (