Merge branch 'develop' into feature/sangshuduo/TD-5844-cmdline-parameters-align

Jenkinsfile

@@ -5,7 +5,7 @@ node {
     git url: 'https://github.com/taosdata/TDengine.git'
 }
 
-def skipstage=0
+def skipbuild=0
 
 def abortPreviousBuilds() {
   def currentJobName = env.JOB_NAME
@@ -33,8 +33,7 @@ def abort_previous(){
   milestone(buildNumber)
 }
 def pre_test(){
-    
-    
+    sh'hostname'
     sh '''
     sudo rmtaos || echo "taosd has not installed"
     '''
@@ -52,12 +51,18 @@ def pre_test(){
         git checkout master
         '''
         }
-      else {
+      else if(env.CHANGE_TARGET == '2.0'){
         sh '''
         cd ${WKC}
-        git checkout develop
+        git checkout 2.0
         '''
       } 
+      else{
+        sh '''
+        cd ${WKC}
+        git checkout develop
+        '''
+      }
     }
     sh'''
     cd ${WKC}
@@ -75,7 +80,13 @@ def pre_test(){
         git checkout master
         '''
         }
-      else {
+      else if(env.CHANGE_TARGET == '2.0'){
+        sh '''
+        cd ${WK}
+        git checkout 2.0
+        '''
+      } 
+      else{
         sh '''
         cd ${WK}
         git checkout develop
@@ -95,19 +106,17 @@ def pre_test(){
     make > /dev/null
     make install > /dev/null
     cd ${WKC}/tests
-    pip3 install ${WKC}/src/connector/python
+    pip3 install ${WKC}/src/connector/python/
     '''
     return 1
 }
 
 pipeline {
   agent none
-  
   environment{
       WK = '/var/lib/jenkins/workspace/TDinternal'
       WKC= '/var/lib/jenkins/workspace/TDinternal/community'
   }
-  
   stages {
       stage('pre_build'){
           agent{label 'master'}
@@ -123,19 +132,22 @@ pipeline {
           rm -rf ${WORKSPACE}.tes
           cp -r ${WORKSPACE} ${WORKSPACE}.tes
           cd ${WORKSPACE}.tes
-          
+          git fetch
           '''
           script {
             if (env.CHANGE_TARGET == 'master') {
               sh '''
               git checkout master
-              git pull origin master
               '''
               }
-            else {
+            else if(env.CHANGE_TARGET == '2.0'){
+              sh '''
+              git checkout 2.0
+              '''
+            } 
+            else{
               sh '''
               git checkout develop
-              git pull origin develop
               '''
             } 
           }
@@ -143,28 +155,30 @@ pipeline {
           git fetch origin +refs/pull/${CHANGE_ID}/merge
           git checkout -qf FETCH_HEAD
           '''     
-          
-          script{
-            env.skipstage=sh(script:"cd ${WORKSPACE}.tes && git --no-pager diff --name-only FETCH_HEAD ${env.CHANGE_TARGET}|grep -v -E '.*md|//src//connector|Jenkinsfile|test-all.sh' || echo 0 ",returnStdout:true) 
+
+          script{  
+            skipbuild='2'     
+            skipbuild=sh(script: "git log -2 --pretty=%B | fgrep -ie '[skip ci]' -e '[ci skip]' && echo 1 || echo 2", returnStdout:true)
+            println skipbuild
           }
-          println env.skipstage
           sh'''
           rm -rf ${WORKSPACE}.tes
           '''
           }
       }
-    
       stage('Parallel test stage') {
         //only build pr
         when {
+          allOf{
               changeRequest()
-               expression {
-                    env.skipstage != 0
+               expression{
+                return skipbuild.trim() == '2'
               }
+            }
           }
       parallel {
         stage('python_1_s1') {
-          agent{label 'p1'}
+          agent{label " slave1 || slave11 "}
           steps {
             
             pre_test()
@@ -179,7 +193,7 @@ pipeline {
           }
         }
         stage('python_2_s5') {
-          agent{label 'p2'}
+          agent{label " slave5 || slave15 "}
           steps {
             
             pre_test()
@@ -193,7 +207,7 @@ pipeline {
           }
         }
         stage('python_3_s6') {
-          agent{label 'p3'}
+          agent{label " slave6 || slave16 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -206,7 +220,7 @@ pipeline {
           }
         }
         stage('test_b1_s2') {
-          agent{label 'b1'}
+          agent{label " slave2 || slave12 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -217,9 +231,8 @@ pipeline {
             }
           }
         }
-
         stage('test_crash_gen_s3') {
-          agent{label "b2"}
+          agent{label " slave3 || slave13 "}
           
           steps {
             pre_test()
@@ -252,13 +265,11 @@ pipeline {
                 ./test-all.sh b2fq
                 date
                 '''
-            }         
-            
+            }                     
           }
         }
-
         stage('test_valgrind_s4') {
-          agent{label "b3"}
+          agent{label " slave4 || slave14 "}
 
           steps {
             pre_test()
@@ -284,7 +295,7 @@ pipeline {
           }
         }
         stage('test_b4_s7') {
-          agent{label 'b4'}
+          agent{label " slave7 || slave17 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -303,7 +314,7 @@ pipeline {
           }
         }
         stage('test_b5_s8') {
-          agent{label 'b5'}
+          agent{label " slave8 || slave18 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -316,7 +327,7 @@ pipeline {
           }
         }
         stage('test_b6_s9') {
-          agent{label 'b6'}
+          agent{label " slave9 || slave19 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -329,7 +340,7 @@ pipeline {
           }
         }
         stage('test_b7_s10') {
-          agent{label 'b7'}
+          agent{label " slave10 || slave20 "}
           steps {     
             timeout(time: 55, unit: 'MINUTES'){       
               pre_test()
@@ -421,6 +432,5 @@ pipeline {
                 from: "support@taosdata.com"
             )
         }
-    }
-   
-}
+    } 
+}
\ No newline at end of file

documentation20/cn/10.cluster/docs.md

 # TDengine 集群安装、管理
 
-多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看TDengine 2.0整体架构一章。而且在安装集群之前，先请按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)一章安装并体验单节点功能。
+多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看《TDengine整体架构》一章。而且在安装集群之前，建议先按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)一章安装并体验单节点功能。
 
 集群的每个数据节点是由End Point来唯一标识的，End Point是由FQDN(Fully Qualified Domain Name)外加Port组成，比如 h1.taosdata.com:6030。一般FQDN就是服务器的hostname，可通过Linux命令`hostname -f`获取（如何配置FQDN，请参考：[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)）。端口是这个数据节点对外服务的端口号，缺省是6030，但可以通过taos.cfg里配置参数serverPort进行修改。一个物理节点可能配置了多个hostname, TDengine会自动获取第一个，但也可以通过taos.cfg里配置参数fqdn进行指定。如果习惯IP地址直接访问，可以将参数fqdn设置为本节点的IP地址。
 
@@ -12,7 +12,7 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
 
 **第零步**：规划集群所有物理节点的FQDN，将规划好的FQDN分别添加到每个物理节点的/etc/hostname；修改每个物理节点的/etc/hosts，将所有集群物理节点的IP与FQDN的对应添加好。【如部署了DNS，请联系网络管理员在DNS上做好相关配置】
 
-**第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据，具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html )   
+**第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据（如果需要保留原有数据，请联系涛思交付团队进行旧版本升级、数据迁移），具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html )   
 **注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（`rm -rf /var/lib/taos/*`）；  
 **注意2：**客户端也需要配置，确保它可以正确解析每个节点的FQDN配置，不管是通过DNS服务，还是 Host 文件。
 
@@ -23,23 +23,23 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
 **第四步**：检查所有数据节点，以及应用程序所在物理节点的网络设置：
 
 1. 每个物理节点上执行命令`hostname -f`，查看和确认所有节点的hostname是不相同的(应用驱动所在节点无需做此项检查)；
-2. 每个物理节点上执行`ping host`, 其中host是其他物理节点的hostname, 看能否ping通其它物理节点; 如果不能ping通，需要检查网络设置, 或/etc/hosts文件(Windows系统默认路径为C:\Windows\system32\drivers\etc\hosts)，或DNS的配置。如果无法ping通，是无法组成集群的；
+2. 每个物理节点上执行`ping host`，其中host是其他物理节点的hostname，看能否ping通其它物理节点；如果不能ping通，需要检查网络设置，或/etc/hosts文件(Windows系统默认路径为C:\Windows\system32\drivers\etc\hosts)，或DNS的配置。如果无法ping通，是无法组成集群的；
 3. 从应用运行的物理节点，ping taosd运行的数据节点，如果无法ping通，应用是无法连接taosd的，请检查应用所在物理节点的DNS设置或hosts文件；
 4. 每个数据节点的End Point就是输出的hostname外加端口号，比如h1.taosdata.com:6030
 
-**第五步**：修改TDengine的配置文件（所有节点的文件/etc/taos/taos.cfg都需要修改）。假设准备启动的第一个数据节点End Point为 h1.taosdata.com:6030, 其与集群配置相关参数如下：
+**第五步**：修改TDengine的配置文件（所有节点的文件/etc/taos/taos.cfg都需要修改）。假设准备启动的第一个数据节点End Point为 h1.taosdata.com:6030，其与集群配置相关参数如下：
 
 ```
 // firstEp 是每个数据节点首次启动后连接的第一个数据节点
 firstEp               h1.taosdata.com:6030
 
-// 必须配置为本数据节点的FQDN，如果本机只有一个hostname, 可注释掉本配置
+// 必须配置为本数据节点的FQDN，如果本机只有一个hostname, 可注释掉本项
 fqdn                  h1.taosdata.com  
 
 // 配置本数据节点的端口号，缺省是6030
 serverPort            6030
 
-// 使用场景，请参考《Arbitrator的使用》的部分
+// 副本数为偶数的时候，需要配置，请参考《Arbitrator的使用》的部分
 arbitrator            ha.taosdata.com:6042
 ```
 
@@ -53,7 +53,7 @@ arbitrator            ha.taosdata.com:6042
 | 2     | mnodeEqualVnodeNum | 一个mnode等同于vnode消耗的个数           |
 | 3     | offlineThreshold   | dnode离线阈值，超过该时间将导致Dnode离线 |
 | 4     | statusInterval     | dnode向mnode报告状态时长                 |
-| 5     | arbitrator         | 系统中裁决器的end point                  |
+| 5     | arbitrator         | 系统中裁决器的End Point                  |
 | 6     | timezone           | 时区                                     |
 | 7     | balance            | 是否启动负载均衡                         |
 | 8     | maxTablesPerVnode  | 每个vnode中能够创建的最大表个数          |
@@ -87,7 +87,7 @@ taos>
 
 1. 按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)一章的方法在每个物理节点启动taosd；（注意：每个物理节点都需要在 taos.cfg 文件中将 firstEP 参数配置为新集群首个节点的 End Point——在本例中是 h1.taos.com:6030）
 
-2. 在第一个数据节点，使用CLI程序taos, 登录进TDengine系统, 执行命令:
+2. 在第一个数据节点，使用CLI程序taos，登录进TDengine系统，执行命令：
 
    ```
    CREATE DNODE "h2.taos.com:6030"; 
@@ -101,7 +101,7 @@ taos>
    SHOW DNODES;
    ```
 
-   查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态，请做两个检查
+   查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态，请做两个检查：
 
    - 查看该数据节点的taosd是否正常工作，如果没有正常运行，需要先检查为什么
    - 查看该数据节点taosd日志文件taosdlog.0里前面几行日志(一般在/var/log/taos目录)，看日志里输出的该数据节点fqdn以及端口号是否为刚添加的End Point。如果不一致，需要将正确的End Point添加进去。
@@ -121,7 +121,7 @@ taos>
 
 ### 添加数据节点
 
-执行CLI程序taos, 使用root账号登录进系统, 执行:
+执行CLI程序taos，使用root账号登录进系统，执行：
 
 ```
 CREATE DNODE "fqdn:port"; 
@@ -131,13 +131,13 @@ CREATE DNODE "fqdn:port";
 
 ### 删除数据节点
 
-执行CLI程序taos, 使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，使用root账号登录进TDengine系统，执行：
 
-```
-DROP DNODE "fqdn:port";
+```mysql
+DROP DNODE "fqdn:port | dnodeID";
 ```
 
-其中fqdn是被删除的节点的FQDN，port是其对外服务器的端口号
+通过"fqdn:port"或"dnodeID"来指定一个具体的节点都是可以的。其中fqdn是被删除的节点的FQDN，port是其对外服务器的端口号；dnodeID可以通过SHOW DNODES获得。
 
 <font color=green>**【注意】**</font>
 
@@ -147,25 +147,41 @@ DROP DNODE "fqdn:port";
 
   - 一个数据节点被drop之后，其他节点都会感知到这个dnodeID的删除操作，任何集群中的节点都不会再接收此dnodeID的请求。
 
-  - dnodeID的是集群自动分配的，不得人工指定。它在生成时递增的，不会重复。
+  - dnodeID是集群自动分配的，不得人工指定。它在生成时是递增的，不会重复。
 
-### 查看数据节点
+### 手动迁移数据节点
+
+手动将某个vnode迁移到指定的dnode。
 
-执行CLI程序taos,使用root账号登录进TDengine系统，执行：
+执行CLI程序taos，使用root账号登录进TDengine系统，执行：
 
+```mysql
+ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
 ```
+
+其中：source-dnodeId是源dnodeId，也就是待迁移的vnode所在的dnodeID；vgId可以通过SHOW VGROUPS获得，列表的第一列；dest-dnodeId是目标dnodeId。
+
+<font color=green>**【注意】**</font>
+
+  - 只有在集群的自动负载均衡选项关闭时(balance设置为0)，才允许手动迁移。
+  - 只有处于正常工作状态的vnode才能被迁移：master/slave，当处于offline/unsynced/syncing状态时，是不能迁移的。
+  - 迁移前，务必核实目标dnode的资源足够：CPU、内存、硬盘。
+
+### 查看数据节点
+
+执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+```mysql
 SHOW DNODES;
 ```
 
-它将列出集群中所有的dnode,每个dnode的fqdn:port, 状态(ready, offline等），vnode数目，还未使用的vnode数目等信息。在添加或删除一个数据节点后，可以使用该命令查看。
+它将列出集群中所有的dnode，每个dnode的ID，end_point(fqdn:port)，状态(ready, offline等），vnode数目，还未使用的vnode数目等信息。在添加或删除一个数据节点后，可以使用该命令查看。
 
 ### 查看虚拟节点组
 
 为充分利用多核技术，并提供scalability，数据需要分片处理。因此TDengine会将一个DB的数据切分成多份，存放在多个vnode里。这些vnode可能分布在多个数据节点dnode里，这样就实现了水平扩展。一个vnode仅仅属于一个DB，但一个DB可以有多个vnode。vnode的是mnode根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
 
-执行CLI程序taos,使用root账号登录进TDengine系统，执行：
-
-```
+执行CLI程序taos，使用root账号登录进TDengine系统，执行：
+```mysql
 SHOW VGROUPS;
 ```
 
@@ -173,9 +189,9 @@ SHOW VGROUPS;
 
 TDengine通过多副本的机制来提供系统的高可用性，包括vnode和mnode的高可用性。
 
-vnode的副本数是与DB关联的，一个集群里可以有多个DB，根据运营的需求，每个DB可以配置不同的副本数。创建数据库时，通过参数replica 指定副本数（缺省为1）。如果副本数为1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误“more dnodes are needed"。比如下面的命令将创建副本数为3的数据库demo：
+vnode的副本数是与DB关联的，一个集群里可以有多个DB，根据运营的需求，每个DB可以配置不同的副本数。创建数据库时，通过参数replica 指定副本数（缺省为1）。如果副本数为1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误"more dnodes are needed"。比如下面的命令将创建副本数为3的数据库demo：
 
-```
+```mysql
 CREATE DATABASE demo replica 3;
 ```
 
@@ -183,20 +199,19 @@ CREATE DATABASE demo replica 3;
 
 一个数据节点dnode里可能有多个DB的数据，因此一个dnode离线时，可能会影响到多个DB。如果一个vnode group里的一半或一半以上的vnode不工作，那么该vnode group就无法对外服务，无法插入或读取数据，这样会影响到它所属的DB的一部分表的读写操作。
 
-因为vnode的引入，无法简单的给出结论：“集群中过半数据节点dnode工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为3，只有三个dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个数据节点不工作，那整个集群就无法正常工作了。
+因为vnode的引入，无法简单地给出结论：“集群中过半数据节点dnode工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为3，只有三个dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个数据节点不工作，那整个集群就无法正常工作了。
 
 ## <a class="anchor" id="mnode"></a>Mnode的高可用性
 
 TDengine集群是由mnode (taosd的一个模块，管理节点) 负责管理的，为保证mnode的高可用，可以配置多个mnode副本，副本数由系统配置参数numOfMnodes决定，有效范围为1-3。为保证元数据的强一致性，mnode副本之间是通过同步的方式进行数据复制的。
 
-一个集群有多个数据节点dnode, 但一个dnode至多运行一个mnode实例。多个dnode情况下，哪个dnode可以作为mnode呢？这是完全由系统根据整个系统资源情况，自动指定的。用户可通过CLI程序taos，在TDengine的console里，执行如下命令：
+一个集群有多个数据节点dnode，但一个dnode至多运行一个mnode实例。多个dnode情况下，哪个dnode可以作为mnode呢？这是完全由系统根据整个系统资源情况，自动指定的。用户可通过CLI程序taos，在TDengine的console里，执行如下命令：
 
-```
+```mysql
 SHOW MNODES;
 ```
 
-来查看mnode列表，该列表将列出mnode所处的dnode的End Point和角色(master, slave, unsynced 或offline)。
-当集群中第一个数据节点启动时，该数据节点一定会运行一个mnode实例，否则该数据节点dnode无法正常工作，因为一个系统是必须有至少一个mnode的。如果numOfMnodes配置为2，启动第二个dnode时，该dnode也将运行一个mnode实例。
+来查看mnode列表，该列表将列出mnode所处的dnode的End Point和角色(master, slave, unsynced 或offline)。当集群中第一个数据节点启动时，该数据节点一定会运行一个mnode实例，否则该数据节点dnode无法正常工作，因为一个系统是必须有至少一个mnode的。如果numOfMnodes配置为2，启动第二个dnode时，该dnode也将运行一个mnode实例。
 
 为保证mnode服务的高可用性，numOfMnodes必须设置为2或更大。因为mnode保存的元数据必须是强一致的，如果numOfMnodes大于2，复制参数quorum自动设为2，也就是说，至少要保证有两个副本写入数据成功，才通知客户端应用写入成功。
 
@@ -210,7 +225,7 @@ SHOW MNODES;
 - 当一个数据节点从集群中移除时，系统将自动把该数据节点上的数据转移到其他数据节点，无需任何人工干预。
 - 如果一个数据节点过热（数据量过大），系统将自动进行负载均衡，将该数据节点的一些vnode自动挪到其他节点。
 
-当上述三种情况发生时，系统将启动一各个数据节点的负载计算，从而决定如何挪动。
+当上述三种情况发生时，系统将启动各个数据节点的负载计算，从而决定如何挪动。
 
 **【提示】负载均衡由参数balance控制，它决定是否启动自动负载均衡。**
 
@@ -225,7 +240,7 @@ SHOW MNODES;
 
 ## <a class="anchor" id="arbitrator"></a>Arbitrator的使用
 
-如果副本数为偶数，当一个 vnode group 里一半 vnode 不工作时，是无法从中选出 master 的。同理，一半 mnode 不工作时，是无法选出 mnode 的 master 的，因为存在“split brain”问题。为解决这个问题，TDengine 引入了 Arbitrator 的概念。Arbitrator 模拟一个 vnode 或 mnode 在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含 Arbitrator 在内，超过半数的 vnode 或 mnode 工作，那么该 vnode group 或 mnode 组就可以正常的提供数据插入或查询服务。比如对于副本数为 2 的情形，如果一个节点 A 离线，但另外一个节点 B 正常，而且能连接到 Arbitrator，那么节点 B 就能正常工作。
+如果副本数为偶数，当一个 vnode group 里一半或超过一半的 vnode 不工作时，是无法从中选出 master 的。同理，一半或超过一半的 mnode 不工作时，是无法选出 mnode 的 master 的，因为存在“split brain”问题。为解决这个问题，TDengine 引入了 Arbitrator 的概念。Arbitrator 模拟一个 vnode 或 mnode 在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含 Arbitrator 在内，超过半数的 vnode 或 mnode 工作，那么该 vnode group 或 mnode 组就可以正常的提供数据插入或查询服务。比如对于副本数为 2 的情形，如果一个节点 A 离线，但另外一个节点 B 正常，而且能连接到 Arbitrator，那么节点 B 就能正常工作。
 
 总之，在目前版本下，TDengine 建议在双副本环境要配置 Arbitrator，以提升系统的可用性。
 
@@ -235,3 +250,9 @@ Arbitrator 的执行程序名为 tarbitrator。该程序对系统资源几乎没
 3. 修改每个 taosd 实例的配置文件，在 taos.cfg 里将参数 arbitrator 设置为 tarbitrator 程序所对应的 End Point。（如果该参数配置了，当副本数为偶数时，系统将自动连接配置的 Arbitrator。如果副本数为奇数，即使配置了 Arbitrator，系统也不会去建立连接。）
 4. 在配置文件中配置了的 Arbitrator，会出现在 `SHOW DNODES;` 指令的返回结果中，对应的 role 列的值会是“arb”。
 
+
+查看集群 Arbitrator 的状态【2.0.14.0 以后支持】
+
+```mysql
+SHOW DNODES;
+```

documentation20/cn/11.administrator/docs.md

@@ -218,7 +218,8 @@ taosd -C
 | 100   | ratioOfQueryCores       |          | **S**    |          | 设置查询线程的最大数量。                                     |                                                              |                                                              | 最小值0 表示只有1个查询线程；最大值2表示最大建立2倍CPU核数的查询线程。默认为1，表示最大和CPU核数相等的查询线程。该值可以为小数，即0.5表示最大建立CPU核数一半的查询线程。 |
 | 101   | update                  |          | **S**    |          | 允许更新已存在的数据行                                         | 0 \| 1                                                       | 0                                                            | 从 2.0.8.0 版本开始                                                       |
 | 102   | cacheLast               |          | **S**    |          | 是否在内存中缓存子表的最近数据                                  | 0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值；3：同时打开缓存最近行和列功能。                                                       | 0                                                            | 2.1.2.0 版本之前、2.0.20.7 版本之前在 taos.cfg 文件中不支持此参数。                                             |
-| 103   | numOfCommitThreads      | YES      | **S**    |          | 设置写入线程的最大数量                                       |                                                              |                                                              |     
+| 103   | numOfCommitThreads      | YES      | **S**    |          | 设置写入线程的最大数量                                       |                                                              |                                                              |                                                              |
+| 104   | maxWildCardsLength      |          | **C**    | bytes    | 设定 LIKE 算子的通配符字符串允许的最大长度                     | 0-16384                                                       | 100                                                          | 2.1.6.1 版本新增。                                                     |
 
 **注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030到6042共13个端口，而且必须TCP和UDP都打开。（详细的端口情况请参见 [TDengine 2.0 端口说明](https://www.taosdata.com/cn/documentation/faq#port)）
 

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

@@ -206,7 +206,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
 
     显示当前数据库下的所有数据表信息。
 
-    说明：可在like中使用通配符进行名称的匹配，这一通配符字符串最长不能超过24字节。
+    说明：可在 like 中使用通配符进行名称的匹配，这一通配符字符串最长不能超过 20 字节。（ 从 2.1.6.1 版本开始，通配符字符串的长度放宽到了 100 字节，并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串，将有可能严重影响 LIKE 操作的执行性能。）
 
     通配符匹配：1）'%'（百分号）匹配0到任意个字符；2）'\_'下划线匹配单个任意字符。
 
@@ -953,6 +953,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
 ### 选择函数
 
+在使用所有的选择函数的时候，可以同时指定输出 ts 列或标签列（包括 tbname），这样就可以方便地知道被选出的值是源于哪个数据行的。
+
 - **MIN**
     ```mysql
     SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];

src/client/src/tscParseInsert.c

@@ -657,9 +657,7 @@ int32_t tsParseValues(char **str, STableDataBlocks *pDataBlock, int maxRows, SIn
     index = 0;
     sToken = tStrGetToken(*str, &index, false);
     if (sToken.n == 0 || sToken.type != TK_RP) {
-      tscSQLSyntaxErrMsg(pInsertParam->msg, ") expected", *str);
-      code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
-      return code;
+      return tscSQLSyntaxErrMsg(pInsertParam->msg, ") expected", *str);
     }
     
     *str += index;

src/client/src/tscSQLParser.c

@@ -4293,7 +4293,7 @@ static bool isValidExpr(tSqlExpr* pLeft, tSqlExpr* pRight, int32_t optr) {
   if (pRight == NULL) {
     return true;
   }
-  
+
   if (pLeft->tokenId >= TK_BOOL && pLeft->tokenId <= TK_BINARY && pRight->tokenId >= TK_BOOL && pRight->tokenId <= TK_BINARY) {
     return false;
   }

src/client/src/tscSubquery.c

@@ -2404,8 +2404,8 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
           SColumn* x = taosArrayGetP(pNewQueryInfo->colList, index1);
           tscColumnCopy(x, pCol);
         } else {
-          SColumn *p = tscColumnClone(pCol);
-          taosArrayPush(pNewQueryInfo->colList, &p);
+          SSchema ss = {.type = (uint8_t)pCol->info.type, .bytes = pCol->info.bytes, .colId = (int16_t)pCol->columnIndex};
+          tscColumnListInsert(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid, &ss);
         }
       }
     }

src/common/src/tglobal.c

@@ -991,7 +991,7 @@ static void doInitGlobalConfig(void) {
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = 0;
-  cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
+  cfg.maxValue = TSDB_MAX_FIELD_LEN;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_BYTE;
   taosInitConfigOption(cfg);

src/connector/nodejs/nodetaos/taosobjects.js

@@ -47,7 +47,8 @@ class TaosTimestamp extends Date {
       super(Math.floor(date / 1000));
       this.precisionExtras = date % 1000;
     } else if (precision === 2) {
-      super(parseInt(date / 1000000));
+      // 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 {

src/connector/nodejs/package.json

 {
   "name": "td2.0-connector",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "A Node.js connector for TDengine.",
   "main": "tdengine.js",
   "directories": {

src/dnode/src/dnodeSystem.c

@@ -42,6 +42,8 @@ int32_t main(int32_t argc, char *argv[]) {
       }
     } else if (strcmp(argv[i], "-C") == 0) {
       dump_config = 1;
+    } else if (strcmp(argv[i], "--force-keep-file") == 0) {
+      tsdbForceKeepFile = true;
     } else if (strcmp(argv[i], "--compact-mnode-wal") == 0) {
       tsCompactMnodeWal = 1;
     } else if (strcmp(argv[i], "-V") == 0) {

src/inc/taosmsg.h

@@ -471,6 +471,7 @@ typedef struct {
 
   bool        stableQuery;      // super table query or not
   bool        topBotQuery;      // TODO used bitwise flag
+  bool        interpQuery;      // interp query or not
   bool        groupbyColumn;    // denote if this is a groupby normal column query
   bool        hasTagResults;    // if there are tag values in final result or not
   bool        timeWindowInterpo;// if the time window start/end required interpolation

src/kit/taosdemo/taosdemo.c

@@ -75,6 +75,7 @@ extern char configDir[];
 #define BUFFER_SIZE         TSDB_MAX_ALLOWED_SQL_LEN
 #define COND_BUF_LEN        (BUFFER_SIZE - 30)
 #define COL_BUFFER_LEN      ((TSDB_COL_NAME_LEN + 15) * TSDB_MAX_COLUMNS)
+
 #define MAX_USERNAME_SIZE  64
 #define MAX_PASSWORD_SIZE  20
 #define MAX_HOSTNAME_SIZE  253      // https://man7.org/linux/man-pages/man7/hostname.7.html
@@ -245,7 +246,6 @@ typedef struct SArguments_S {
     uint32_t disorderRatio;               // 0: no disorder, >0: x%
     int      disorderRange;               // ms, us or ns. accordig to database precision
     uint32_t method_of_delete;
-    char **  arg_list;
     uint64_t totalInsertRows;
     uint64_t totalAffectedRows;
     bool     demo_mode;                  // use default column name and semi-random data
@@ -637,7 +637,6 @@ SArguments g_args = {
     0,               // disorderRatio
     1000,            // disorderRange
     1,               // method_of_delete
-    NULL,            // arg_list
     0,               // totalInsertRows;
     0,               // totalAffectedRows;
     true,            // demo_mode;
@@ -1011,6 +1010,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                     exit(EXIT_FAILURE);
                 }
                 arguments->datatype[0] = argv[i];
+                arguments->datatype[1] = NULL;
             } else {
                 // more than one col
                 int index = 0;
@@ -1415,6 +1415,7 @@ static char *rand_float_str()
     return g_randfloat_buff + (cursor * FLOAT_BUFF_LEN);
 }
 
+
 static float rand_float()
 {
     static int cursor;
@@ -6409,6 +6410,9 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
     bool flagSleep = true;
     uint64_t sleepTimeTotal = 0;
 
+    int percentComplete = 0;
+    int64_t totalRows = insertRows * pThreadInfo->ntables;
+
     while(pThreadInfo->totalInsertRows < pThreadInfo->ntables * insertRows) {
         if ((flagSleep) && (insert_interval)) {
             st = taosGetTimestampMs();
@@ -6585,6 +6589,11 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
 
         pThreadInfo->totalAffectedRows += affectedRows;
 
+        int currentPercent = pThreadInfo->totalAffectedRows * 100 / totalRows;
+        if (currentPercent > percentComplete ) {
+            printf("[%d]:%d%%\n", pThreadInfo->threadID, currentPercent);
+            percentComplete = currentPercent;
+        }
         int64_t  currentPrintTime = taosGetTimestampMs();
         if (currentPrintTime - lastPrintTime > 30*1000) {
             printf("thread[%d] has currently inserted rows: %"PRIu64 ", affected rows: %"PRIu64 "\n",
@@ -6606,6 +6615,8 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
             }
         }
     }
+    if (percentComplete < 100)
+        printf("[%d]:%d%%\n", pThreadInfo->threadID, percentComplete);
 
 free_of_interlace:
     tmfree(pThreadInfo->buffer);
@@ -6643,6 +6654,9 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
 
     pThreadInfo->samplePos = 0;
 
+    int percentComplete = 0;
+    int64_t totalRows = insertRows * pThreadInfo->ntables;
+
     for (uint64_t tableSeq = pThreadInfo->start_table_from;
             tableSeq <= pThreadInfo->end_table_to;
             tableSeq ++) {
@@ -6748,6 +6762,11 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
 
             pThreadInfo->totalAffectedRows += affectedRows;
 
+            int currentPercent = pThreadInfo->totalAffectedRows * 100 / totalRows;
+            if (currentPercent > percentComplete ) {
+                printf("[%d]:%d%%\n", pThreadInfo->threadID, currentPercent);
+                percentComplete = currentPercent;
+            }
             int64_t  currentPrintTime = taosGetTimestampMs();
             if (currentPrintTime - lastPrintTime > 30*1000) {
                 printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n",
@@ -6770,6 +6789,8 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
                     __func__, __LINE__, pThreadInfo->samplePos);
         }
     } // tableSeq
+    if (percentComplete < 100)
+        printf("[%d]:%d%%\n", pThreadInfo->threadID, percentComplete);
 
 free_of_progressive:
     tmfree(pThreadInfo->buffer);

src/mnode/src/mnodeShow.c

@@ -253,11 +253,15 @@ static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) {
     
   int32_t connId = htonl(pHBMsg->connId);
   SConnObj *pConn = mnodeAccquireConn(connId, connInfo.user, connInfo.clientIp, connInfo.clientPort);
+  if (pConn == NULL) {
+    pHBMsg->pid = htonl(pHBMsg->pid);
+    pConn = mnodeCreateConn(connInfo.user, connInfo.clientIp, connInfo.clientPort, pHBMsg->pid, pHBMsg->appName);
+  }
 
   if (pConn == NULL) {
     // do not close existing links, otherwise
     // mError("failed to create connId, close connect");
-    // pRsp->killConnection = 1;
+    // pRsp->killConnection = 1;    
   } else {
     pRsp->connId = htonl(pConn->connId);
     mnodeSaveQueryStreamList(pConn, pHBMsg);

src/mnode/src/mnodeWrite.c

@@ -65,7 +65,14 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) {
     return TSDB_CODE_MND_MSG_NOT_PROCESSED;
   }
 
-  int32_t code = mnodeInitMsg(pMsg);
+  int32_t code = grantCheck(TSDB_GRANT_TIME);
+  if (code != TSDB_CODE_SUCCESS) {
+    mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
+           tstrerror(code));
+    return code;
+  }
+
+  code = mnodeInitMsg(pMsg);
   if (code != TSDB_CODE_SUCCESS) {
     mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
            tstrerror(code));

src/query/inc/qExecutor.h

@@ -333,6 +333,8 @@ enum OPERATOR_TYPE_E {
   OP_Distinct          = 20,
   OP_Join              = 21,
   OP_StateWindow       = 22,
+  OP_AllTimeWindow     = 23,
+  OP_AllMultiTableTimeInterval = 24,
 };
 
 typedef struct SOperatorInfo {
@@ -554,11 +556,13 @@ SOperatorInfo* createAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOpera
 SOperatorInfo* createProjectOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream);
 SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createAllTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createAllMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);

src/query/inc/qUtil.h

@@ -39,7 +39,6 @@
 #define GET_QID(_r)  (((SQInfo*)((_r)->qinfo))->qId)
 
 #define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
-#define GET_ROW_PARAM_FOR_MULTIOUTPUT(_q, tbq, sq) (((tbq) && (!(sq)))? (_q)->pExpr1[1].base.param[0].i64:1)
 
 int32_t getOutputInterResultBufSize(SQueryAttr* pQueryAttr);
 
@@ -60,6 +59,7 @@ SResultRowCellInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t
 
 void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr);
 void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols);
+int32_t getRowNumForMultioutput(SQueryAttr* pQueryAttr, bool topBottomQuery, bool stable);
 
 static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {
   assert(pResultRowInfo != NULL && slot >= 0 && slot < pResultRowInfo->size);
@@ -70,7 +70,7 @@ static FORCE_INLINE char* getPosInResultPage(SQueryAttr* pQueryAttr, tFilePage*
                                              int32_t offset) {
   assert(rowOffset >= 0 && pQueryAttr != NULL);
 
-  int32_t numOfRows = (int32_t)GET_ROW_PARAM_FOR_MULTIOUTPUT(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery);
+  int32_t numOfRows = (int32_t)getRowNumForMultioutput(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery);
   return ((char *)page->data) + rowOffset + offset * numOfRows;
 }
 

src/query/src/qAggMain.c

@@ -3708,27 +3708,59 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
       }
     } else {
       // no data generated yet
-      if (pCtx->size == 1) {
+      if (pCtx->size < 1) {
         return;
       }
 
       // check the timestamp in input buffer
       TSKEY skey = GET_TS_DATA(pCtx, 0);
-      TSKEY ekey = GET_TS_DATA(pCtx, 1);
-
-      // no data generated yet
-      if (!(skey < pCtx->startTs && ekey > pCtx->startTs)) {
-        return;
-      }
-
-      assert(pCtx->start.key == INT64_MIN && skey < pCtx->startTs && ekey > pCtx->startTs);
 
       if (type == TSDB_FILL_PREV) {
+        if (skey > pCtx->startTs) {
+          return;
+        }
+
+        if (pCtx->size > 1) {
+          TSKEY ekey = GET_TS_DATA(pCtx, 1);
+          if (ekey > skey && ekey <= pCtx->startTs) {
+            skey = ekey;
+          }
+        }
         assignVal(pCtx->pOutput, pCtx->pInput, pCtx->outputBytes, pCtx->inputType);
       } else if (type == TSDB_FILL_NEXT) {
-        char* val = ((char*)pCtx->pInput) + pCtx->inputBytes;
+        TSKEY ekey = skey;
+        char* val = NULL;
+        
+        if (ekey < pCtx->startTs) {
+          if (pCtx->size > 1) {
+            ekey = GET_TS_DATA(pCtx, 1);
+            if (ekey < pCtx->startTs) {
+              return;
+            }
+
+            val = ((char*)pCtx->pInput) + pCtx->inputBytes;            
+          } else {
+            return;
+          }
+        } else {
+          val = (char*)pCtx->pInput;
+        }
+        
         assignVal(pCtx->pOutput, val, pCtx->outputBytes, pCtx->inputType);
       } else if (type == TSDB_FILL_LINEAR) {
+        if (pCtx->size <= 1) {
+          return;
+        }
+      
+        TSKEY ekey = GET_TS_DATA(pCtx, 1);
+      
+        // no data generated yet
+        if (!(skey < pCtx->startTs && ekey > pCtx->startTs)) {
+          return;
+        }
+        
+        assert(pCtx->start.key == INT64_MIN && skey < pCtx->startTs && ekey > pCtx->startTs);
+        
         char *start = GET_INPUT_DATA(pCtx, 0);
         char *end = GET_INPUT_DATA(pCtx, 1);
 
@@ -4047,9 +4079,9 @@ void block_func_merge(SQLFunctionCtx* pCtx) {
   STableBlockDist info = {0};
   int32_t len = *(int32_t*) pCtx->pInput;
   blockDistInfoFromBinary(((char*)pCtx->pInput) + sizeof(int32_t), len, &info);
-
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   mergeTableBlockDist(pResInfo, &info);
+  taosArrayDestroy(info.dataBlockInfos); 
 
   pResInfo->numOfRes = 1;
   pResInfo->hasResult = DATA_SET_FLAG;

src/query/src/qFill.c

@@ -206,6 +206,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
     } else {
       assert(pFillInfo->currentKey == ts);
       initBeforeAfterDataBuf(pFillInfo, prev);
+      if (pFillInfo->type == TSDB_FILL_NEXT && (pFillInfo->index + 1) < pFillInfo->numOfRows) {
+        initBeforeAfterDataBuf(pFillInfo, next);
+        ++pFillInfo->index;
+        copyCurrentRowIntoBuf(pFillInfo, srcData, *next);
+        --pFillInfo->index;
+      }
 
       // assign rows to dst buffer
       for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
@@ -227,6 +233,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
           } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
             assignVal(output, src, pCol->col.bytes, pCol->col.type);
             memcpy(*prev + pCol->col.offset, src, pCol->col.bytes);
+          } else if (pFillInfo->type == TSDB_FILL_NEXT) {
+            if (*next) {
+              assignVal(output, *next + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+            } else {
+              setNull(output, pCol->col.type, pCol->col.bytes);
+            }
           } else {
             assignVal(output, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
           }

src/query/src/qPlan.c

@@ -567,10 +567,18 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
     }
   } else if (pQueryAttr->interval.interval > 0) {
     if (pQueryAttr->stableQuery) {
-      op = OP_MultiTableTimeInterval;
+      if (pQueryAttr->pointInterpQuery) {
+        op = OP_AllMultiTableTimeInterval;
+      } else {
+        op = OP_MultiTableTimeInterval;
+      }
       taosArrayPush(plan, &op);
-    } else {
-      op = OP_TimeWindow;
+    } else {      
+      if (pQueryAttr->pointInterpQuery) {
+        op = OP_AllTimeWindow;
+      } else {
+        op = OP_TimeWindow;
+      }
       taosArrayPush(plan, &op);
 
       if (pQueryAttr->pExpr2 != NULL) {
@@ -578,7 +586,7 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
         taosArrayPush(plan, &op);
       }
 
-      if (pQueryAttr->fillType != TSDB_FILL_NONE && (!pQueryAttr->pointInterpQuery)) {
+      if (pQueryAttr->fillType != TSDB_FILL_NONE) {
         op = OP_Fill;
         taosArrayPush(plan, &op);
       }

src/query/src/qUtil.c

@@ -30,6 +30,18 @@ typedef struct SCompSupporter {
   int32_t           order;
 } SCompSupporter;
 
+int32_t getRowNumForMultioutput(SQueryAttr* pQueryAttr, bool topBottomQuery, bool stable) {
+  if (pQueryAttr && (!stable)) {
+    for (int16_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
+      if (pQueryAttr->pExpr1[i].base.functionId == TSDB_FUNC_TOP || pQueryAttr->pExpr1[i].base.functionId == TSDB_FUNC_BOTTOM) {
+        return (int32_t)pQueryAttr->pExpr1[i].base.param[0].i64;
+      }
+    }
+  }
+
+  return 1;
+}
+
 int32_t getOutputInterResultBufSize(SQueryAttr* pQueryAttr) {
   int32_t size = 0;
 

src/query/tests/rangeMergeTest.cpp

@@ -330,7 +330,7 @@ void intDataTest() {
     filterAddRange(h, ra + i, TSDB_RELATION_AND);
   }
   filterGetRangeNum(h, &num);
-  ASSERT_EQ(num, 0);
+  ASSERT_EQ(num, 1);
   filterFreeRangeCtx(h);
 
 

src/rpc/src/rpcTcp.c

@@ -397,7 +397,11 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
   SThreadObj *pThreadObj = pClientObj->pThreadObj[index];
 
   SOCKET fd = taosOpenTcpClientSocket(ip, port, pThreadObj->ip);
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  if (fd == (SOCKET)-1) return NULL;
+#else
   if (fd <= 0) return NULL;
+#endif
 
   struct sockaddr_in sin;
   uint16_t localPort = 0;

src/tsdb/inc/tsdbMeta.h

@@ -24,8 +24,7 @@ typedef struct STable {
   tstr*          name;  // NOTE: there a flexible string here
   uint64_t       suid;
   struct STable* pSuper;  // super table pointer
-  uint8_t        numOfSchemas;
-  STSchema*      schema[TSDB_MAX_TABLE_SCHEMAS];
+  SArray*        schema;
   STSchema*      tagSchema;
   SKVRow         tagVal;
   SSkipList*     pIndex;         // For TSDB_SUPER_TABLE, it is the skiplist index
@@ -107,10 +106,9 @@ static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock,
 
   if (lock) TSDB_RLOCK_TABLE(pDTable);
   if (_version < 0) {  // get the latest version of schema
-    pTSchema = pDTable->schema[pDTable->numOfSchemas - 1];
+    pTSchema = *(STSchema **)taosArrayGetLast(pDTable->schema);
   } else {  // get the schema with version
-    void* ptr = taosbsearch(&_version, pDTable->schema, pDTable->numOfSchemas, sizeof(STSchema*),
-                            tsdbCompareSchemaVersion, TD_EQ);
+    void* ptr = taosArraySearch(pDTable->schema, &_version, tsdbCompareSchemaVersion, TD_EQ);
     if (ptr == NULL) {
       terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
       goto _exit;

src/tsdb/src/tsdbFS.c

@@ -37,6 +37,8 @@ static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired);
 static int  tsdbProcessExpiredFS(STsdbRepo *pRepo);
 static int  tsdbCreateMeta(STsdbRepo *pRepo);
 
+// For backward compatibility
+bool tsdbForceKeepFile = false;
 // ================== CURRENT file header info
 static int tsdbEncodeFSHeader(void **buf, SFSHeader *pHeader) {
   int tlen = 0;
@@ -1048,6 +1050,26 @@ static int tsdbRestoreMeta(STsdbRepo *pRepo) {
           return -1;
         }
 
+        if (tsdbForceKeepFile) {
+          struct stat tfstat;
+
+          // Get real file size
+          if (fstat(pfs->cstatus->pmf->fd, &tfstat) < 0) {
+            terrno = TAOS_SYSTEM_ERROR(errno);
+            tsdbCloseMFile(pfs->cstatus->pmf);
+            tfsClosedir(tdir);
+            regfree(&regex);
+            return -1;
+          }
+
+          if (pfs->cstatus->pmf->info.size != tfstat.st_size) {
+            int64_t tfsize = pfs->cstatus->pmf->info.size;
+            pfs->cstatus->pmf->info.size = tfstat.st_size;
+            tsdbInfo("vgId:%d file %s header size is changed from %" PRId64 " to %" PRId64, REPO_ID(pRepo),
+                     TSDB_FILE_FULL_NAME(pfs->cstatus->pmf), tfsize, pfs->cstatus->pmf->info.size);
+          }
+        }
+
         tsdbCloseMFile(pfs->cstatus->pmf);
       }
     } else if (code == REG_NOMATCH) {
@@ -1212,6 +1234,24 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
         return -1;
       }
 
+      if (tsdbForceKeepFile) {
+        struct stat tfstat;
+
+        // Get real file size
+        if (fstat(pDFile->fd, &tfstat) < 0) {
+          terrno = TAOS_SYSTEM_ERROR(errno);
+          taosArrayDestroy(fArray);
+          return -1;
+        }
+
+        if (pDFile->info.size != tfstat.st_size) {
+          int64_t tfsize = pDFile->info.size;
+          pDFile->info.size = tfstat.st_size;
+          tsdbInfo("vgId:%d file %s header size is changed from %" PRId64 " to %" PRId64, REPO_ID(pRepo),
+                   TSDB_FILE_FULL_NAME(pDFile), tfsize, pDFile->info.size);
+        }
+      }
+
       tsdbCloseDFile(pDFile);
       index++;
     }

src/tsdb/src/tsdbMeta.c

@@ -43,6 +43,8 @@ static int     tsdbRemoveTableFromStore(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbRmTableFromMeta(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbAdjustMetaTables(STsdbRepo *pRepo, int tid);
 static int     tsdbCheckTableTagVal(SKVRow *pKVRow, STSchema *pSchema);
+static int     tsdbAddSchema(STable *pTable, STSchema *pSchema);
+static void    tsdbFreeTableSchema(STable *pTable);
 
 // ------------------ OUTER FUNCTIONS ------------------
 int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
@@ -722,17 +724,10 @@ void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema,
   STsdbMeta *pMeta = pRepo->tsdbMeta;
 
   STable *pCTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
-  ASSERT(schemaVersion(pSchema) > schemaVersion(pCTable->schema[pCTable->numOfSchemas - 1]));
+  ASSERT(schemaVersion(pSchema) > schemaVersion(*(STSchema **)taosArrayGetLast(pCTable->schema)));
 
   TSDB_WLOCK_TABLE(pCTable);
-  if (pCTable->numOfSchemas < TSDB_MAX_TABLE_SCHEMAS) {
-    pCTable->schema[pCTable->numOfSchemas++] = pSchema;
-  } else {
-    ASSERT(pCTable->numOfSchemas == TSDB_MAX_TABLE_SCHEMAS);
-    tdFreeSchema(pCTable->schema[0]);
-    memmove(pCTable->schema, pCTable->schema + 1, sizeof(STSchema *) * (TSDB_MAX_TABLE_SCHEMAS - 1));
-    pCTable->schema[pCTable->numOfSchemas - 1] = pSchema;
-  }
+  tsdbAddSchema(pCTable, pSchema);
 
   if (schemaNCols(pSchema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(pSchema);
   if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
@@ -828,9 +823,7 @@ static STable *tsdbCreateTableFromCfg(STableCfg *pCfg, bool isSuper, STable *pST
     TABLE_TID(pTable) = -1;
     TABLE_SUID(pTable) = -1;
     pTable->pSuper = NULL;
-    pTable->numOfSchemas = 1;
-    pTable->schema[0] = tdDupSchema(pCfg->schema);
-    if (pTable->schema[0] == NULL) {
+    if (tsdbAddSchema(pTable, tdDupSchema(pCfg->schema)) < 0) {
       terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
       goto _err;
     }
@@ -841,7 +834,8 @@ static STable *tsdbCreateTableFromCfg(STableCfg *pCfg, bool isSuper, STable *pST
     }
     pTable->tagVal = NULL;
     STColumn *pCol = schemaColAt(pTable->tagSchema, DEFAULT_TAG_INDEX_COLUMN);
-    pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, colType(pCol), (uint8_t)(colBytes(pCol)), NULL, SL_ALLOW_DUP_KEY, getTagIndexKey);
+    pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, colType(pCol), (uint8_t)(colBytes(pCol)), NULL,
+                                     SL_ALLOW_DUP_KEY, getTagIndexKey);
     if (pTable->pIndex == NULL) {
       terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
       goto _err;
@@ -870,9 +864,7 @@ static STable *tsdbCreateTableFromCfg(STableCfg *pCfg, bool isSuper, STable *pST
       }
     } else {
       TABLE_SUID(pTable) = -1;
-      pTable->numOfSchemas = 1;
-      pTable->schema[0] = tdDupSchema(pCfg->schema);
-      if (pTable->schema[0] == NULL) {
+      if (tsdbAddSchema(pTable, tdDupSchema(pCfg->schema)) < 0) {
         terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
         goto _err;
       }
@@ -906,9 +898,7 @@ static void tsdbFreeTable(STable *pTable) {
                 TABLE_UID(pTable));
     tfree(TABLE_NAME(pTable));
     if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
-      for (int i = 0; i < TSDB_MAX_TABLE_SCHEMAS; i++) {
-        tdFreeSchema(pTable->schema[i]);
-      }
+      tsdbFreeTableSchema(pTable);
 
       if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
         tdFreeSchema(pTable->tagSchema);
@@ -1260,9 +1250,10 @@ static int tsdbEncodeTable(void **buf, STable *pTable) {
     tlen += taosEncodeFixedU64(buf, TABLE_SUID(pTable));
     tlen += tdEncodeKVRow(buf, pTable->tagVal);
   } else {
-    tlen += taosEncodeFixedU8(buf, pTable->numOfSchemas);
-    for (int i = 0; i < pTable->numOfSchemas; i++) {
-      tlen += tdEncodeSchema(buf, pTable->schema[i]);
+    tlen += taosEncodeFixedU8(buf, (uint8_t)taosArrayGetSize(pTable->schema));
+    for (int i = 0; i < taosArrayGetSize(pTable->schema); i++) {
+      STSchema *pSchema = taosArrayGetP(pTable->schema, i);
+      tlen += tdEncodeSchema(buf, pSchema);
     }
 
     if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
@@ -1293,9 +1284,12 @@ static void *tsdbDecodeTable(void *buf, STable **pRTable) {
     buf = taosDecodeFixedU64(buf, &TABLE_SUID(pTable));
     buf = tdDecodeKVRow(buf, &(pTable->tagVal));
   } else {
-    buf = taosDecodeFixedU8(buf, &(pTable->numOfSchemas));
-    for (int i = 0; i < pTable->numOfSchemas; i++) {
-      buf = tdDecodeSchema(buf, &(pTable->schema[i]));
+    uint8_t nSchemas;
+    buf = taosDecodeFixedU8(buf, &nSchemas);
+    for (int i = 0; i < nSchemas; i++) {
+      STSchema *pSchema;
+      buf = tdDecodeSchema(buf, &pSchema);
+      tsdbAddSchema(pTable, pSchema);
     }
 
     if (TABLE_TYPE(pTable) == TSDB_SUPER_TABLE) {
@@ -1457,3 +1451,38 @@ static int tsdbCheckTableTagVal(SKVRow *pKVRow, STSchema *pSchema) {
 
   return 0;
 }
+
+static int tsdbAddSchema(STable *pTable, STSchema *pSchema) {
+  ASSERT(TABLE_TYPE(pTable) != TSDB_CHILD_TABLE);
+
+  if (pTable->schema == NULL) {
+    pTable->schema = taosArrayInit(TSDB_MAX_TABLE_SCHEMAS, sizeof(SSchema *));
+    if (pTable->schema == NULL) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+      return -1;
+    }
+  }
+
+  ASSERT(taosArrayGetSize(pTable->schema) == 0 ||
+         schemaVersion(pSchema) > schemaVersion(*(STSchema **)taosArrayGetLast(pTable->schema)));
+
+  if (taosArrayPush(pTable->schema, &pSchema) == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
+  return 0;
+}
+
+static void tsdbFreeTableSchema(STable *pTable) {
+  ASSERT(pTable != NULL);
+
+  if (pTable->schema) {
+    for (size_t i = 0; i < taosArrayGetSize(pTable->schema); i++) {
+      STSchema *pSchema = taosArrayGetP(pTable->schema, i);
+      tdFreeSchema(pSchema);
+    }
+
+    taosArrayDestroy(pTable->schema);
+  }
+}
\ No newline at end of file

src/tsdb/src/tsdbRead.c

@@ -2693,7 +2693,7 @@ static void destroyHelper(void* param) {
   free(param);
 }
 
-static bool loadBlockOfActiveTable(STsdbQueryHandle* pQueryHandle) {
+static bool  loadBlockOfActiveTable(STsdbQueryHandle* pQueryHandle) {
   if (pQueryHandle->checkFiles) {
     // check if the query range overlaps with the file data block
     bool exists = true;

src/util/inc/tconfig.h

@@ -81,6 +81,7 @@ typedef struct {
 extern SGlobalCfg tsGlobalConfig[];
 extern int32_t    tsGlobalConfigNum;
 extern char *     tsCfgStatusStr[];
+extern bool       tsdbForceKeepFile;
 
 void taosReadGlobalLogCfg();
 bool taosReadGlobalCfg();

src/util/src/tcompare.c

@@ -280,25 +280,26 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
 
 int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
   SPatternCompareInfo pInfo = {'%', '_'};
-  
-  char pattern[128] = {0};
+
+  assert(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN);
+  char *pattern = calloc(varDataLen(pRight) + 1, sizeof(char));
   memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
-  assert(varDataLen(pRight) < 128);
 
   size_t sz = varDataLen(pLeft);
-  char *buf = malloc(sz + 1); 
-  memcpy(buf, varDataVal(pLeft), sz); 
+  char *buf = malloc(sz + 1);
+  memcpy(buf, varDataVal(pLeft), sz);
   buf[sz] = 0;
 
   int32_t ret = patternMatch(pattern, buf, sz, &pInfo);
   free(buf);
+  free(pattern);
   return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
 
 int32_t taosArrayCompareString(const void* a, const void* b) {
   const char* x = *(const char**)a;
   const char* y = *(const char**)b;
-  
+
   return compareLenPrefixedStr(x, y);
 }
 
@@ -307,19 +308,19 @@ int32_t taosArrayCompareString(const void* a, const void* b) {
 //  return taosArraySearchString(arr, pLeft, taosArrayCompareString, TD_EQ) == NULL ? 0 : 1;
 //}
 int32_t compareFindItemInSet(const void *pLeft, const void* pRight)  {
-  return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;    
+  return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;
 }
 
 int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
   SPatternCompareInfo pInfo = {'%', '_'};
 
-  wchar_t pattern[128] = {0};
-  assert(TSDB_PATTERN_STRING_MAX_LEN < 128);
+  assert(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN * TSDB_NCHAR_SIZE);
+  wchar_t *pattern = calloc(varDataLen(pRight) + 1, sizeof(wchar_t));
 
   memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
-  assert(varDataLen(pRight) < 128);
-  
+
   int32_t ret = WCSPatternMatch(pattern, varDataVal(pLeft), varDataLen(pLeft)/TSDB_NCHAR_SIZE, &pInfo);
+  free(pattern);
   return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
 }
 

tests/perftest-scripts/perftest-query.sh

@@ -101,7 +101,14 @@ function runQueryPerfTest {
 
 	python3 insert/insertFromCSVPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
 	
+	echo "=========== taosdemo performance: 4 int columns, 10000 tables, 100000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
 	python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
+
+	echo "=========== taosdemo performance: 400 int columns, 400 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
+	python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 400 -D 400 -B 200 -t 10000 -r 1000 | tee -a $PERFORMANCE_TEST_REPORT
+
+	echo "=========== taosdemo performance: 1900 int columns, 1900 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
+	python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 1900 -D 1900 -B 200 -t 10000 -r 1000 | tee -a $PERFORMANCE_TEST_REPORT
 }
 
 

tests/pytest/alter/alterColMultiTimes.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import random
+import string
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def genColList(self):
+        '''
+            generate column list
+        '''
+        col_list = list()
+        for i in range(1, 18):
+            col_list.append(f'c{i}')
+        return col_list
+
+    def genIncreaseValue(self, input_value):
+        '''
+            add ', 1' to end of value every loop
+        '''
+        value_list = list(input_value)
+        value_list.insert(-1, ", 1")
+        return ''.join(value_list)
+
+    def insertAlter(self):
+        '''
+            after each alter and insert, when execute 'select * from {tbname};' taosd will coredump
+        '''
+        tbname = ''.join(random.choice(string.ascii_letters.lower()) for i in range(7))
+        input_value = '(now, 1)'
+        tdSql.execute(f'create table {tbname} (ts timestamp, c0 int);')
+        tdSql.execute(f'insert into  {tbname} values {input_value};')
+        for col in self.genColList():
+            input_value = self.genIncreaseValue(input_value)
+            tdSql.execute(f'alter table {tbname} add column {col} int;')
+            tdSql.execute(f'insert into {tbname} values {input_value};')
+        tdSql.query(f'select * from {tbname};')
+        tdSql.checkRows(18)
+            
+    def run(self):
+        tdSql.prepare()
+        self.insertAlter()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/crash_gen/valgrind_taos.supp

@@ -17742,4 +17742,370 @@
    fun:taosGetFqdn
    fun:taosCheckGlobalCfg
    fun:taos_init_imp
-}
+}
\ No newline at end of file
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/bin/python3.8
+   fun:PyObject_GetItem
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   fun:PyCode_NewWithPosOnlyArgs
+   fun:PyCode_New
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/tslibs/parsing.cpython-38-x86_64-linux-gnu.so
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/tslibs/parsing.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/local/lib/python3.8
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_New
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_New
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyFunction_Vectorcall
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyFunction_Vectorcall
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8                      
+   obj:/usr/bin/python3.8                      
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyFunction_Vectorcall     
+   fun:_PyEval_EvalFrameDefault   
+   fun:_PyEval_EvalCodeWithName   
+   fun:_PyFunction_Vectorcall     
+   fun:_PyEval_EvalFrameDefault   
+   fun:_PyFunction_Vectorcall     
+   fun:_PyEval_EvalFrameDefault   
+   fun:_PyEval_EvalCodeWithName   
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun: malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/interval.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun: malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   obj:/usr/bin/python3.8
+   fun:PyObject_CallFunctionObjArgs
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyObject_GetAttr
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8)
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8)
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8)
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8)
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/interval.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8)
+   obj:/usr/bin/python3.8)
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/tslibs/np_datetime.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/tslibs/ccalendar.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/interval.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_Pack
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/hashtable.cpython-38-x86_64-linux-gnu.so
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/_libs/hashtable.cpython-38-x86_64-linux-gnu.so
+   fun:PyModule_ExecDef
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:PyVectorcall_Call
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   ...
+   obj:/usr/local/lib/python3.8/dist-packages/pandas/*
+   ...
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_New
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_New
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:_PyObject_MakeTpCall
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyFunction_Vectorcall
+   fun:_PyEval_EvalFrameDefault
+   obj:/usr/bin/python3.8
+   fun:PyObject_GetAttr
+   fun:_PyEval_EvalFrameDefault
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:/usr/bin/python3.8
+   fun:PyTuple_New
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   obj:/usr/bin/python3.8
+   fun:_PyEval_EvalFrameDefault
+   fun:_PyEval_EvalCodeWithName
+   fun:_PyFunction_Vectorcall
+} 

tests/pytest/fulltest.sh

@@ -284,7 +284,7 @@ python3 ./test.py -f alter/alterTabAddTagWithNULL.py
 python3 ./test.py -f alter/alterTimestampColDataProcess.py
 
 # client
-python3 ./test.py -f client/client.py
+#python3 ./test.py -f client/client.py
 python3 ./test.py -f client/version.py
 python3 ./test.py -f client/alterDatabase.py
 python3 ./test.py -f client/noConnectionErrorTest.py
@@ -386,6 +386,7 @@ python3 ./test.py -f query/querySession.py
 python3 test.py -f  alter/alter_create_exception.py
 python3 ./test.py -f insert/flushwhiledrop.py
 python3 ./test.py -f insert/schemalessInsert.py
+python3 ./test.py -f alter/alterColMultiTimes.py 
 
 #======================p4-end===============
 

tests/pytest/query/queryWildcardLength.py

@@ -157,19 +157,6 @@ class TDTestCase:
         tdSql.execute(f'create table {table_name}_sub1 using {table_name} tags ("{table_name}", "{table_name}")')
         tdSql.execute(f'insert into {table_name}_sub1 values (now, "{table_name}", "{table_name}");')
 
-        # TODO sc1 leave a bug ---> TD-5918
-        # sql_list = [f'select * from {table_name} where bi1 like "{hp_name}"',
-        #             f'select * from {table_name} where bi1 like "{lp_name}"',
-        #             f'select * from {table_name} where bi1 like "{ul_name}"',
-        #             f'select * from {table_name} where nc1 like "{hp_name}"',
-        #             f'select * from {table_name} where nc1 like "{lp_name}"',
-        #             f'select * from {table_name} where nc1 like "{ul_name}"',
-        #             f'select * from {table_name} where si1 like "{hp_name}"',
-        #             f'select * from {table_name} where si1 like "{lp_name}"',
-        #             f'select * from {table_name} where si1 like "{ul_name}"',
-        #             f'select * from {table_name} where sc1 like "{hp_name}"',
-        #             f'select * from {table_name} where sc1 like "{lp_name}"',
-        #             f'select * from {table_name} where sc1 like "{ul_name}"']
         sql_list = [f'select * from {table_name} where bi1 like "{hp_name}"',
                     f'select * from {table_name} where bi1 like "{lp_name}"',
                     f'select * from {table_name} where bi1 like "{ul_name}"',
@@ -178,7 +165,11 @@ class TDTestCase:
                     f'select * from {table_name} where nc1 like "{ul_name}"',
                     f'select * from {table_name} where si1 like "{hp_name}"',
                     f'select * from {table_name} where si1 like "{lp_name}"',
-                    f'select * from {table_name} where si1 like "{ul_name}"']
+                    f'select * from {table_name} where si1 like "{ul_name}"',
+                    f'select * from {table_name} where sc1 like "{hp_name}"',
+                    f'select * from {table_name} where sc1 like "{lp_name}"',
+                    f'select * from {table_name} where sc1 like "{ul_name}"']
+      
         for sql in sql_list:
             tdSql.query(sql)
             if len(table_name) >= 1:
@@ -211,7 +202,6 @@ class TDTestCase:
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)
 
-
 tdCases.addWindows(__file__, TDTestCase())
 tdCases.addLinux(__file__, TDTestCase())
 

tests/pytest/tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py

@@ -47,7 +47,6 @@ class TDTestCase:
         else:
             tdLog.info("taosd found in %s" % buildPath)
         binPath = buildPath + "/build/bin/"
-
         # insert: create one  or mutiple tables per sql and insert multiple rows per sql
         # insert data from a special timestamp
         # check stable stb0
@@ -90,7 +89,6 @@ class TDTestCase:
         os.system(
             "%staosdemo -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestNanoDatabaseNow.json -y " %
             binPath)
-
         tdSql.execute("use nsdb2")
         tdSql.query("show stables")
         tdSql.checkData(0, 4, 100)

tests/pytest/tools/taosdemoAllTest/taosdemoTestSupportNanosubscribe.py

@@ -103,7 +103,6 @@ class TDTestCase:
 
         os.system("cat subscribe_res0.txt* > all_subscribe_res0.txt")
         subTimes0 = self.subTimes("all_subscribe_res0.txt")
-        print("pass")
         self.assertCheck("all_subscribe_res0.txt",subTimes0 ,202)
 
         

tests/pytest/tools/taosdemoPerformance.py

@@ -19,11 +19,16 @@ import json
 import sys
 
 class taosdemoPerformace:
-    def __init__(self, commitID, dbName, branch, type):
+    def __init__(self, commitID, dbName, branch, type, numOfTables, numOfRows, numOfInt, numOfDouble, numOfBinary):
         self.commitID = commitID
         self.dbName = dbName
         self.branch = branch
         self.type = type
+        self.numOfTables = numOfTables
+        self.numOfRows = numOfRows
+        self.numOfInt = numOfInt
+        self.numOfDouble = numOfDouble
+        self.numOfBinary = numOfBinary 
         self.host = "127.0.0.1"
         self.user = "root"
         self.password = "taosdata"
@@ -51,14 +56,14 @@ class taosdemoPerformace:
         stb = {
             "name": "meters",
             "child_table_exists": "no",
-            "childtable_count": 10000,
+            "childtable_count": self.numOfTables,
             "childtable_prefix": "stb_",
             "auto_create_table": "no",
             "data_source": "rand",
             "batch_create_tbl_num": 10,
             "insert_mode": "taosc",
-            "insert_rows": 100000,
-            "interlace_rows": 100,
+            "insert_rows": self.numOfRows,
+            "interlace_rows": 0,
             "max_sql_len": 1024000,
             "disorder_ratio": 0,
             "disorder_range": 1000,
@@ -68,7 +73,9 @@ class taosdemoPerformace:
             "sample_file": "./sample.csv",
             "tags_file": "",
             "columns": [
-                {"type": "INT", "count": 4}
+                {"type": "INT", "count": self.numOfInt},
+                {"type": "DOUBLE", "count": self.numOfDouble},
+                {"type": "BINARY", "len": 128, "count": self.numOfBinary}
             ],
             "tags": [
                 {"type": "INT", "count": 1},
@@ -76,6 +83,7 @@ class taosdemoPerformace:
             ]
         }
 
+
         stables = []
         stables.append(stb)
 
@@ -163,21 +171,21 @@ class taosdemoPerformace:
 
         cursor.execute("create database if not exists %s" % self.dbName)
         cursor.execute("use %s" % self.dbName)
-        cursor.execute("create table if not exists taosdemo_perf (ts timestamp, create_table_time float, insert_records_time float, records_per_second float, commit_id binary(50), avg_delay float, max_delay float, min_delay float, branch binary(50), type binary(20))")
-        print("==================== taosdemo performance ====================")
+        cursor.execute("create table if not exists taosdemo_perf (ts timestamp, create_table_time float, insert_records_time float, records_per_second float, commit_id binary(50), avg_delay float, max_delay float, min_delay float, branch binary(50), type binary(20), numoftables int, numofrows int, numofint int, numofdouble int, numofbinary int)")
         print("create tables time: %f" % float(self.createTableTime))
         print("insert records time: %f" % float(self.insertRecordsTime))
         print("records per second: %f" % float(self.recordsPerSecond))
         print("avg delay: %f" % float(self.avgDelay))
         print("max delay: %f" % float(self.maxDelay))
         print("min delay: %f" % float(self.minDelay))
-        cursor.execute("insert into taosdemo_perf values(now, %f, %f, %f, '%s', %f, %f, %f, '%s', '%s')" %
+        cursor.execute("insert into taosdemo_perf values(now, %f, %f, %f, '%s', %f, %f, %f, '%s', '%s', %d, %d, %d, %d, %d)" %
             (float(self.createTableTime), float(self.insertRecordsTime), float(self.recordsPerSecond), 
-            self.commitID, float(self.avgDelay), float(self.maxDelay), float(self.minDelay), self.branch, self.type))
+            self.commitID, float(self.avgDelay), float(self.maxDelay), float(self.minDelay), self.branch, 
+            self.type, self.numOfTables, self.numOfRows, self.numOfInt, self.numOfDouble, self.numOfBinary))
         cursor.close()
 
         cursor1 = self.conn.cursor()
-        cursor1.execute("drop database if exists %s" % self.insertDB)
+        # cursor1.execute("drop database if exists %s" % self.insertDB)
         cursor1.close()
 
 if __name__ == '__main__':
@@ -209,8 +217,43 @@ if __name__ == '__main__':
         default='glibc',
         type=str,
         help='build type (default: glibc)')
+    parser.add_argument(
+        '-i',
+        '--num-of-int',
+        action='store',
+        default=4,
+        type=int,
+        help='num of int columns (default: 4)')
+    parser.add_argument(
+        '-D',
+        '--num-of-double',
+        action='store',
+        default=0,
+        type=int,
+        help='num of double columns (default: 4)')
+    parser.add_argument(
+        '-B',
+        '--num-of-binary',
+        action='store',
+        default=0,
+        type=int,
+        help='num of binary columns (default: 4)')
+    parser.add_argument(
+        '-t',
+        '--num-of-tables',
+        action='store',
+        default=10000,
+        type=int,
+        help='num of tables (default: 10000)')
+    parser.add_argument(
+        '-r',
+        '--num-of-rows',
+        action='store',
+        default=100000,
+        type=int,
+        help='num of rows (default: 100000)')
     args = parser.parse_args()
 
-    perftest = taosdemoPerformace(args.commit_id, args.database_name, args.git_branch, args.build_type)
+    perftest = taosdemoPerformace(args.commit_id, args.database_name, args.git_branch, args.build_type, args.num_of_tables, args.num_of_rows, args.num_of_int, args.num_of_double, args.num_of_binary)
     perftest.insertData()
     perftest.createTablesAndStoreData()

tests/script/general/parser/fill.sim

@@ -1050,6 +1050,27 @@ sql_error select min(c3) from m_fl_mt0 interval(10w) fill(value, 20)
 sql_error select max(c3) from m_fl_mt0 interval(1n) fill(prev)
 sql_error select min(c3) from m_fl_mt0 interval(1y) fill(value, 20)
 
+sql create table nexttb1 (ts timestamp, f1 int);
+sql insert into nexttb1 values ('2021-08-08 1:1:1', NULL);
+sql insert into nexttb1 values ('2021-08-08 1:1:5', 3);
+
+sql select last(*) from nexttb1 where ts >= '2021-08-08 1:1:1' and ts < '2021-08-08 1:1:10' interval(1s) fill(next);
+if $rows != 9 then
+  return -1
+endi
+if $data00 != @21-08-08 01:01:01.000@ then
+  return -1
+endi
+if $data01 != @21-08-08 01:01:01.000@ then
+  return -1
+endi
+if $data02 != 3 then
+  return -1
+endi
+
+
+
+
 print =============== clear
 #sql drop database $db
 #sql show databases
@@ -1057,4 +1078,4 @@ print =============== clear
 #  return -1
 #endi
 
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

tests/script/general/parser/function.sim

@@ -1148,3 +1148,21 @@ endi
 
 
 sql select derivative(test_column_alias_name, 1s, 0) from (select avg(k) test_column_alias_name from t1 interval(1s));
+
+sql create table smeters (ts timestamp, current float, voltage int);
+sql insert into smeters values ('2021-08-08 10:10:10', 10, 1);
+sql insert into smeters values ('2021-08-08 10:10:12', 10, 2);
+
+sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000'  and current=10 interval(1000a);
+if $rows != 2 then
+  return -1
+endi
+if $data00 != @21-08-08 10:10:10.000@ then
+  return -1
+endi
+if $data10 != @21-08-08 10:10:12.000@ then
+  return -1
+endi
+
+
+

tests/script/general/parser/interp.sim

@@ -55,6 +55,9 @@ while $i < $halfNum
 endw 
 print ====== tables created
 
+sql create table ap1 (ts timestamp, pav float);
+sql INSERT INTO ap1 VALUES ('2021-07-25 02:19:54.100',1) ('2021-07-25 02:19:54.200',2) ('2021-07-25 02:19:54.300',3) ('2021-07-25 02:19:56.500',4) ('2021-07-25 02:19:57.500',5) ('2021-07-25 02:19:57.600',6) ('2021-07-25 02:19:57.900',7) ('2021-07-25 02:19:58.100',8) ('2021-07-25 02:19:58.300',9) ('2021-07-25 02:19:59.100',10) ('2021-07-25 02:19:59.300',11) ('2021-07-25 02:19:59.500',12) ('2021-07-25 02:19:59.700',13) ('2021-07-25 02:19:59.900',14) ('2021-07-25 02:20:05.000', 20) ('2021-07-25 02:25:00.000', 10000);
+
 run general/parser/interp_test.sim
 
 print ================== restart server to commit data into disk
@@ -65,4 +68,4 @@ print ================== server restart completed
 
 run general/parser/interp_test.sim
 
-system sh/exec.sh -n dnode1 -s stop -x SIGINT
+#system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file