Merge branch 'develop' into update-windows-jenkins

efbf23f5 · Yiqing Liu · GitHub · 4652d42b · 59fd3317 · efbf23f5
329 changed file
--- a/.drone.yml
+++ b/.drone.yml
 ---
 kind: pipeline
-name: test_amd64
-platform:
-  os: linux
-  arch: amd64
-steps:
- name: build
-  image: gcc
-  commands:
-  - apt-get update
-  - apt-get install -y cmake build-essential 
-  - mkdir debug
-  - cd debug
-  - cmake .. 
-  - make -j4 
-  trigger:
-    event:
-      - pull_request
-  when:
-    branch:
-    - develop
-    - master
-    - 2.0
---
-kind: pipeline
 name: test_arm64_bionic
 platform:
@@ -36,7 +10,11 @@ steps:
  image: arm64v8/ubuntu:bionic
  commands:
  - apt-get update
-  - apt-get install -y cmake build-essential
+  - apt-get install -y cmake  git build-essential wget
+  - wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -63,7 +41,11 @@ steps:
  commands:
  - echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
  - apt-get update 
-  - apt-get install -y -qq cmake build-essential
+  - apt-get install -y -qq git cmake build-essential wget
+  - wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -88,10 +70,18 @@ steps:
 - name: build
  image: arm64v8/centos:7
  commands:
-  - yum install -y gcc gcc-c++ make cmake git
+  - yum install -y epel-release
+  - yum update
+  - yum install -y gcc gcc-c++ make cmake3  wget git 
+  - wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - ln -s /usr/bin/cmake3 /usr/bin/cmake
+  - go version
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
-  - cmake .. -DCPUTYPE=aarch64 > /dev/null
+  - cmake3 .. -DCPUTYPE=aarch64 > /dev/null
  - make -j4 
  trigger:
    event:
@@ -113,7 +103,8 @@ steps:
 - name: build
  image: arm64v8/centos:8
  commands:
-  - dnf install -y gcc gcc-c++ make cmake epel-release git libarchive
+  - dnf install -y gcc gcc-c++ make cmake epel-release git libarchive golang
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -139,7 +130,8 @@ steps:
  image: arm32v7/ubuntu:bionic
  commands:
  - apt-get update
-  - apt-get install -y cmake build-essential
+  - apt-get install -y cmake build-essential golang-go git
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. -DCPUTYPE=aarch32 > /dev/null
@@ -165,8 +157,11 @@ steps:
  image: ubuntu:trusty
  commands:
  - apt-get update
-  - apt-get install -y gcc cmake3 build-essential git binutils-2.26
+  - apt-get install -y gcc cmake3 build-essential git binutils-2.26 wget 
+  - wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. 
@@ -192,7 +187,11 @@ steps:
  image: ubuntu:xenial
  commands:
  - apt-get update
-  - apt-get install -y gcc cmake build-essential
+  - apt-get install -y gcc cmake build-essential  git wget
+  - wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. 
@@ -217,7 +216,11 @@ steps:
  image: ubuntu:bionic
  commands:
  - apt-get update
-  - apt-get install -y gcc cmake build-essential
+  - apt-get install -y gcc cmake build-essential  git wget
+  - wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
  - cmake .. 
@@ -241,10 +244,17 @@ steps:
 - name: build
  image: ansible/centos7-ansible
  commands:
-  - yum install -y gcc gcc-c++ make cmake
+  - yum install -y epel-release
+  - yum update
+  - yum install -y gcc gcc-c++ make cmake3  wget git 
+  - wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
+  - tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
+  - export PATH=$PATH:/usr/local/go/bin
+  - ln -s /usr/bin/cmake3 /usr/bin/cmake
+  - git submodule update --init --recursive
  - mkdir debug
  - cd debug
-  - cmake .. 
+  - cmake3 .. 
  - make -j4 
  trigger:
    event:

--- a/.gitmodules
+++ b/.gitmodules
@@ -16,3 +16,6 @@
 [submodule "deps/TSZ"]
 	path = deps/TSZ
 	url = https://github.com/taosdata/TSZ.git
+[submodule "src/plugins/blm3"]
+	path = src/plugins/blm3
+	url = https://github.com/taosdata/blm3
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,9 +10,9 @@ ELSE ()
 ENDIF ()
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 ELSE ()
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
 ENDIF ()
 SET(TD_ACCOUNT FALSE)
@@ -38,7 +38,7 @@ MESSAGE(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
 INCLUDE(cmake/input.inc)
 INCLUDE(cmake/platform.inc)
-IF (TD_WINDOWS OR TD_DARWIN) 
+IF (TD_WINDOWS OR TD_DARWIN)
  SET(TD_SOMODE_STATIC TRUE)
 ENDIF ()

--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -72,6 +72,7 @@ def pre_test(){
    git fetch origin +refs/pull/${CHANGE_ID}/merge
    git checkout -qf FETCH_HEAD
    git clean -dfx
+    git submodule update --init --recursive
    cd ${WK}
    git reset --hard HEAD~10
    '''
@@ -98,7 +99,7 @@ def pre_test(){
    sh '''
    cd ${WK}
    git pull >/dev/null 
    export TZ=Asia/Harbin
    date
    git clean -dfx
@@ -148,6 +149,7 @@ def pre_test_win(){
    git fetch origin +refs/pull/%CHANGE_ID%/merge
    git checkout -qf FETCH_HEAD
    git clean -dfx
+    git submodule update --init --recursive
    cd C:\\workspace\\TDinternal
    git reset --hard HEAD~10
    '''
@@ -468,35 +470,35 @@ pipeline {
          }
        } 
-        stage('build'){
+        // stage('build'){
-          agent{label " wintest "}
+        //   agent{label " wintest "}
-          steps {
+        //   steps {
-            pre_test()
+        //     pre_test()
-            script{             
+        //     script{             
-                while(win_stop == 0){
+        //         while(win_stop == 0){
-                  sleep(1)
+        //           sleep(1)
-                  }
+        //           }
-              }
+        //       }
-            }
+        //     }
-        }
+        // }
-        stage('test'){
+        // stage('test'){
-          agent{label "win"}
+        //   agent{label "win"}
-          steps{
+        //   steps{
-            catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+        //     catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
-                pre_test_win()
+        //         pre_test_win()
-                timeout(time: 20, unit: 'MINUTES'){
+        //         timeout(time: 20, unit: 'MINUTES'){
-                bat'''
+        //         bat'''
-                cd C:\\workspace\\TDinternal\\community\\tests\\pytest
+        //         cd C:\\workspace\\TDinternal\\community\\tests\\pytest
-                .\\test-all.bat Wintest
+        //         .\\test-all.bat Wintest
-                '''
+        //         '''
-                }
+        //         }
-            }     
+        //     }     
-            script{
+        //     script{
-              win_stop=1
+        //       win_stop=1
-            }
+        //     }
-          }
+        //   }
-        }
+        // }
    }

--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 [![TDengine](TDenginelogo.png)](https://www.taosdata.com)
-English | [简体中文](./README-CN.md) 
+English | [简体中文](./README-CN.md)
 We are hiring, check [here](https://www.taosdata.com/en/careers/)
 # What is TDengine？
@@ -32,7 +32,7 @@ For user manual, system design and architecture, engineering blogs, refer to [TD
 # Building
 At the moment, TDengine only supports building and running on Linux systems. You can choose to [install from packages](https://www.taosdata.com/en/getting-started/#Install-from-Package) or from the source code. This quick guide is for installation from the source only.
-To build TDengine, use [CMake](https://cmake.org/) 2.8.12.x or higher versions in the project directory. 
+To build TDengine, use [CMake](https://cmake.org/) 3.0.2 or higher versions in the project directory.
 ## Install tools
@@ -47,7 +47,7 @@ sudo apt-get install -y gcc cmake3 build-essential git binutils-2.26
 export PATH=/usr/lib/binutils-2.26/bin:$PATH
 ```
-To compile and package the JDBC driver source code, you should have a Java jdk-8 or higher and Apache Maven 2.7 or higher installed. 
+To compile and package the JDBC driver source code, you should have a Java jdk-8 or higher and Apache Maven 2.7 or higher installed.
 To install openjdk-8:
 ```bash
 sudo apt-get install -y openjdk-8-jdk
@@ -60,7 +60,10 @@ sudo apt-get install -y  maven
 ### Centos 7:
 ```bash
-sudo yum install -y gcc gcc-c++ make cmake git
+sudo yum install epel-release
+sudo yum update
+sudo yum install -y gcc gcc-c++ make cmake3 git
+sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 To install openjdk-8:
@@ -88,6 +91,15 @@ To install Apache Maven:
 sudo dnf install -y maven
 ```
+### Setup golang environment
+TDengine includes few components developed by Go language. Please refer to golang.org official documentation for golang environment setup.
+Please use version 1.14+. For the user in China, we recommend using a proxy to accelerate package downloading.
+```
+go env -w GO111MODULE=on
+go env -w GOPROXY=https://goproxy.cn,direct
+```
 ## Get the source codes
 First of all, you may clone the source codes from github:
@@ -227,7 +239,7 @@ In another terminal, use the TDengine shell to connect the server:
 ./build/bin/taos -c test/cfg
 ```
-option "-c test/cfg" specifies the system configuration file directory. 
+option "-c test/cfg" specifies the system configuration file directory.
 # Try TDengine
 It is easy to run SQL commands from TDengine shell which is the same as other SQL databases.

--- a/alert/release.sh
+++ b/alert/release.sh
@@ -52,7 +52,7 @@ echo "cpuType=${cpuType}"
 echo "osType=${osType}"
 echo "version=${version}"
-GOOS=${osType} GOARCH=${cpuType} go build -ldflags '-X main.version='${version}
+GOOS=${osType} GOARCH=${cpuType} go mod tidy && go build -ldflags '-X main.version='${version}
 mkdir -p TDengine-alert/driver

--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -87,7 +87,7 @@ IF (TD_ARM_64)
  ADD_DEFINITIONS(-DUSE_LIBICONV)
  MESSAGE(STATUS "arm64 is defined")
  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
@@ -124,7 +124,17 @@ IF (TD_APLHINE)
  MESSAGE(STATUS "aplhine is defined")
 ENDIF ()
-IF (TD_BUILD_HTTP)
+IF (TD_LINUX)
+  IF (TD_ARM_32)
+    SET(TD_BUILD_HTTP TRUE)
+    ADD_DEFINITIONS(-DHTTP_EMBEDDED)
+  ELSE ()
+    IF (TD_BUILD_HTTP)
+      ADD_DEFINITIONS(-DHTTP_EMBEDDED)
+    ENDIF ()
+  ENDIF ()
+ELSE ()
+  SET(TD_BUILD_HTTP TRUE)
  ADD_DEFINITIONS(-DHTTP_EMBEDDED)
 ENDIF ()

--- a/cmake/env.inc
+++ b/cmake/env.inc
@@ -2,7 +2,12 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
 PROJECT(TDengine)
 SET(CMAKE_C_STANDARD 11)
-SET(CMAKE_VERBOSE_MAKEFILE ON)
+IF (TD_BUILD_VERBOSE)
+  SET(CMAKE_VERBOSE_MAKEFILE ON)
+ELSE ()
+  SET(CMAKE_VERBOSE_MAKEFILE OFF)
+ENDIF ()
 #set output directory
 SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/lib)

--- a/cmake/input.inc
+++ b/cmake/input.inc
@@ -90,10 +90,10 @@ IF (${BUILD_JDBC} MATCHES "false")
  SET(TD_BUILD_JDBC FALSE)
 ENDIF ()
-SET(TD_BUILD_HTTP TRUE)
+SET(TD_BUILD_HTTP FALSE)
-IF (${BUILD_HTTP} MATCHES "false")
+IF (${BUILD_HTTP} MATCHES "true")
-  SET(TD_BUILD_HTTP FALSE)
+  SET(TD_BUILD_HTTP TRUE)
 ENDIF ()
 SET(TD_MEMORY_SANITIZER FALSE)
@@ -101,11 +101,17 @@ IF (${MEMORY_SANITIZER} MATCHES "true")
  SET(TD_MEMORY_SANITIZER TRUE)
 ENDIF ()
+SET(TD_BUILD_VERBOSE FALSE)
+IF (${VERBOSE} MATCHES "true")
+  SET(CMAKE_VERBOSE_MAKEFILE ON)
+  SET(TD_BUILD_VERBOSE TRUE)
+ENDIF ()
 IF (${TSZ_ENABLED} MATCHES "true")
-  # define add 
+  # define add
  MESSAGE(STATUS "build with TSZ enabled")
  ADD_DEFINITIONS(-DTD_TSZ)
  set(VAR_TSZ "TSZ" CACHE INTERNAL "global variant tsz" )
 ELSE()
  set(VAR_TSZ "" CACHE INTERNAL "global variant empty" )
-ENDIF()  
+ENDIF()
--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -6,6 +6,8 @@ IF (TD_LINUX)
 ELSEIF (TD_WINDOWS)
  IF (TD_POWER)
    SET(CMAKE_INSTALL_PREFIX C:/PowerDB)
+  ELSEIF (TD_PRO)
+    SET(CMAKE_INSTALL_PREFIX C:/ProDB)
  ELSE ()
    SET(CMAKE_INSTALL_PREFIX C:/TDengine)
  ENDIF ()
@@ -24,6 +26,8 @@ ELSEIF (TD_WINDOWS)
  IF (TD_POWER)
    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/power.exe DESTINATION .)
+  ELSEIF (TD_PRO)
+    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/prodbc.exe DESTINATION .)
  ELSE ()
    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosdemo.exe DESTINATION .)

--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.1.7.2")
+  SET(TD_VER_NUMBER "2.2.0.5")
 ENDIF ()
 IF (DEFINED VERCOMPATIBLE)

--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
 PROJECT(TDengine)
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 ELSE ()
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
 ENDIF ()
 ADD_SUBDIRECTORY(zlib-1.2.11)

--- a/deps/MQTT-C/CMakeLists.txt
+++ b/deps/MQTT-C/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 # MQTT-C build options
 option(MQTT_C_OpenSSL_SUPPORT "Build MQTT-C with OpenSSL support?" OFF)

--- a/deps/MsvcLibX/CMakeLists.txt
+++ b/deps/MsvcLibX/CMakeLists.txt
 PROJECT(TDengine)
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 ELSE ()
-  CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+  CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
 ENDIF ()
 IF (TD_WINDOWS)

--- a/deps/cJson/inc/cJSON.h
+++ b/deps/cJson/inc/cJSON.h
@@ -73,7 +73,7 @@ typedef struct cJSON
    char *string;
    //Keep the original string of number
-    char numberstring[13];
+    char numberstring[64];
 } cJSON;
 typedef struct cJSON_Hooks

--- a/deps/cJson/src/cJSON.c
+++ b/deps/cJson/src/cJSON.c
@@ -290,7 +290,7 @@ loop_end:
    input_buffer->offset += (size_t)(after_end - number_c_string);
-    strncpy(item->numberstring, (const char *)number_c_string, 12);
+    strncpy(item->numberstring, (const char *)number_c_string, strlen((const char*)number_c_string));
    return true;
 }

--- a/deps/iconv/CMakeLists.txt
+++ b/deps/iconv/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_WINDOWS)

--- a/deps/pthread/CMakeLists.txt
+++ b/deps/pthread/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_WINDOWS)

--- a/deps/regex/CMakeLists.txt
+++ b/deps/regex/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_WINDOWS)

--- a/deps/wepoll/CMakeLists.txt
+++ b/deps/wepoll/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_WINDOWS)

--- a/deps/zlib-1.2.11/CMakeLists.txt
+++ b/deps/zlib-1.2.11/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_WINDOWS)

--- a/documentation20/cn/00.index/docs.md
+++ b/documentation20/cn/00.index/docs.md
@@ -53,6 +53,8 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [Schemaless 写入](/insert#schemaless)：免于预先建表，将数据直接写入时自动维护元数据结构
 * [Prometheus 写入](/insert#prometheus)：配置Prometheus, 不用任何代码，将数据直接写入
 * [Telegraf 写入](/insert#telegraf)：配置Telegraf, 不用任何代码，将采集数据直接写入
+* [collectd 直接写入](/insert#collectd)：配置 collectd，不用任何代码，将采集数据直接写入
+* [StatsD 直接写入](/insert#statsd)：配置 StatsD，不用任何代码，将采集数据直接写入
 * [EMQ X Broker](/insert#emq)：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
 * [HiveMQ Broker](/insert#hivemq)：配置HiveMQ，不用任何代码，就可将MQTT数据直接写入
@@ -118,6 +120,11 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 * [数据复制](/architecture/replica)：支持实时同步、异步复制，保证系统的High Availibility
 * [技术博客](https://www.taosdata.com/cn/blog/?categories=3)：更多的技术分析和架构设计文章
+## [应用 TDengine 快速搭建 IT 运维系统](/devops)
+* [devops](/devops/telegraf)：使用 TDengine + Telegraf + Grafana 快速搭建 IT 运维系统
+* [devops](/devops/collectd)：使用 TDengine + collectd_statsd + Grafana 快速搭建 IT 运维系统
 ## 常用工具
 * [TDengine样例导入工具](https://www.taosdata.com/blog/2020/01/18/1166.html)

--- a/documentation20/cn/02.getting-started/01.docker/docs.md
+++ b/documentation20/cn/02.getting-started/01.docker/docs.md
@@ -224,7 +224,7 @@ tdengine
 1，通过端口映射(-p)，将容器内部开放的网络端口映射到宿主机的指定端口上。通过挂载本地目录(-v)，可以实现宿主机与容器内部的数据同步，防止容器删除后，数据丢失。
 ```bash
-$ docker run -d -v /etc/taos:/etc/taos -P 6041:6041 tdengine/tdengine
+$ docker run -d -v /etc/taos:/etc/taos -p 6041:6041 tdengine/tdengine
 526aa188da767ae94b244226a2b2eec2b5f17dd8eff592893d9ec0cd0f3a1ccd
 $ curl -u root:taosdata -d 'show databases' 127.0.0.1:6041/rest/sql

--- a/documentation20/cn/02.getting-started/02.taosdemo/docs.md
+++ b/documentation20/cn/02.getting-started/02.taosdemo/docs.md
--- a/documentation20/cn/02.getting-started/docs.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -175,8 +175,10 @@ taos> select avg(current), max(voltage), min(phase) from test.meters where group
 ```mysql
 taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
 ```
+## <a class="anchor" id="taosdemo"></a> taosdemo 详细功能列表
-**Note:** taosdemo 命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help` 详细列出。您可以设置不同参数进行体验。
+taosdemo 命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help` 详细列出。您可以设置不同参数进行体验。
+taosdemo 详细使用方法请参照 [如何使用taosdemo对TDengine进行性能测试？](https://www.taosdata.com/cn/documentation/getting-started/taosdemo )。
 ## 客户端和报警模块

--- a/documentation20/cn/04.model/docs.md
+++ b/documentation20/cn/04.model/docs.md
-# TDengine数据建模
+# TDengine 数据建模
-TDengine采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库、超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
+TDengine 采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库、超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
 关于数据建模请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1945.html)。
-## <a class="anchor" id="create-db"></a>创建库
+## <a class="anchor" id="create-db"></a> 创建库
-不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
+不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
 ```mysql
 CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
 ```
-上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，内存块数为6，允许更新数据。详细的语法及参数请见 [TAOS SQL 的数据管理](https://www.taosdata.com/cn/documentation/taos-sql#management) 章节。
+上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，内存块数为 6，允许更新数据。详细的语法及参数请见 [TAOS SQL 的数据管理](https://www.taosdata.com/cn/documentation/taos-sql#management) 章节。
-创建库之后，需要使用SQL命令USE将当前库切换过来，例如：
+创建库之后，需要使用 SQL 命令 USE 将当前库切换过来，例如：
 ```mysql
 USE power;	
 ```
-将当前连接里操作的库换为power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。  
+将当前连接里操作的库换为 power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。  
 **注意：**
 - 任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
- 处于两个不同库的表是不能进行JOIN操作的。
+- 处于两个不同库的表是不能进行 JOIN 操作的。
 - 创建并插入记录、查询历史记录的时候，均需要指定时间戳。
-## <a class="anchor" id="create-stable"></a>创建超级表
+## <a class="anchor" id="create-stable"></a> 创建超级表
-一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用TDengine, 需要对每个类型的数据采集点创建一个超级表。以[表1](https://www.taosdata.com/cn/documentation/architecture#model_table1)中的智能电表为例，可以使用如下的SQL命令创建超级表：
+一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用 TDengine, 需要对每个类型的数据采集点创建一个超级表。以[表1](https://www.taosdata.com/cn/documentation/architecture#model_table1) 中的智能电表为例，可以使用如下的 SQL 命令创建超级表：
 ```mysql
 CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
@@ -39,25 +39,25 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
 **注意：**这一指令中的 STABLE 关键字，在 2.0.15 之前的版本中需写作 TABLE 。
-与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义。第一列必须为时间戳（示例中为ts)，其他列为采集的物理量（示例中为current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](https://www.taosdata.com/cn/documentation/taos-sql#super-table) 章节。
+与创建普通表一样，创建表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts)，其他列为采集的物理量（示例中为 current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 schema (示例中为 location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](https://www.taosdata.com/cn/documentation/taos-sql#super-table) 章节。
 每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。一张超级表里包含的采集物理量必须是同时采集的（时间戳是一致的）。
 一张超级表最多容许 1024 列，如果一个采集点采集的物理量个数超过 1024，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。（从 2.1.7.0 版本开始，列数限制由 1024 列放宽到了 4096 列。）
-## <a class="anchor" id="create-table"></a>创建表
+## <a class="anchor" id="create-table"></a> 创建表
-TDengine对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以[表1](https://www.taosdata.com/cn/documentation/architecture#model_table1)中的智能电表为例，可以使用如下的SQL命令建表：
+TDengine 对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以[表1](https://www.taosdata.com/cn/documentation/architecture#model_table1)中的智能电表为例，可以使用如下的SQL命令建表：
 ```mysql
 CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 ```
-其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](https://www.taosdata.com/cn/documentation/taos-sql#table) 章节。
+其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值 ”Beijing.Chaoyang"，标签 groupId 的具体标签值 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](https://www.taosdata.com/cn/documentation/taos-sql#table) 章节。
-**注意：**目前 TDengine 没有从技术层面限制使用一个 database （dbA）的超级表作为模板建立另一个 database （dbB）的子表，后续会禁止这种用法，不建议使用这种方法建表。
+**注意：**目前 TDengine 没有从技术层面限制使用一个 database (dbA)的超级表作为模板建立另一个 database (dbB)的子表，后续会禁止这种用法，不建议使用这种方法建表。
-TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列号）。但对于有的场景，并没有唯一的ID，可以将多个ID组合成一个唯一的ID。不建议将具有唯一性的ID作为标签值。  
+TDengine 建议将数据采集点的全局唯一 ID 作为表名(比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。  
 **自动建表**：在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
@@ -65,13 +65,13 @@ TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列
 INSERT INTO d1001 USING meters TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
 ```
-上述SQL语句将记录 (now, 10.2, 219, 0.32) 插入表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值 `“Beijing.Chaoyang", 2`。
+上述 SQL 语句将记录(now, 10.2, 219, 0.32)插入表 d1001。如果表 d1001 还未创建，则使用超级表 meters 做模板自动创建，同时打上标签值 `“Beijing.Chaoyang", 2`。
 关于自动建表的详细语法请参见 [插入记录时自动建表](https://www.taosdata.com/cn/documentation/taos-sql#auto_create_table) 章节。
 ## 多列模型 vs 单列模型
-TDengine支持多列模型，只要物理量是一个数据采集点同时采集的（时间戳一致），这些量就可以作为不同列放在一张超级表里。但还有一种极限的设计，单列模型，每个采集的物理量都单独建表，因此每种类型的物理量都单独建立一超级表。比如电流、电压、相位，就建三张超级表。
+TDengine 支持多列模型，只要物理量是一个数据采集点同时采集的（时间戳一致），这些量就可以作为不同列放在一张超级表里。但还有一种极限的设计，单列模型，每个采集的物理量都单独建表，因此每种类型的物理量都单独建立一超级表。比如电流、电压、相位，就建三张超级表。
-TDengine建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得更简单。
+TDengine 建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得更简单。
--- a/documentation20/cn/05.insert/docs.md
+++ b/documentation20/cn/05.insert/docs.md
 # 高效写入数据
-TDengine支持多种接口写入数据，包括SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV文件等，后续还将提供Kafka, OPC等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。
+TDengine支持多种接口写入数据，包括SQL，Prometheus，Telegraf，collectd，StatsD，EMQ MQTT Broker，HiveMQ Broker，CSV文件等，后续还将提供Kafka，OPC等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。
 ## <a class="anchor" id="sql"></a>SQL 写入
@@ -98,7 +98,7 @@ Schemaless 按照如下原则来处理行数据：
 用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
 - Linux操作系统的服务器
- 安装好Golang，1.10版本以上
+- 安装好Golang，1.14版本以上
 - 对应的TDengine版本。因为用到了TDengine的客户端动态链接库，因此需要安装好和服务端相同版本的TDengine程序；比如服务端版本是TDengine 2.0.0, 则在Bailongma所在的Linux服务器（可以与TDengine在同一台服务器，或者不同服务器）
 Bailongma项目中有一个文件夹blm_prometheus，存放了prometheus的写入API程序。编译过程如下：
@@ -183,7 +183,76 @@ use prometheus;
 select * from apiserver_request_latencies_bucket;
 ```
-## <a class="anchor" id="telegraf"></a>Telegraf 直接写入
+## <a class="anchor" id="telegraf"></a> Telegraf 直接写入(通过 BLM v3)
+安装 Telegraf 请参考[官方文档](https://portal.influxdata.com/downloads/)。
+TDengine 新版本（2.3.0.0+）包含一个 BLM3 独立程序，负责接收包括 Telegraf 的多种应用的数据写入。
+配置方法，假设 TDengine 使用默认用户名 root 和密码 taosdata。在 /etc/telegraf/telegraf.conf 增加如下文字：
+```
+[[outputs.http]]
+  url = "http://<TDengine server/cluster host>:6041/influxdb/v1/write?db=metrics"
+  method = "POST"
+  timeout = "5s"
+  username = "root"
+  password = "taosdata"
+  data_format = "influx"
+  influx_max_line_bytes = 250
+```
+然后重启 telegraf：
+```
+sudo systemctl start telegraf
+```
+即可在 TDengine 中查询 metrics 数据库中 Telegraf 写入的数据。
+BLM v3 相关配置参数请参考 blm3 --help 命令输出以及相关文档。
+## <a class="anchor" id="collectd"></a> collectd 直接写入(通过 BLM v3)
+安装 collectd，请参考[官方文档](https://collectd.org/download.shtml)。
+TDengine 新版本（2.3.0.0+）包含一个 BLM3 独立程序，负责接收包括 collectd 的多种应用的数据写入。
+在 /etc/collectd/collectd.conf 文件中增加如下内容：
+```
+LoadPlugin network
+<Plugin network>
+  Server "<TDengine cluster/server host>" "25826"
+</Plugin>
+```
+重启 collectd
+```
+sudo systemctl start collectd
+```
+BLM v3 相关配置参数请参考 blm3 --help 命令输出以及相关文档。
+## <a class="anchor" id="statsd"></a> StatsD 直接写入(通过 BLM v3)
+安装 StatsD
+请参考[官方文档](https://github.com/statsd/statsd)。
+TDengine 新版本（2.3.0.0+）包含一个 BLM3 独立程序，负责接收包括 StatsD 的多种应用的数据写入。
+在 config.js 文件中增加如下内容后启动 StatsD：
+```
+backends 部分添加 "./backends/repeater"
+repeater 部分添加 { host:'<TDengine server/cluster host>', port: 8126 }
+```
+示例配置文件：
+```
+{
+port: 8125
+, backends: ["./backends/repeater"]
+, repeater: [{ host: '127.0.0.1', port: 8126}]
+}
+```
+BLM v3 相关配置参数请参考 blm3 --help 命令输出以及相关文档。
+## <a class="anchor" id="blm2-telegraf"></a> 使用 Bailongma 2.0 接入 Telegraf 数据写入
+*注意：TDengine 新版本（2.3.0.0+）提供新版本 Bailongma ，命名为 BLM v3，提供更简便的 Telegraf 数据写入以及其他更强大的功能，Bailongma v2 即之前版本将逐步不再维护。
 [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/)是一流行的IT运维数据采集开源工具，TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Telegraf做简单配置，无需任何代码，就可将Telegraf采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。

--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -407,9 +407,9 @@ typedef struct TAOS_MULTI_BIND {
 除了使用 SQL 方式或者使用参数绑定 API 写入数据外，还可以使用 Schemaless 的方式完成写入。Schemaless 可以免于预先创建超级表/数据子表的数据结构，而是可以直接写入数据，TDengine 系统会根据写入的数据内容自动创建和维护所需要的表结构。Schemaless 的使用方式详见 [Schemaless 写入](https://www.taosdata.com/cn/documentation/insert#schemaless) 章节，这里介绍与之配套使用的 C/C++ API。
+2.2.0.0版本接口：
 - `int taos_insert_lines(TAOS* taos, char* lines[], int numLines)`
-  （2.2.0.0 版本新增）  
  以 Schemaless 格式写入多行数据。其中：
    * taos：调用 taos_connect 返回的数据库连接。
    * lines：由 char 字符串指针组成的数组，指向本次想要写入数据库的多行数据。
@@ -421,6 +421,65 @@ typedef struct TAOS_MULTI_BIND {
    1. 此接口是一个同步阻塞式接口，使用时机与 `taos_query()` 一致。
    2. 在调用此接口之前，必须先调用 `taos_select_db()` 来确定目前是在向哪个 DB 来写入。
+2.3.0.0版本接口：
+- `int taos_schemaless_insert(TAOS* taos, const char* lines[], int numLines, int protocol, const char* precision, int* affectedRows, char* msg, int msgBufLen)`
+  **参数说明**
+    taos:  数据库连接，通过taos_connect 函数建立的数据库连接。
+    lines：文本数据。满足解析格式要求的无模式文本字符串。
+    numLines:文本数据的行数，不能为 0 。
+    protocol: 行协议类型，用于标识文本数据格式。
+    precision：文本数据中的时间戳精度字符串。
+    affectedRows：插入操作完成以后，正确写入到数据库中的记录行数。
+    msg: 如果出现错误（函数返回值不为 0）情况下，错误提示信息。该参数是输入参数，需要用户指定消息输出缓冲区，如果不指定该缓冲区（输入为NULL），即使出现错误也不会得到错误提示信息。
+    msgBufLen: 缓冲区的长度，避免错误提示消息越界。
+  **返回值**
+    0：无错误发生。
+    非 0 值：发生了错误。此时可以通过msg获取错误信息的提示。该返回值含义可以参考taoserror.h文件中的错误码定义。
+  **说明**
+    协议类型是枚举类型，包含以下三种格式：
+    SML_LINE_PROTOCOL：InfluxDB行协议（Line Protocol)
+    SML_TELNET_PROTOCOL: OpenTSDB文本行协议
+    SML_JSON_PROTOCOL: OpenTSDB Json协议格式
+    时间戳分辨率的说明使用如下字符串：“h“ （小时）、”m“（分钟）、”s“ （秒） ”ms“（毫秒）、”u“ (微秒）、”ns”（纳秒），不区分大小写。需要注意的是，时间戳分辨率参数只在协议类型为 SML_LINE_PROTOCOL 的时候生效。对于 OpenTSDB的文本协议，时间戳的解析遵循其官方解析规则 — 按照时间戳包含的字符的数量来确认时间精度。
+```c
+#include <stdlib.h>
+#include <stdio.h>
+#include <taos.h>
+int main() {
+  const char* host = "127.0.0.1";
+  const char* user = "root";
+  const char* passwd = "taosdata";
+  // error message buffer
+  char msg[512] = {0};
+  // connect to server
+  TAOS* taos = taos_connect(host, user, passwd, "test", 0);
+  // prepare the line string
+  char* lines1[] = {
+      "stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000",
+      "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833641000000"
+  };
+  // schema-less insert
+  int code = taos_schemaless_insert(taos, lines1, 2, SML_LINE_PROTOCOL, "ns", msg, sizeof(msg)/sizeof(msg[0]));
+  if (code != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", msg);
+  }
+  // close the connection
+  taos_close(taos);
+  return (code);
+}
+```
+**注**：后续2.2.0.0版本也更新成2.3.0.0版本的接口。
 ### 连续查询接口
 TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时间段，对一张或多张数据库的表(数据流)进行各种实时聚合计算操作。操作简单，仅有打开、关闭流的API。具体如下： 

--- a/documentation20/cn/10.cluster/docs.md
+++ b/documentation20/cn/10.cluster/docs.md
 # TDengine 集群安装、管理
-多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看《TDengine整体架构》一章。而且在安装集群之前，建议先按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)一章安装并体验单节点功能。
+多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看[《TDengine整体架构》](https://www.taosdata.com/cn/documentation/architecture)一章。而且在安装集群之前，建议先按照[《立即开始》](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地址。

--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -220,6 +220,10 @@ taosd -C
 | 102   | cacheLast               |          | **S**    |          | 是否在内存中缓存子表的最近数据                                  | 0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值；3：同时打开缓存最近行和列功能。（2.1.2.0 版本开始此参数支持 0～3 的取值范围，在此之前取值只能是 [0, 1]）                      | 0                                                            | 2.1.2.0 版本之前、2.0.20.7 版本之前在 taos.cfg 文件中不支持此参数。                                             |
 | 103   | numOfCommitThreads      | YES      | **S**    |          | 设置写入线程的最大数量                                       |                                                              |                                                              |                                                              |
 | 104   | maxWildCardsLength      |          | **C**    | bytes    | 设定 LIKE 算子的通配符字符串允许的最大长度                     | 0-16384                                                       | 100                                                          | 2.1.6.1 版本新增。                                                     |
+| 105  | compressColData         |          | **S**    | bytes    | 客户端与服务器之间进行消息通讯过程中，对服务器端查询结果进行列压缩的阈值。 | 0: 对所有查询结果均进行压缩  >0: 查询结果中任意列大小超过该值的消息才进行压缩  -1: 不压缩 | -1                                                           | 2.3.0.0 版本新增。                     |
+| 106    | tsdbMetaCompactRatio      |          | **C**    |          | tsdb meta文件中冗余数据超过多少阈值，开启meta文件的压缩功能                                  | 0：不开启，[1-100]：冗余数据比例                                                 | 0                                                            |  |
+| 107    | rpcForceTcp | | **SC**|  | 强制使用TCP传输 | 0: 不开启 1: 开启 ｜  0 ｜ 在网络比较差的环境中，建议开启。2.0版本新增。｜
+| 107  | rpcForceTcp         |          | **SC**    |     | 强制使用TCP传输。 | 0: 不开启 1: 开启 | 0                                              | 在网络比较差的环境中，建议开启。2.0 版本新增。                |
 **注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030到6042共13个端口，而且必须TCP和UDP都打开。（详细的端口情况请参见 [TDengine 2.0 端口说明](https://www.taosdata.com/cn/documentation/faq#port)）
@@ -365,7 +369,7 @@ taos -C  或  taos --dump-config
 - timezone
-    默认值：从系统中动态获取当前客户端运行系统所在的时区。
+    默认值：动态获取当前客户端运行系统所在的时区。
    为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。

--- a/documentation20/cn/12.taos-sql/02.udf/docs.md
+++ b/documentation20/cn/12.taos-sql/02.udf/docs.md
@@ -107,7 +107,7 @@ gcc -g -O0 -fPIC -shared add_one.c -o add_one.so
  例如，如下语句可以把 add_one.so 创建为系统中可用的 UDF：
  ```sql
-  CREATE FUNCTION add_one AS "/home/taos/udf_example/add_one.so" OUTPUTTYPE INT bufsize 128;
+  CREATE FUNCTION add_one AS "/home/taos/udf_example/add_one.so" OUTPUTTYPE INT;
  ```
 - 创建聚合函数：`CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize B;`
@@ -116,9 +116,9 @@ gcc -g -O0 -fPIC -shared add_one.c -o add_one.so
  * typename(Z)：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
  * B：系统使用的中间临时缓冲区大小，单位是字节，最小 0，最大 512，通常可以设置为 128。
-  例如，如下语句可以把 add_one.so 创建为系统中可用的 UDF：
+  例如，如下语句可以把 abs_max.so 创建为系统中可用的 UDF：
  ```sql
-  CREATE FUNCTION abs_max AS "/home/taos/udf_example/abs_max.so" OUTPUTTYPE BIGINT bufsize 128;
+  CREATE AGGREGATE FUNCTION abs_max AS "/home/taos/udf_example/abs_max.so" OUTPUTTYPE BIGINT bufsize 128;
  ```
 ### 管理 UDF

--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -67,15 +67,23 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
    CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
    ```
    说明：<!-- 注意：上一行中的 SQL 语句在企业版文档中会被替换，因此修改此语句的话，需要修改企业版文档的替换字典键值！！ -->
    1) KEEP是该数据库的数据保留多长天数，缺省是3650天(10年)，数据库会自动删除超过时限的数据；<!-- REPLACE_OPEN_TO_ENTERPRISE__KEEP_PARAM_DESCRIPTION -->
    2) UPDATE 标志数据库支持更新相同时间戳数据；（从 2.1.7.0 版本开始此参数支持设为 2，表示允许部分列更新，也即更新数据行时未被设置的列会保留原值。）（从 2.0.8.0 版本开始支持此参数。注意此参数不能通过 `ALTER DATABASE` 指令进行修改。）
+        1) UPDATE设为0时，表示不允许更新数据，后发送的相同时间戳的数据会被直接丢弃；
+        2) UPDATE设为1时，表示更新全部列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会被设为 NULL；
+        3) UPDATE设为2时，表示支持更新部分列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会保持原有数据行中的对应值；
+        4) 更多关于UPDATE参数的用法，请参考[FAQ](https://www.taosdata.com/cn/documentation/faq)。
    3) 数据库名最大长度为33；
    4) 一条SQL 语句的最大长度为65480个字符；
    5) 数据库还有更多与存储相关的配置参数，请参见 [服务端配置](https://www.taosdata.com/cn/documentation/administrator#config) 章节。
 - **显示系统当前参数**
@@ -160,9 +168,14 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
    3) 表的每行长度不能超过 16k 个字符;（注意：每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）
-    4) 子表名只能由字母、数字和下划线组成，且不能以数字开头
+    4) 子表名只能由字母、数字和下划线组成，且不能以数字开头，不区分大小写
    5) 使用数据类型 binary 或 nchar，需指定其最长的字节数，如 binary(20)，表示 20 字节；
+    6) 为了兼容支持更多形式的表名，TDengine 引入新的转义符 "\`"，可以让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。但是同样具有长度限制要求。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
+    例如：\`aBc\` 和 \`abc\` 是不同的表名，但是 abc 和 aBc 是相同的表名。
+    需要注意的是转义字符中的内容必须是可打印字符。
+    上述的操作逻辑和约束要求与MySQL数据的操作一致。
+    从 2.3.0.0 版本开始支持这种方式。
 - **以超级表为模板创建数据表**
@@ -713,18 +726,19 @@ Query OK, 1 row(s) in set (0.001091s)
 ### 支持的条件过滤操作
-| **Operation**   | **Note**                      | **Applicable Data Types**                 |
+| **Operation** | **Note**                 | **Applicable Data Types**                 |
-| --------------- | ----------------------------- | ----------------------------------------- |
+| ------------- | ------------------------ | ----------------------------------------- |
-| >               | larger than                   | **`timestamp`** and all numeric types     |
+| >             | larger than              | **`timestamp`** and all numeric types     |
-| <               | smaller than                  | **`timestamp`** and all numeric types     |
+| <             | smaller than             | **`timestamp`** and all numeric types     |
-| >=              | larger than or equal to       | **`timestamp`** and all numeric types     |
+| >=            | larger than or equal to  | **`timestamp`** and all numeric types     |
-| <=              | smaller than or equal to      | **`timestamp`** and all numeric types     |
+| <=            | smaller than or equal to | **`timestamp`** and all numeric types     |
-| =               | equal to                      | all types                                 |
+| =             | equal to                 | all types                                 |
-| <>              | not equal to                  | all types                                 |
+| <>            | not equal to             | all types                                 |
-| is [not] null   | is null or is not null        | all types                                 |
+| is [not] null | is null or is not null   | all types                                 |
-| between and     | within a certain range        | **`timestamp`** and all numeric types     |
+| between and   | within a certain range   | **`timestamp`** and all numeric types     |
-| in              | match any value in a set      | all types except first column `timestamp` |
+| in            | match any value in a set | all types except first column `timestamp` |
-| like            | match a wildcard string       | **`binary`** **`nchar`**                  |
+| like          | match a wildcard string  | **`binary`** **`nchar`**                  |
+| match/nmatch  | filter regex             | **regex**                                 |
 1. <> 算子也可以写为 != ，请注意，这个算子不能用于数据表第一列的 timestamp 字段。
 2. like 算子使用通配符字符串进行匹配检查。
@@ -736,7 +750,30 @@ Query OK, 1 row(s) in set (0.001091s)
 4. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如： `((value > 20 AND value < 30) OR (value < 12))`。
  * 从 2.3.0.0 版本开始，允许使用多个时间过滤条件，但首列时间戳的过滤运算结果只能包含一个区间。
 5. 从 2.0.17.0 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
-6. 从 2.1.4.0 版本开始，条件过滤开始支持 IN 算子，例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明：BOOL 类型写作 `{true, false}` 或 `{0, 1}` 均可，但不能写作 0、1 之外的整数；FLOAT 和 DOUBLE 类型会受到浮点数精度影响，集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功；TIMESTAMP 类型支持非主键的列。<!-- REPLACE_OPEN_TO_ENTERPRISE__IN_OPERATOR_AND_UNSIGNED_INTEGER -->
+6. 从 2.1.4.0 版本开始，条件过滤开始支持 IN 算子，例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明：BOOL 类型写作 `{true, false}` 或 `{0, 1}` 均可，但不能写作 0、1 之外的整数；FLOAT 和 DOUBLE 类型会受到浮点数精度影响，集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功；TIMESTAMP 类型支持非主键的列。
+7. 从2.3.0.0版本开始，条件过滤开始支持正则表达式，关键字match/nmatch，不区分大小写。
+   **语法**
+   WHERE (column|tbname) **match/MATCH/nmatch/NMATCH** *regex*
+   **正则表达式规范**
+   确保使用的正则表达式符合POSIX的规范，具体规范内容可参见[Regular Expressions](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html)
+   **使用限制**
+   只能针对表名（即 tbname 筛选）和标签的名称和binary类型标签值 进行正则表达式过滤，不支持针对普通列使用正则表达式过滤。
+   只能在 WHERE 子句中作为过滤条件存在。
+   正则匹配字符串长度不能超过 128 字节。可以通过参数 *maxRegexStringLen* 设置和调整最大允许的正则匹配字符串，该参数是客户端配置参数，需要重启才能生效。
+   **嵌套查询支持**
+   可以在内层查询和外层查询中使用。<!-- REPLACE_OPEN_TO_ENTERPRISE__IN_OPERATOR_AND_UNSIGNED_INTEGER -->
 <a class="anchor" id="join"></a>
 ### JOIN 子句
@@ -1230,10 +1267,12 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    ```
 - **APERCENTILE**
    ```mysql
-    SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
+    SELECT APERCENTILE(field_name, P[, algo_type]) 
+    FROM { tb_name | stb_name } [WHERE clause]
    ```
-    功能说明：统计表/超级表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
+    功能说明：统计表/超级表中指定列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
    返回结果数据类型： 双精度浮点数Double。
@@ -1241,47 +1280,62 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    适用于：**表、超级表**。
-    说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。推荐使用```APERCENTILE```函数，该函数性能远胜于```PERCENTILE```函数。
+    说明：*P*值有效取值范围0≤P≤100，为 0 的时候等同于 MIN，为 100 的时候等同于MAX；*algo_type*的有效输入：**default** 和 **t-digest**。 用于指定计算近似分位数的算法。可不提供第三个参数的输入，此时将使用 default 的算法进行计算，即 apercentile(column_name, 50, "default") 与 apercentile(column_name, 50) 等价。当使用“t-digest”参数的时候，将使用t-digest方式采样计算近似分位数。但该参数指定计算算法的功能从2.2.0.x版本开始支持，2.2.0.0之前的版本不支持指定使用算法的功能。
+    嵌套子查询支持：适用于内层查询和外层查询。
    ```mysql
    taos> SELECT APERCENTILE(current, 20) FROM d1001;
    apercentile(current, 20)  |
    ============================
                10.300000191 |
    Query OK, 1 row(s) in set (0.000645s)
+    taos> select apercentile (count, 80, 'default') from stb1;
+     apercentile (c0, 80, 'default') |
+    ==================================
+                 601920857.210056424 |
+    Query OK, 1 row(s) in set (0.012363s)
+    taos> select apercentile (count, 80, 't-digest') from stb1;
+     apercentile (c0, 80, 't-digest') |
+    ===================================
+                  605869120.966666579 |
+    Query OK, 1 row(s) in set (0.011639s)
    ```
 - **LAST_ROW**
    ```mysql
    SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
    ```
-    功能说明：返回表/超级表的最后一条记录。
+功能说明：返回表/超级表的最后一条记录。
-    返回结果数据类型：同应用的字段。
+返回结果数据类型：同应用的字段。
-    应用字段：所有字段。
+应用字段：所有字段。
-    适用于：**表、超级表**。
+适用于：**表、超级表**。
-    限制：LAST_ROW() 不能与 INTERVAL 一起使用。
+限制：LAST_ROW() 不能与 INTERVAL 一起使用。
-    说明：在用于超级表时，时间戳完全一样且同为最大的数据行可能有多个，那么会从中随机返回一条，而并不保证多次运行所挑选的数据行必然一致。
+说明：在用于超级表时，时间戳完全一样且同为最大的数据行可能有多个，那么会从中随机返回一条，而并不保证多次运行所挑选的数据行必然一致。
    示例：
    ```mysql
    taos> SELECT LAST_ROW(current) FROM meters;
    last_row(current)   |
    =======================
                12.30000 |
-    Query OK, 1 row(s) in set (0.001238s)
+Query OK, 1 row(s) in set (0.001238s)
    taos> SELECT LAST_ROW(current) FROM d1002;
    last_row(current)   |
    =======================
                10.30000 |
    Query OK, 1 row(s) in set (0.001042s)
-    ```
+```
 - **INTERP**
    ```mysql
    SELECT INTERP(field_name) FROM { tb_name | stb_name } WHERE ts='timestamp' [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})];
@@ -1418,6 +1472,39 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
    Query OK, 1 row(s) in set (0.000836s)
    ```
+- **CEIL**
+    ```mysql
+    SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
+    ```
+    功能说明：获得指定列的向上取整数的结果。
+    返回结果类型：与指定列的原始数据类型一致。例如，如果指定列的原始数据类型为 Float，那么返回的数据类型也为 Float；如果指定列的原始数据类型为 Double，那么返回的数据类型也为 Double。
+    适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列，无论 tag 列的类型是什么类型。
+    嵌套子查询支持：适用于内层查询和外层查询。
+    说明：
+      支持 +、-、*、/ 运算，如 ceil(col1) + ceil(col2)。
+      只能与普通列，选择（Selection）、投影（Projection）函数一起使用，不能与聚合（Aggregation）函数一起使用。
+      该函数可以应用在普通表和超级表上。
+    支持版本：指定计算算法的功能从 2.2.0.x 版本开始，2.2.0.0 之前的版本不支持指定使用算法的功能。
+- **FLOOR**
+    ```mysql
+    SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
+    ```
+    功能说明：获得指定列的向下取整数的结果。  
+    其他使用说明参见CEIL函数描述。
+- **ROUND**
+    ```mysql
+    SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
+    ```
+    功能说明：获得指定列的四舍五入的结果。  
+    其他使用说明参见CEIL函数描述。
 - **四则运算**
    ```mysql
@@ -1507,7 +1594,7 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P
 ## <a class="anchor" id="limitation"></a>TAOS SQL 边界限制
 - 数据库名最大长度为 32。
- 表名最大长度为 192，每行数据最大长度 16k 个字符（注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）。
+- 表名最大长度为 192，每行数据最大长度 16k 个字符, 从 2.1.7.0 版本开始，每行数据最大长度 48k 个字符（注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置）。
 - 列名最大长度为 64，最多允许 1024 列，最少需要 2 列，第一列必须是时间戳。（从 2.1.7.0 版本开始，改为最多允许 4096 列）
 - 标签名最大长度为 64，最多允许 128 个，可以 1 个，一个表中标签值的总长度不超过 16k 个字符。
 - SQL 语句最大长度 65480 个字符，但可通过系统配置参数 maxSQLLength 修改，最长可配置为 1M。

--- a/documentation20/cn/14.devops/01.telegraf/docs.md
+++ b/documentation20/cn/14.devops/01.telegraf/docs.md
+# 使用 TDengine + Telegraf + Grafana 快速搭建 IT 运维展示系统
+## 背景介绍
+TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。自从 2019年 7 月开源以来，凭借创新的数据建模设计、快捷的安装方式、易用的编程接口和强大的数据写入查询性能博得了大量时序数据开发者的青睐。
+IT 运维监测数据通常都是对时间特性比较敏感的数据，例如：
+- 系统资源指标：CPU、内存、IO、带宽等。
+- 软件系统指标：存活状态、连接数目、请求数目、超时数目、错误数目、响应时间、服务类型及其他与业务有关的指标。
+当前主流的 IT 运维系统通常包含一个数据采集模块，一个数据存储模块，和一个可视化显示模块。Telegraf 和 Grafana 分别是当前最流行的数据采集模块和可视化显示模块之一。而数据存储模块可供选择的软件比较多，其中 OpenTSDB 或 InfluxDB 比较流行。而 TDengine 作为新兴的时序大数据平台，具备极强的高性能、高可靠、易管理、易维护的优势。
+本文介绍不需要写一行代码，通过简单修改几行配置文件，就可以快速搭建一个基于 TDengine + Telegraf + Grafana 的 IT 运维系统。架构如下图：
+![IT-DevOps-Solutions-Telegraf.png](../../images/IT-DevOps-Solutions-Telegraf.png)
+## 安装步骤
+### 安装 Telegraf，Grafana 和 TDengine
+安装 Telegraf、Grafana 和 TDengine 请参考相关官方文档。
+### Telegraf
+请参考[官方文档](https://portal.influxdata.com/downloads/)。
+### Grafana
+请参考[官方文档](https://grafana.com/grafana/download)。
+### 安装 TDengine 
+从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/）页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
+## 数据链路设置
+### 复制 TDengine 插件到 grafana 插件目录
+```
+1. sudo cp -r /usr/local/taos/connector/grafanaplugin /var/lib/grafana/plugins/tdengine
+2. sudo chown grafana:grafana -R /var/lib/grafana/plugins/tdengine
+3. echo -e "[plugins]\nallow_loading_unsigned_plugins = taosdata-tdengine-datasource\n" | sudo tee -a /etc/grafana/grafana.ini
+4. sudo systemctl restart grafana-server.service
+```
+### 修改 /etc/telegraf/telegraf.conf 
+假设 TDengine 使用默认用户名 root 和密码 taosdata。增加如下文字：
+```
+[[outputs.http]]
+  url = "http://<TDengine server/cluster host>:6041/influxdb/v1/write?db=metrics"
+  method = "POST"
+  timeout = "5s"
+  username = "root"
+  password = "taosdata"
+  data_format = "influx"
+  influx_max_line_bytes = 250
+```
+然后重启 telegraf：
+```
+sudo systemctl start telegraf
+```
+### 导入 Dashboard
+使用 Web 浏览器访问 IP:3000 登录 Grafana 界面，系统初始用户名密码为 admin/admin。
+点击左侧齿轮图标并选择 Plugins，应该可以找到 TDengine data source 插件图标。
+点击左侧加号图标并选择 Import，按照界面提示选择 /usr/local/taos/connector/grafanaplugin/examples/telegraf/grafana/dashboards/telegraf-dashboard-v0.1.0.json 文件。如果按照 Grafana 的机器上没有安装 TDengine，可以从 https://github.com/taosdata/grafanaplugin/blob/master/examples/telegraf/grafana/dashboards/telegraf-dashboard-v0.1.0.json 下载 dashboard JSON 文件再导入。之后可以看到如下界面的仪表盘：
+![IT-DevOps-Solutions-telegraf-dashboard.png](../../images/IT-DevOps-Solutions-telegraf-dashboard.png)
+## 总结
+以上演示如何快速搭建一个完整的 IT 运维展示系统。得力于 TDengine 2.3.0.0 版本中新增的 schemaless 协议解析功能，以及强大的生态软件适配能力，用户可以短短数分钟就可以搭建一个高效易用的 IT 运维系统。TDengine 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品落地案例。
--- a/documentation20/cn/14.devops/02.collectd/docs.md
+++ b/documentation20/cn/14.devops/02.collectd/docs.md
+# 使用 TDengine + collectd/StatsD + Grafana 快速搭建 IT 运维监控系统
+## 背景介绍
+TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。自从 2019年 7 月开源以来，凭借创新的数据建模设计、快捷的安装方式、易用的编程接口和强大的数据写入查询性能博得了大量时序数据开发者的青睐。
+IT 运维监测数据通常都是对时间特性比较敏感的数据，例如：
+- 系统资源指标：CPU、内存、IO、带宽等。
+- 软件系统指标：存活状态、连接数目、请求数目、超时数目、错误数目、响应时间、服务类型及其他与业务有关的指标。
+当前主流的 IT 运维系统通常包含一个数据采集模块，一个数据存储模块，和一个可视化显示模块。collectd / statsD 作为老牌开源数据采集工具，具有广泛的用户群。但是 collectd / StatsD 自身功能有限，往往需要配合 Telegraf、Grafana 以及时序数据库组合搭建成为完整的监控系统。而 TDengine 新版本支持多种数据协议接入，可以直接接受 collectd 和 statsD 的数据写入，并提供 Grafana dashboard 进行图形化展示。
+本文介绍不需要写一行代码，通过简单修改几行配置文件，就可以快速搭建一个基于 TDengine + collectd / statsD + Grafana 的 IT 运维系统。架构如下图：
+![IT-DevOps-Solutions-Collectd-StatsD.png](../../images/IT-DevOps-Solutions-Collectd-StatsD.png)
+## 安装步骤
+安装 collectd， StatsD， Grafana 和 TDengine 请参考相关官方文档。
+### 安装 collectd
+请参考[官方文档](https://collectd.org/documentation.shtml)。
+### 安装 StatsD
+请参考[官方文档](https://github.com/statsd/statsd)。
+### 安装 Grafana
+请参考[官方文档](https://grafana.com/grafana/download)。
+### 安装 TDengine
+从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/）页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
+## 数据链路设置
+### 复制 TDengine 插件到 grafana 插件目录
+```
+1. sudo cp -r /usr/local/taos/connector/grafanaplugin /var/lib/grafana/plugins/tdengine
+2. sudo chown grafana:grafana -R /var/lib/grafana/plugins/tdengine
+3. echo -e "[plugins]\nallow_loading_unsigned_plugins = taosdata-tdengine-datasource\n" | sudo tee -a /etc/grafana/grafana.ini
+4. sudo systemctl restart grafana-server.service
+```
+### 配置 collectd
+在 /etc/collectd/collectd.conf 文件中增加如下内容后启动 collectd：
+```
+LoadPlugin network
+<Plugin network>
+  Server "<TDengine server/cluster host>" "25826"
+</Plugin>
+sudo systemctl start collectd
+```
+### 配置 StatsD
+在 config.js 文件中增加如下内容后启动 StatsD：
+```
+backends 部分添加 "./backends/repeater"
+repeater 部分添加 { host:'<TDengine server/cluster host>', port: 8126 }
+```
+### 导入 Dashboard
+使用 Web 浏览器访问 IP:3000 登录 Grafana 界面，系统初始用户名密码为 admin/admin。
+点击左侧齿轮图标并选择 Plugins，应该可以找到 TDengine data source 插件图标。
+#### 导入 collectd 仪表盘
+点击左侧加号图标并选择 Import，按照界面提示选择 /usr/local/taos/connector/grafanaplugin/examples/collectd/grafana/dashboards/collect-metrics-with-tdengine-v0.1.0.json 文件。如果按照 Grafana 的机器上没有安装 TDengine，可以从 https://github.com/taosdata/grafanaplugin/blob/master/examples/collectd/grafana/dashboards/collect-metrics-with-tdengine-v0.1.0.json 下载 dashboard json 文件再导入。之后可以看到如下界面的仪表盘：
+![IT-DevOps-Solutions-collectd-dashboard.png](../../images/IT-DevOps-Solutions-collectd-dashboard.png)
+#### 导入 StatsD 仪表盘
+点击左侧加号图标并选择 Import，按照界面提示选择 /usr/local/taos/connector/grafanaplugin/examples/statsd/dashboards/statsd-with-tdengine-v0.1.0.json 文件。如果安装 Grafana 的机器上没有安装 TDengine，可以从 https://github.com/taosdata/grafanaplugin/blob/master/examples/statsd/dashboards/statsd-with-tdengine-v0.1.0.json 下载 dashboard json 文件再导入。之后可以看到如下界面的仪表盘：
+![IT-DevOps-Solutions-statsd-dashboard.png](../../images/IT-DevOps-Solutions-statsd-dashboard.png)
+## 总结
+TDengine 作为新兴的时序大数据平台，具备极强的高性能、高可靠、易管理、易维护的优势。得力于 TDengine 2.3.0.0 版本中新增的 schemaless 协议解析功能，以及强大的生态软件适配能力，用户可以短短数分钟就可以搭建一个高效易用的 IT 运维系统或者适配一个已存在的系统。
+TDengine 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品成功落地案例。
--- a/documentation20/cn/images/IT-DevOps-Solutions-Collectd-StatsD.png
+++ b/documentation20/cn/images/IT-DevOps-Solutions-Collectd-StatsD.png
--- a/documentation20/cn/images/IT-DevOps-Solutions-Telegraf.png
+++ b/documentation20/cn/images/IT-DevOps-Solutions-Telegraf.png
--- a/documentation20/cn/images/IT-DevOps-Solutions-collectd-dashboard.png
+++ b/documentation20/cn/images/IT-DevOps-Solutions-collectd-dashboard.png
--- a/documentation20/cn/images/IT-DevOps-Solutions-statsd-dashboard.png
+++ b/documentation20/cn/images/IT-DevOps-Solutions-statsd-dashboard.png
--- a/documentation20/cn/images/IT-DevOps-Solutions-telegraf-dashboard.png
+++ b/documentation20/cn/images/IT-DevOps-Solutions-telegraf-dashboard.png
--- a/documentation20/en/02.getting-started/02.taosdemo/docs.md
+++ b/documentation20/en/02.getting-started/02.taosdemo/docs.md
--- a/documentation20/en/02.getting-started/docs.md
+++ b/documentation20/en/02.getting-started/docs.md
@@ -180,7 +180,10 @@ taos> select avg(f1), max(f2), min(f3) from test.meters where areaid=10;
 taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 ```
-**Note**: you can run command `taosdemo` with many options, like number of tables, rows of records and so on. To know more about these options, you can execute `taosdemo --help` and then take a try using different options.
+## <a class="anchor" id="taosdemo"></a> Using taosdemo in detail
+you can run command `taosdemo` with many options, like number of tables, rows of records and so on. To know more about these options, you can execute `taosdemo --help` and then take a try using different options.
+Please refer to [How to use taosdemo to test the performance of TDengine](https://www.taosdata.com/en/documentation/getting-started/taosdemo) for detail.
 ## Client and Alarm Module

--- a/documentation20/en/03.architecture/docs.md
+++ b/documentation20/en/03.architecture/docs.md
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -141,6 +141,12 @@ keepColumnName            1
 # > 0 (rpc message body which larger than this value will be compressed)
 # compressMsgSize       -1
+# query retrieved column data compression option:
+#  -1 (no compression)
+#   0 (all retrieved column data compressed),
+# > 0 (any retrieved column size greater than this value all data will be compressed.)
+# compressColData       -1
 # max length of an SQL
 # maxSQLLength          65480
@@ -289,3 +295,9 @@ keepColumnName            1
 # percent of redundant data in tsdb meta will compact meta data,0 means donot compact
 # tsdbMetaCompactRatio    0
+# default string type used for storing JSON String, options can be binary/nchar, default is binary
+# defaultJSONStrType      binary
+# force TCP transmission 
+# rpcForceTcp        0
--- a/packaging/check_package.sh
+++ b/packaging/check_package.sh
@@ -95,7 +95,7 @@ function check_file() {
        echo -e "$1/$2 \033[31mnot exists\033[0m!quit"
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
-        exit 8 
+        exit 8
    fi
 }
@@ -107,6 +107,7 @@ function get_package_name() {
 		echo ${var::-17}
 	fi
 }
 function check_link() {
    #check Link whether exists or broken
    if [ -L $1 ] ; then
@@ -114,13 +115,13 @@ function check_link() {
            echo -e "$1 \033[31Broken link\033[0m"
            fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
            echo -e $fin_result
-            exit 8 
+            exit 8
        fi
    else
        echo -e "$1 \033[31mnot exists\033[0m!quit"
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
-        exit 8 
+        exit 8
    fi
 }
@@ -141,11 +142,11 @@ function check_main_path() {
 function check_bin_path() {
    # check install bin dir and all sub dir
-    bin_dir=("taos" "taosd" "taosdemo" "taosdump" "remove.sh" "tarbitrator" "set_core.sh")
+    bin_dir=("taos" "taosd" "blm3" "taosdemo" "taosdump" "remove.sh" "tarbitrator" "set_core.sh")
    for i in ${bin_dir[@]};do
        check_file ${sbin_dir} $i
    done
-    lbin_dir=("taos" "taosd" "taosdemo" "taosdump" "rmtaos" "tarbitrator" "set_core")
+    lbin_dir=("taos" "taosd" "blm3" "taosdemo" "taosdump" "rmtaos" "tarbitrator" "set_core")
    for i in ${lbin_dir[@]};do
        check_link ${bin_link_dir}/$i
    done
@@ -155,7 +156,6 @@ function check_bin_path() {
    echo -e "Check bin  path:\033[32mOK\033[0m!"
 }
 function check_lib_path() {
    # check all links
    check_link ${lib_link_dir}/libtaos.so
@@ -168,9 +168,8 @@ function check_lib_path() {
    echo -e "Check lib  path:\033[32mOK\033[0m!"
 }
 function check_header_path() {
-	# check all header 
+	# check all header
 	header_dir=("taos.h" "taoserror.h")
    for i in ${header_dir[@]};do
        check_link ${inc_link_dir}/$i
@@ -178,6 +177,12 @@ function check_header_path() {
    echo -e "Check bin  path:\033[32mOK\033[0m!"
 }
+function check_blm3_config_dir() {
+	# check all config
+	check_file ${cfg_install_dir} blm3.toml
+	check_file ${install_main_dir}/cfg blm.toml.org
+	echo -e "Check conf path:\033[32mOK\033[0m!"
+}
 function check_config_dir() {
 	# check all config
@@ -194,7 +199,7 @@ function check_log_path() {
 function check_data_path() {
 	# check data path
-	check_file ${data_dir} 
+	check_file ${data_dir}
 	echo -e "Check data path:\033[32mOK\033[0m!"
 }
@@ -204,7 +209,7 @@ function install_TDengine() {
  temp_version=$(get_package_name $1)
 	cd $(get_package_name $1)
  echo -e "\033[32muninstall TDengine && install TDengine...\033[0m"
-	rmtaos >/dev/null 2>&1 || echo 'taosd not installed' && echo -e '\n\n' |./install.sh >/dev/null 2>&1 
+	rmtaos >/dev/null 2>&1 || echo 'taosd not installed' && echo -e '\n\n' |./install.sh >/dev/null 2>&1
  echo -e "\033[32mTDengine has been installed!\033[0m"
  echo -e "\033[32mTDengine is starting...\033[0m"
  kill_process taos && systemctl start taosd && sleep 10
@@ -216,18 +221,19 @@ function test_TDengine() {
    check_lib_path
    check_header_path
    check_config_dir
+    check_blm3_config_dir
    check_log_path
    check_data_path
    result=`taos -s 'create database test ;create table test.tt(ts timestamp ,i int);insert into test.tt values(now,11);select * from test.tt' 2>&1 ||:`
    if [[ $result =~ "Unable to establish" ]];then
-        echo -e "\033[31mTDengine connect failed\033[0m" 
+        echo -e "\033[31mTDengine connect failed\033[0m"
        fin_result=$fin_result"\033[31m$temp_version\033[0m test failed!\n"
        echo -e $fin_result
-        exit 8 
+        exit 8
-    fi  
+    fi
    echo -e "Check TDengine connect:\033[32mOK\033[0m!"
    fin_result=$fin_result"\033[32m$temp_version\033[0m test OK!\n"
-} 
+}
 # ## ==============================Main program starts from here============================
 TD_package_name=`ls ${script_dir}/*server*gz |awk -F '/' '{print $NF}' `
 temp=`pwd`
@@ -242,4 +248,4 @@ for i in $TD_package_name;do
 	test_TDengine
 done
 echo "============================================================"
 echo -e $fin_result
\ No newline at end of file
--- a/packaging/deb/DEBIAN/preinst
+++ b/packaging/deb/DEBIAN/preinst
@@ -24,9 +24,13 @@ fi
 # if taos.cfg already softlink, remove it
 cfg_install_dir="/etc/taos"
 install_main_dir="/usr/local/taos"
-if [ -f ${cfg_install_dir}/taos.cfg ]; then
+if [ -f "${install_main_dir}/taos.cfg" ]; then
    ${csudo} rm -f ${install_main_dir}/cfg/taos.cfg   || :
 fi
+if [ -f "${install_main_dir}/blm.toml" ]; then
+    ${csudo} rm -f ${install_main_dir}/cfg/blm.toml     || :
+fi
 # there can not libtaos.so*, otherwise ln -s  error
-${csudo} rm -f ${install_main_dir}/driver/libtaos*   || :    
+${csudo} rm -f ${install_main_dir}/driver/libtaos*   || :
--- a/packaging/deb/DEBIAN/prerm
+++ b/packaging/deb/DEBIAN/prerm
@@ -17,7 +17,7 @@ else
    bin_link_dir="/usr/bin"
    lib_link_dir="/usr/lib"
    inc_link_dir="/usr/include"
    data_link_dir="/usr/local/taos/data"
    log_link_dir="/usr/local/taos/log"
    cfg_link_dir="/usr/local/taos/cfg"
@@ -25,15 +25,16 @@ else
    # Remove all links
    ${csudo} rm -f ${bin_link_dir}/taos       || :
    ${csudo} rm -f ${bin_link_dir}/taosd      || :
+    ${csudo} rm -f ${bin_link_dir}/blm3       || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo   || :
    ${csudo} rm -f ${bin_link_dir}/taosdump   || :
    ${csudo} rm -f ${cfg_link_dir}/*          || :
    ${csudo} rm -f ${inc_link_dir}/taos.h     || :
    ${csudo} rm -f ${lib_link_dir}/libtaos.*  || :
    ${csudo} rm -f ${log_link_dir}            || :
    ${csudo} rm -f ${data_link_dir}           || :
    pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
    if [ -n "$pid" ]; then
        ${csudo} kill -9 $pid   || :

--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -44,15 +44,25 @@ mkdir -p ${pkg_dir}${install_home_path}/init.d
 mkdir -p ${pkg_dir}${install_home_path}/script
 cp ${compile_dir}/../packaging/cfg/taos.cfg         ${pkg_dir}${install_home_path}/cfg
+if [ -f "${compile_dir}/test/cfg/blm.toml" ]; then
+    cp ${compile_dir}/test/cfg/blm.toml                 ${pkg_dir}${install_home_path}/cfg
+fi
 cp ${compile_dir}/../packaging/deb/taosd            ${pkg_dir}${install_home_path}/init.d
 cp ${compile_dir}/../packaging/tools/post.sh        ${pkg_dir}${install_home_path}/script
 cp ${compile_dir}/../packaging/tools/preun.sh       ${pkg_dir}${install_home_path}/script
 cp ${compile_dir}/../packaging/tools/startPre.sh    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/../packaging/tools/set_core.sh    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/../packaging/tools/taosd-dump-cfg.gdb    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/bin/taosdemo                ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/bin/taosdump                ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/bin/taosd                   ${pkg_dir}${install_home_path}/bin
+if [ -f "${compile_dir}/build/bin/blm3" ]; then
+    cp ${compile_dir}/build/bin/blm3                    ${pkg_dir}${install_home_path}/bin ||:
+fi
 cp ${compile_dir}/build/bin/taos                    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_path}/driver
 cp ${compile_dir}/../src/inc/taos.h                 ${pkg_dir}${install_home_path}/include

--- a/packaging/deb/taosd
+++ b/packaging/deb/taosd
@@ -24,6 +24,11 @@ USER="root"
 GROUP="root"
 DAEMON="/usr/local/taos/bin/taosd"
 DAEMON_OPTS=""
+HTTPD_NAME="blm3"
+DAEMON_HTTPD_NAME=$HTTPD_NAME
+DAEMON_HTTPD="/usr/local/taos/bin/$HTTPD_NAME"
 PID_FILE="/var/run/$NAME.pid"
 APPARGS=""
@@ -36,6 +41,7 @@ case "$1" in
    start)
        log_action_begin_msg "Starting TDEngine..."
+        $DAEMON_HTTPD &
        if start-stop-daemon --test --start --chuid "$USER:$GROUP" --background --make-pidfile --pidfile "$PID_FILE" --exec "$DAEMON" -- $APPARGS &> /dev/null; then
            touch "$PID_FILE" && chown "$USER":"$GROUP" "$PID_FILE"
@@ -52,6 +58,7 @@ case "$1" in
    stop)
        log_action_begin_msg "Stopping TDEngine..."
+        pkill -9 $DAEMON_HTTPD_NAME
        set +e
        if [ -f "$PID_FILE" ]; then
            start-stop-daemon --stop --pidfile "$PID_FILE" --user "$USER" --retry=TERM/120/KILL/5 > /dev/null

--- a/packaging/release.sh
+++ b/packaging/release.sh
@@ -192,12 +192,21 @@ else
    allocator_macro=""
 fi
+if [[ "$dbName" == "pro" ]]; then
+    sed -i "s/taos config/prodb config/g"   ${top_dir}/src/util/src/tconfig.c
+fi
+echo "build ${pagMode} package ..."
+if [[ "$pagMode" == "lite" ]]; then
+    BUILD_HTTP=true
+fi
 # check support cpu type
 if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "mips64" ]] ; then
  if [ "$verMode" != "cluster" ]; then
-    cmake ../    -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode} ${allocator_macro}
+    cmake ../    -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode} -DBUILD_HTTP=${BUILD_HTTP} ${allocator_macro}
  else
-    cmake ../../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} ${allocator_macro}
+    cmake ../../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DBUILD_HTTP=${BUILD_HTTP} ${allocator_macro}
  fi
 else
  echo "input cpuType=${cpuType} error!!!"

--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@@ -54,6 +54,9 @@ mkdir -p %{buildroot}%{homepath}/init.d
 mkdir -p %{buildroot}%{homepath}/script
 cp %{_compiledir}/../packaging/cfg/taos.cfg         %{buildroot}%{homepath}/cfg
+if [ -f %{_compiledir}/test/cfg/blm.toml ]; then
+    cp %{_compiledir}/test/cfg/blm.toml         %{buildroot}%{homepath}/cfg
+fi
 cp %{_compiledir}/../packaging/rpm/taosd            %{buildroot}%{homepath}/init.d
 cp %{_compiledir}/../packaging/tools/post.sh        %{buildroot}%{homepath}/script
 cp %{_compiledir}/../packaging/tools/preun.sh       %{buildroot}%{homepath}/script
@@ -62,6 +65,9 @@ cp %{_compiledir}/../packaging/tools/set_core.sh    %{buildroot}%{homepath}/bin
 cp %{_compiledir}/../packaging/tools/taosd-dump-cfg.gdb    %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taos                    %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taosd                   %{buildroot}%{homepath}/bin
+if [ -f %{_compiledir}/build/bin/blm3 ]; then
+    cp %{_compiledir}/build/bin/blm3                    %{buildroot}%{homepath}/bin ||:
+fi
 cp %{_compiledir}/build/bin/taosdemo                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taosdump                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
@@ -150,6 +156,11 @@ if [ -f %{cfg_install_dir}/taos.cfg ]; then
    ${csudo} rm -f %{homepath}/cfg/taos.cfg   || :
 fi
+# if blm.toml already softlink, remove it
+if [ -f %{cfg_install_dir}/blm.toml ]; then
+    ${csudo} rm -f %{homepath}/cfg/blm.toml || :
+fi
 # there can not libtaos.so*, otherwise ln -s  error
 ${csudo} rm -f %{homepath}/driver/libtaos*   || :
@@ -188,6 +199,7 @@ if [ $1 -eq 0 ];then
    # Remove all links
    ${csudo} rm -f ${bin_link_dir}/taos       || :
    ${csudo} rm -f ${bin_link_dir}/taosd      || :
+    ${csudo} rm -f ${bin_link_dir}/blm3       || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo   || :
    ${csudo} rm -f ${bin_link_dir}/taosdump   || :
    ${csudo} rm -f ${cfg_link_dir}/*          || :

--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -185,6 +185,7 @@ function install_bin() {
    # Remove links
    ${csudo} rm -f ${bin_link_dir}/taos     || :
    ${csudo} rm -f ${bin_link_dir}/taosd    || :
+    ${csudo} rm -f ${bin_link_dir}/blm3     || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo || :
    ${csudo} rm -f ${bin_link_dir}/taosdump || :
    ${csudo} rm -f ${bin_link_dir}/rmtaos   || :
@@ -196,6 +197,7 @@ function install_bin() {
    #Make link
    [ -x ${install_main_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos                      || :
    [ -x ${install_main_dir}/bin/taosd ] && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd                   || :
+    [ -x ${install_main_dir}/bin/blm3 ] && ${csudo} ln -s ${install_main_dir}/bin/blm3 ${bin_link_dir}/blm3                      || :
    [ -x ${install_main_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo          || :
    [ -x ${install_main_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump          || :
    [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos          || :
@@ -445,10 +447,27 @@ function local_fqdn_check() {
  fi
 }
+function install_blm3_config() {
+    if [ ! -f "${cfg_install_dir}/blm.toml" ]; then
+        ${csudo} mkdir -p ${cfg_install_dir}
+        [ -f ${script_dir}/cfg/blm.toml ] && ${csudo} cp ${script_dir}/cfg/blm.toml ${cfg_install_dir}
+        [ -f ${cfg_install_dir}/blm.toml ] && ${csudo} chmod 644 ${cfg_install_dir}/blm.toml
+    fi
+    [ -f ${script_dir}/cfg/blm.toml ] &&
+        ${csudo} cp -f ${script_dir}/cfg/blm.toml ${install_main_dir}/cfg/blm.toml.org
+    [ -f ${cfg_install_dir}/blm.toml ] &&
+        ${csudo} ln -s ${cfg_install_dir}/blm.toml ${install_main_dir}/cfg/blm.toml
+    [ ! -z $1 ] && return 0 || : # only install client
+}
 function install_config() {
    #${csudo} rm -f ${install_main_dir}/cfg/taos.cfg     || :
-    if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
+    if [ ! -f "${cfg_install_dir}/taos.cfg" ]; then
        ${csudo} mkdir -p ${cfg_install_dir}
        [ -f ${script_dir}/cfg/taos.cfg ] && ${csudo} cp ${script_dir}/cfg/taos.cfg ${cfg_install_dir}
        ${csudo} chmod 644 ${cfg_install_dir}/*
@@ -860,6 +879,7 @@ function update_TDengine() {
        install_bin
        install_service
        install_config
+        install_blm3_config
        openresty_work=false
        if [ "$verMode" == "cluster" ]; then
@@ -1002,6 +1022,7 @@ function install_TDengine() {
        echo
        echo -e "\033[44;32;1mTDengine client is installed successfully!${NC}"
    fi
    touch ~/.taos_history
    rm -rf $(tar -tf taos.tar.gz)
 }

--- a/packaging/tools/install_pro.sh
+++ b/packaging/tools/install_pro.sh
@@ -154,9 +154,9 @@ function install_main_path() {
    ${csudo} mkdir -p ${install_main_dir}
    ${csudo} mkdir -p ${install_main_dir}/cfg
    ${csudo} mkdir -p ${install_main_dir}/bin
-    ${csudo} mkdir -p ${install_main_dir}/connector
+#    ${csudo} mkdir -p ${install_main_dir}/connector
    ${csudo} mkdir -p ${install_main_dir}/driver
-    ${csudo} mkdir -p ${install_main_dir}/examples
+#    ${csudo} mkdir -p ${install_main_dir}/examples
    ${csudo} mkdir -p ${install_main_dir}/include
    ${csudo} mkdir -p ${install_main_dir}/init.d
    if [ "$verMode" == "cluster" ]; then
@@ -779,10 +779,10 @@ function update_prodb() {
    install_log
    install_header
    install_lib
-    if [ "$pagMode" != "lite" ]; then
+#    if [ "$pagMode" != "lite" ]; then
-      install_connector
+#      install_connector
-    fi
+#    fi
-    install_examples
+#    install_examples
    if [ -z $1 ]; then
        install_bin
        install_service
@@ -853,10 +853,10 @@ function install_prodb() {
    install_header
    install_lib
    install_jemalloc
-    if [ "$pagMode" != "lite" ]; then
+#    if [ "$pagMode" != "lite" ]; then
-      install_connector
+#      install_connector
-    fi
+#    fi
-    install_examples
+#    install_examples
    if [ -z $1 ]; then # install service and client
        # For installing new

--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -46,7 +46,7 @@ else
    install_main_dir="/usr/local/Cellar/tdengine/${verNumber}"
    install_main_2_dir="/usr/local/Cellar/tdengine@${verNumber}/${verNumber}"
    bin_dir="/usr/local/Cellar/tdengine/${verNumber}/bin"
    bin_2_dir="/usr/local/Cellar/tdengine@${verNumber}/${verNumber}/bin"
 fi
@@ -114,6 +114,13 @@ if [ "$osType" != "Darwin" ]; then
    fi
 fi
+function kill_blm3() {
+    pid=$(ps -ef | grep "blm3" | grep -v "grep" | awk '{print $2}')
+    if [ -n "$pid" ]; then
+        ${csudo} kill -9 $pid   || :
+    fi
+}
 function kill_taosd() {
    pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
    if [ -n "$pid" ]; then
@@ -149,6 +156,7 @@ function install_bin() {
    # Remove links
    ${csudo} rm -f ${bin_link_dir}/taos     || :
    ${csudo} rm -f ${bin_link_dir}/taosd    || :
+    ${csudo} rm -f ${bin_link_dir}/blm3 || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo || :
    ${csudo} rm -f ${bin_link_dir}/taosdump || :
@@ -156,25 +164,26 @@ function install_bin() {
        ${csudo} rm -f ${bin_link_dir}/perfMonitor || :
        ${csudo} rm -f ${bin_link_dir}/set_core || :
        ${csudo} rm -f ${bin_link_dir}/rmtaos   || :
        ${csudo} cp -r ${binary_dir}/build/bin/* ${install_main_dir}/bin
        ${csudo} cp -r ${script_dir}/taosd-dump-cfg.gdb   ${install_main_dir}/bin
        ${csudo} cp -r ${script_dir}/remove.sh     ${install_main_dir}/bin
        ${csudo} cp -r ${script_dir}/set_core.sh   ${install_main_dir}/bin
        ${csudo} cp -r ${script_dir}/startPre.sh   ${install_main_dir}/bin
        ${csudo} chmod 0555 ${install_main_dir}/bin/*
        #Make link
        [ -x ${install_main_dir}/bin/taos ]      && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos    || :
        [ -x ${install_main_dir}/bin/taosd ]     && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd   || :
+        [ -x ${install_main_dir}/bin/blm3 ]  && ${csudo} ln -s ${install_main_dir}/bin/blm3 ${bin_link_dir}/blm3 || :
        [ -x ${install_main_dir}/bin/taosdump ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
        [ -x ${install_main_dir}/bin/taosdemo ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
        [ -x ${install_main_dir}/bin/perfMonitor ]  && ${csudo} ln -s ${install_main_dir}/bin/perfMonitor ${bin_link_dir}/perfMonitor || :
        [ -x ${install_main_dir}/set_core.sh ]  && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
        [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos  || :
   else
        ${csudo} cp -r ${binary_dir}/build/bin/*   ${install_main_dir}/bin || ${csudo} cp -r ${binary_dir}/build/bin/*   ${install_main_2_dir}/bin  || :
        ${csudo} cp -r ${script_dir}/taosd-dump-cfg.gdb   ${install_main_dir}/bin || ${csudo}cp -r ${script_dir}/taosd-dump-cfg.gdb   ${install_main_2_dir}  || :
        ${csudo} cp -r ${script_dir}/remove_client.sh   ${install_main_dir}/bin || ${csudo} cp -r ${script_dir}/remove_client.sh   ${install_main_2_dir}/bin
@@ -182,6 +191,7 @@ function install_bin() {
        #Make link
        [ -x ${install_main_dir}/bin/taos ] || [ -x ${install_main_2_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos || ${csudo} ln -s ${install_main_2_dir}/bin/taos  || :
        [ -x ${install_main_dir}/bin/taosd ] || [ -x ${install_main_2_dir}/bin/taosd ] &&  ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd || ${csudo} ln -s ${install_main_2_dir}/bin/taosd || :
+        [ -x ${install_main_dir}/bin/blm3 ] || [ -x ${install_main_2_dir}/bin/blm3 ] &&  ${csudo} ln -s ${install_main_dir}/bin/blm3 ${bin_link_dir}/blm3 || ${csudo} ln -s ${install_main_2_dir}/bin/blm3 || :
        [ -x ${install_main_dir}/bin/taosdump ] || [ -x ${install_main_2_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || ln -s ${install_main_2_dir}/bin/taosdump ${bin_link_dir}/taosdump   || :
        [ -x ${install_main_dir}/bin/taosdemo ] || [ -x ${install_main_2_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || ln -s ${install_main_2_dir}/bin/taosdemo ${bin_link_dir}/taosdemo   || :
    fi
@@ -191,40 +201,38 @@ function install_jemalloc() {
    if [ "$osType" != "Darwin" ]; then
        /usr/bin/install -c -d /usr/local/bin
-        if [ -f ${binary_dir}/build/bin/jemalloc-config ]; then
+        if [ -f "${binary_dir}/build/bin/jemalloc-config" ]; then
            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jemalloc-config /usr/local/bin
        fi
-        if [ -f ${binary_dir}/build/bin/jemalloc.sh ]; then
+        if [ -f "${binary_dir}/build/bin/jemalloc.sh" ]; then
            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jemalloc.sh /usr/local/bin
        fi
-        if [ -f ${binary_dir}/build/bin/jeprof ]; then
+        if [ -f "${binary_dir}/build/bin/jeprof" ]; then
            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jeprof /usr/local/bin
        fi
-        if [ -f ${binary_dir}/build/include/jemalloc/jemalloc.h ]; then
+        if [ -f "${binary_dir}/build/include/jemalloc/jemalloc.h" ]; then
            /usr/bin/install -c -d /usr/local/include/jemalloc
            /usr/bin/install -c -m 644 ${binary_dir}/build/include/jemalloc/jemalloc.h /usr/local/include/jemalloc
        fi
-        if [ -f ${binary_dir}/build/lib/libjemalloc.so.2 ]; then
+        if [ -f "${binary_dir}/build/lib/libjemalloc.so.2" ]; then
            /usr/bin/install -c -d /usr/local/lib
            /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.so.2 /usr/local/lib
            ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
            /usr/bin/install -c -d /usr/local/lib
-            if [ -f ${binary_dir}/build/lib/libjemalloc.a ]; then
+            [ -f ${binary_dir}/build/lib/libjemalloc.a ] &&
                /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.a /usr/local/lib
-            fi
+            [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ] &&
-            if [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ]; then
                /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc_pic.a /usr/local/lib
-            fi
+            if [ -f "${binary_dir}/build/lib/pkgconfig/jemalloc.pc" ]; then
-            if [ -f ${binary_dir}/build/lib/pkgconfig/jemalloc.pc ]; then
                /usr/bin/install -c -d /usr/local/lib/pkgconfig
                /usr/bin/install -c -m 644 ${binary_dir}/build/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
            fi
        fi
-        if [ -f ${binary_dir}/build/share/doc/jemalloc/jemalloc.html ]; then
+        if [ -f "${binary_dir}/build/share/doc/jemalloc/jemalloc.html" ]; then
            /usr/bin/install -c -d /usr/local/share/doc/jemalloc
            /usr/bin/install -c -m 644 ${binary_dir}/build/share/doc/jemalloc/jemalloc.html /usr/local/share/doc/jemalloc
        fi
-        if [ -f ${binary_dir}/build/share/man/man3/jemalloc.3 ]; then
+        if [ -f "${binary_dir}/build/share/man/man3/jemalloc.3" ]; then
            /usr/bin/install -c -d /usr/local/share/man/man3
            /usr/bin/install -c -m 644 ${binary_dir}/build/share/man/man3/jemalloc.3 /usr/local/share/man/man3
        fi
@@ -256,13 +264,13 @@ function install_lib() {
        fi
    else
        ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib ${install_main_dir}/driver || ${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib ${install_main_2_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/* || ${csudo} chmod 777 ${install_main_2_dir}/driver/*
        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.* ${install_main_dir}/driver/libtaos.1.dylib || ${csudo} ln -sf ${install_main_2_dir}/driver/libtaos.* ${install_main_2_dir}/driver/libtaos.1.dylib   || :
        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.1.dylib ${install_main_dir}/driver/libtaos.dylib || ${csudo} ln -sf ${install_main_2_dir}/driver/libtaos.1.dylib ${install_main_2_dir}/driver/libtaos.dylib   || :
        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.${verNumber}.dylib ${lib_link_dir}/libtaos.1.dylib || ${csudo} ln -sf ${install_main_2_dir}/driver/libtaos.${verNumber}.dylib ${lib_link_dir}/libtaos.1.dylib   || :
        ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib   || :
    fi
    install_jemalloc
    if [ "$osType" != "Darwin" ]; then
@@ -285,18 +293,36 @@ function install_header() {
 function install_config() {
    #${csudo} rm -f ${install_main_dir}/cfg/taos.cfg     || :
-    if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
+    if [ ! -f "${cfg_install_dir}/taos.cfg" ]; then
        ${csudo} mkdir -p ${cfg_install_dir}
        [ -f ${script_dir}/../cfg/taos.cfg ] &&
        ${csudo} cp ${script_dir}/../cfg/taos.cfg ${cfg_install_dir}
-        ${csudo} chmod 644 ${cfg_install_dir}/*
+        ${csudo} chmod 644 ${cfg_install_dir}/taos.cfg
        ${csudo} cp -f ${script_dir}/../cfg/taos.cfg ${install_main_dir}/cfg/taos.cfg.org
-        ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+        ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg/taos.cfg
    else
        ${csudo} cp -f ${script_dir}/../cfg/taos.cfg ${install_main_dir}/cfg/taos.cfg.org || ${csudo} cp -f ${script_dir}/../cfg/taos.cfg ${install_main_2_dir}/cfg/taos.cfg.org
    fi
 }
+function install_blm3_config() {
+    if [ ! -f "${cfg_install_dir}/blm.toml" ]; then
+        ${csudo} mkdir -p ${cfg_install_dir}
+        [ -f ${binary_dir}/test/cfg/blm.toml ] &&
+            ${csudo} cp ${binary_dir}/test/cfg/blm.toml ${cfg_install_dir}
+        [ -f ${cfg_install_dir}/blm.toml ] &&
+            ${csudo} chmod 644 ${cfg_install_dir}/blm.toml
+        [ -f ${binary_dir}/test/cfg//blm.toml ] &&
+            ${csudo} cp -f ${binary_dir}/test/cfg/blm.toml ${install_main_dir}/cfg/blm.toml.org
+        [ -f ${cfg_install_dir}/blm.toml ] &&
+            ${csudo} ln -s ${cfg_install_dir}/blm.toml ${install_main_dir}/cfg/blm.toml
+    else
+        [ -f ${binary_dir}/test/cfg//blm.toml ] &&
+            ${csudo} cp -f ${binary_dir}/test/cfg/blm.toml ${install_main_dir}/cfg/blm.toml.org \
+                || ${csudo} cp -f ${binary_dir}/test/cfg/blm.toml ${install_main_2_dir}/cfg/blm.toml.org
+    fi
+}
 function install_log() {
    ${csudo} rm -rf ${log_dir}  || :
    ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
@@ -445,6 +471,7 @@ function install_service() {
        install_service_on_sysvinit
    else
        # must manual stop taosd
+        kill_blm3
        kill_taosd
    fi
 }
@@ -460,6 +487,7 @@ function update_TDengine() {
        elif ((${service_mod}==1)); then
            ${csudo} service taosd stop || :
        else
+            kill_blm3
            kill_taosd
        fi
        sleep 1
@@ -480,6 +508,7 @@ function update_TDengine() {
    fi
    install_config
+    install_blm3_config
    if [ "$osType" != "Darwin" ]; then
        echo
@@ -487,6 +516,7 @@ function update_TDengine() {
        echo
        echo -e "${GREEN_DARK}To configure TDengine ${NC}: edit /etc/taos/taos.cfg"
+        echo -e "${GREEN_DARK}To configure blm3 (if has) ${NC}: edit /etc/taos/blm.toml"
        if ((${service_mod}==0)); then
            echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} systemctl start taosd${NC}"
        elif ((${service_mod}==1)); then
@@ -516,7 +546,7 @@ function install_TDengine() {
    else
        echo -e "${GREEN}Start to install TDEngine Client ...${NC}"
    fi
    install_main_path
    install_data
@@ -526,12 +556,13 @@ function install_TDengine() {
    install_connector
    install_examples
    install_bin
    if [ "$osType" != "Darwin" ]; then
        install_service
    fi
    install_config
+    install_blm3_config
    if [ "$osType" != "Darwin" ]; then
        # Ask if to start the service
@@ -539,6 +570,7 @@ function install_TDengine() {
        echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
        echo
        echo -e "${GREEN_DARK}To configure TDengine ${NC}: edit /etc/taos/taos.cfg"
+        echo -e "${GREEN_DARK}To configure blm (if has) ${NC}: edit /etc/taos/blm.toml"
        if ((${service_mod}==0)); then
            echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} systemctl start taosd${NC}"
        elif ((${service_mod}==1)); then

--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@@ -183,7 +183,7 @@ pkg_name=${install_dir}-${osType}-${cpuType}
 # fi
 if [[ "$verType" == "beta" ]] || [[ "$verType" == "preRelease" ]]; then
-  pkg_name=${install_dir}-${verType}-${osType}-${cpuType} 
+  pkg_name=${install_dir}-${verType}-${osType}-${cpuType}
 elif [ "$verType" == "stable" ]; then
  pkg_name=${pkg_name}
 else

--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -35,10 +35,19 @@ fi
 if [ "$pagMode" == "lite" ]; then
  strip ${build_dir}/bin/taosd
  strip ${build_dir}/bin/taos
+  # lite version doesn't include blm3,  which will lead to no restful interface
  bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${script_dir}/remove.sh ${script_dir}/startPre.sh"
 else
-  bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo ${build_dir}/bin/tarbitrator\
+  bin_files="${build_dir}/bin/taosd \
-             ${script_dir}/remove.sh ${script_dir}/set_core.sh ${script_dir}/startPre.sh  ${script_dir}/taosd-dump-cfg.gdb"
+      ${build_dir}/bin/taos \
+      ${build_dir}/bin/blm3 \
+      ${build_dir}/bin/taosdump \
+      ${build_dir}/bin/taosdemo \
+      ${build_dir}/bin/tarbitrator\
+      ${script_dir}/remove.sh \
+      ${script_dir}/set_core.sh \
+      ${script_dir}/startPre.sh \
+      ${script_dir}/taosd-dump-cfg.gdb"
 fi
 lib_files="${build_dir}/lib/libtaos.so.${version}"
@@ -68,6 +77,9 @@ init_file_tarbitrator_rpm=${script_dir}/../rpm/tarbitratord
 mkdir -p ${install_dir}
 mkdir -p ${install_dir}/inc && cp ${header_files} ${install_dir}/inc
 mkdir -p ${install_dir}/cfg && cp ${cfg_dir}/taos.cfg ${install_dir}/cfg/taos.cfg
+[ -f ${cfg_dir}/blm.toml ] && cp ${cfg_dir}/blm.toml ${install_dir}/cfg/blm.toml
 mkdir -p ${install_dir}/bin && cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || :
 mkdir -p ${install_dir}/init.d && cp ${init_file_deb} ${install_dir}/init.d/taosd.deb
 mkdir -p ${install_dir}/init.d && cp ${init_file_rpm} ${install_dir}/init.d/taosd.rpm
@@ -216,7 +228,7 @@ pkg_name=${install_dir}-${osType}-${cpuType}
 # fi
 if [[ "$verType" == "beta" ]] || [[ "$verType" == "preRelease" ]]; then
-  pkg_name=${install_dir}-${verType}-${osType}-${cpuType} 
+  pkg_name=${install_dir}-${verType}-${osType}-${cpuType}
 elif [ "$verType" == "stable" ]; then
  pkg_name=${pkg_name}
 else

--- a/packaging/tools/makepkg_power.sh
+++ b/packaging/tools/makepkg_power.sh
@@ -81,6 +81,7 @@ else
 #  bin_files="${build_dir}/bin/powerd ${build_dir}/bin/power ${build_dir}/bin/powerdemo ${build_dir}/bin/tarbitrator ${script_dir}/remove_power.sh ${script_dir}/set_core.sh"
  cp ${build_dir}/bin/taos          ${install_dir}/bin/power
  cp ${build_dir}/bin/taosd         ${install_dir}/bin/powerd
+  cp ${build_dir}/bin/blm3          ${install_dir}/bin/blm3 ||:
  cp ${script_dir}/remove_power.sh  ${install_dir}/bin
  cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/powerdemo
  cp ${build_dir}/bin/taosdump      ${install_dir}/bin/powerdump

--- a/packaging/tools/makepkg_pro.sh
+++ b/packaging/tools/makepkg_pro.sh
@@ -24,7 +24,7 @@ build_dir="${compile_dir}/build"
 code_dir="${top_dir}/src"
 release_dir="${top_dir}/release"
-#package_name='linux'
+# package_name='linux'
 if [ "$verMode" == "cluster" ]; then
    install_dir="${release_dir}/ProDB-enterprise-server-${version}"
 else
@@ -45,19 +45,13 @@ nginx_dir="${code_dir}/../../enterprise/src/plugins/web"
 mkdir -p ${install_dir}
 mkdir -p ${install_dir}/inc && cp ${header_files} ${install_dir}/inc
 mkdir -p ${install_dir}/cfg && cp ${cfg_dir}/taos.cfg ${install_dir}/cfg/taos.cfg
-#mkdir -p ${install_dir}/bin && cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || :
 mkdir -p ${install_dir}/bin
+# bin
 if [ "$pagMode" == "lite" ]; then
  strip ${build_dir}/bin/taosd
  strip ${build_dir}/bin/taos
-  cp ${build_dir}/bin/taos          ${install_dir}/bin/prodbc
-  cp ${build_dir}/bin/taosd         ${install_dir}/bin/prodbs
-  cp ${script_dir}/remove_pro.sh  ${install_dir}/bin
 else
-  cp ${build_dir}/bin/taos          ${install_dir}/bin/prodbc
-  cp ${build_dir}/bin/taosd         ${install_dir}/bin/prodbs
-  cp ${script_dir}/remove_pro.sh  ${install_dir}/bin
  cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/prodemo
  cp ${build_dir}/bin/taosdump      ${install_dir}/bin/prodump
  cp ${build_dir}/bin/tarbitrator   ${install_dir}/bin
@@ -66,17 +60,21 @@ else
  cp ${script_dir}/startPre.sh      ${install_dir}/bin
  cp ${script_dir}/taosd-dump-cfg.gdb  ${install_dir}/bin
 fi
+cp ${build_dir}/bin/taos          ${install_dir}/bin/prodbc
+cp ${build_dir}/bin/taosd         ${install_dir}/bin/prodbs
+cp ${build_dir}/bin/blm3          ${install_dir}/bin/blm3 ||:
+cp ${script_dir}/remove_pro.sh  ${install_dir}/bin
 chmod a+x ${install_dir}/bin/* || :
+# cluster
 if [ "$verMode" == "cluster" ]; then
    sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/bin/remove_pro.sh >> remove_prodb_temp.sh
    mv remove_prodb_temp.sh ${install_dir}/bin/remove_pro.sh
    mkdir -p ${install_dir}/nginxd && cp -r ${nginx_dir}/* ${install_dir}/nginxd
    cp ${nginx_dir}/png/taos.png ${install_dir}/nginxd/admin/images/taos.png
    rm -rf ${install_dir}/nginxd/png
    # replace the OEM name, add by yangzy@2021-09-22
    sed -i -e 's/www.taosdata.com/www.hanatech.com.cn/g' $(grep -r 'www.taosdata.com' ${install_dir}/nginxd | sed -r "s/(.*\.html):\s*(.*)/\1/g")
    sed -i -e 's/TAOS Data/Hanatech/g' $(grep -r 'TAOS Data' ${install_dir}/nginxd | sed -r "s/(.*\.html):\s*(.*)/\1/g")
@@ -85,14 +83,9 @@ if [ "$verMode" == "cluster" ]; then
    sed -i -e 's/<th style="font-weight: normal">taosd<\/th>/<th style="font-weight: normal">prodbs<\/th>/g' ${install_dir}/nginxd/admin/monitor.html
    sed -i -e "s/data:\['taosd', 'system'\],/data:\['prodbs', 'system'\],/g" ${install_dir}/nginxd/admin/monitor.html
    sed -i -e "s/name: 'taosd',/name: 'prodbs',/g" ${install_dir}/nginxd/admin/monitor.html
    sed -i "s/TDengine/ProDB/g"   ${install_dir}/nginxd/admin/*.html
    sed -i "s/TDengine/ProDB/g"   ${install_dir}/nginxd/admin/js/*.js
-    sed -i '/dataDir/ {s/taos/ProDB/g}'  ${install_dir}/cfg/taos.cfg
-    sed -i '/logDir/  {s/taos/ProDB/g}'  ${install_dir}/cfg/taos.cfg
-    sed -i "s/TDengine/ProDB/g"        ${install_dir}/cfg/taos.cfg
    if [ "$cpuType" == "aarch64" ]; then
        cp -f ${install_dir}/nginxd/sbin/arm/64bit/nginx ${install_dir}/nginxd/sbin/
    elif [ "$cpuType" == "aarch32" ]; then
@@ -101,6 +94,13 @@ if [ "$verMode" == "cluster" ]; then
    rm -rf ${install_dir}/nginxd/sbin/arm
 fi
+sed -i '/dataDir/ {s/taos/ProDB/g}'  ${install_dir}/cfg/taos.cfg
+sed -i '/logDir/  {s/taos/ProDB/g}'  ${install_dir}/cfg/taos.cfg
+sed -i "s/TDengine/ProDB/g"     ${install_dir}/cfg/taos.cfg
+sed -i "s/support@taosdata.com/support@hanatech.com.cn/g"      ${install_dir}/cfg/taos.cfg
+sed -i "s/taos client/prodbc/g"      ${install_dir}/cfg/taos.cfg
+sed -i "s/taosd/prodbs/g"      ${install_dir}/cfg/taos.cfg
 cd ${install_dir}
 tar -zcv -f prodb.tar.gz * --remove-files  || :
 exitcode=$?
@@ -116,58 +116,62 @@ if [ "$verMode" == "cluster" ]; then
    mv install_prodb_temp.sh ${install_dir}/install_pro.sh
 fi
 if [ "$pagMode" == "lite" ]; then
-    sed 's/pagMode=full/pagMode=lite/g' ${install_dir}/install.sh >> install_prodb_temp.sh
+    sed -e "s/pagMode=full/pagMode=lite/g" -e "s/taos_history/prodb_history/g" ${install_dir}/install.sh >> install_prodb_temp.sh
    mv install_prodb_temp.sh ${install_dir}/install_pro.sh
 fi
+sed -i "/install_connector$/d" ${install_dir}/install_pro.sh
+sed -i "/install_examples$/d" ${install_dir}/install_pro.sh
 chmod a+x ${install_dir}/install_pro.sh
 # Copy example code
-mkdir -p ${install_dir}/examples
+#mkdir -p ${install_dir}/examples
-examples_dir="${top_dir}/tests/examples"
+#examples_dir="${top_dir}/tests/examples"
-cp -r ${examples_dir}/c      ${install_dir}/examples
+#cp -r ${examples_dir}/c      ${install_dir}/examples
-sed -i '/passwd/ {s/taosdata/prodb/g}'  ${install_dir}/examples/c/*.c
+#sed -i '/passwd/ {s/taosdata/prodb/g}'  ${install_dir}/examples/c/*.c
-sed -i '/root/   {s/taosdata/prodb/g}'  ${install_dir}/examples/c/*.c
+#sed -i '/root/   {s/taosdata/prodb/g}'  ${install_dir}/examples/c/*.c
+#
-if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
+#if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp -r ${examples_dir}/JDBC   ${install_dir}/examples
+#  cp -r ${examples_dir}/JDBC   ${install_dir}/examples
-  cp -r ${examples_dir}/matlab ${install_dir}/examples
+#  cp -r ${examples_dir}/matlab ${install_dir}/examples
-  mv ${install_dir}/examples/matlab/TDengineDemo.m ${install_dir}/examples/matlab/ProDBDemo.m
+#  mv ${install_dir}/examples/matlab/TDengineDemo.m ${install_dir}/examples/matlab/ProDBDemo.m
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/matlab/ProDBDemo.m
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/matlab/ProDBDemo.m
-  cp -r ${examples_dir}/python ${install_dir}/examples
+#  cp -r ${examples_dir}/python ${install_dir}/examples
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/python/read_example.py
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/python/read_example.py
-  cp -r ${examples_dir}/R      ${install_dir}/examples
+#  cp -r ${examples_dir}/R      ${install_dir}/examples
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/R/command.txt
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/R/command.txt
-  cp -r ${examples_dir}/go     ${install_dir}/examples
+#  cp -r ${examples_dir}/go     ${install_dir}/examples
-  mv ${install_dir}/examples/go/taosdemo.go ${install_dir}/examples/go/prodemo.go
+#  mv ${install_dir}/examples/go/taosdemo.go ${install_dir}/examples/go/prodemo.go
-  sed -i '/root/ {s/taosdata/prodb/g}'  ${install_dir}/examples/go/prodemo.go
+#  sed -i '/root/ {s/taosdata/prodb/g}'  ${install_dir}/examples/go/prodemo.go
-fi
+#fi
 # Copy driver
 mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo "${versionComp}" > ${install_dir}/driver/vercomp.txt
 # Copy connector
-connector_dir="${code_dir}/connector"
+#connector_dir="${code_dir}/connector"
-mkdir -p ${install_dir}/connector
+#mkdir -p ${install_dir}/connector
-if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
+#if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
+#  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
-  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+#  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
-    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+#    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
-  else
+#  else
-    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
+#    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
-  fi
+#  fi
-  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+#  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
-    cp -r ${connector_dir}/go ${install_dir}/connector
+#    cp -r ${connector_dir}/go ${install_dir}/connector
-  else
+#  else
-    echo "WARNING: go connector not found, please check if want to use it!"
+#    echo "WARNING: go connector not found, please check if want to use it!"
-  fi
+#  fi
-  cp -r ${connector_dir}/python  ${install_dir}/connector/
+#  cp -r ${connector_dir}/python  ${install_dir}/connector/
-  mv ${install_dir}/connector/python/taos ${install_dir}/connector/python/prodb
+#  mv ${install_dir}/connector/python/taos ${install_dir}/connector/python/prodb
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/cinterface.py
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/cinterface.py
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/subscription.py
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/subscription.py
-  sed -i '/self._password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/connection.py
+#  sed -i '/self._password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/connection.py
-fi
+#fi
 cd ${release_dir}

--- a/packaging/tools/makepkg_tq.sh
+++ b/packaging/tools/makepkg_tq.sh
@@ -82,6 +82,7 @@ else
  cp ${build_dir}/bin/taos          ${install_dir}/bin/tq
  cp ${build_dir}/bin/taosd         ${install_dir}/bin/tqd
  cp ${script_dir}/remove_tq.sh  ${install_dir}/bin
+  cp ${build_dir}/bin/blm3          ${install_dir}/bin/blm3 ||:
  cp ${build_dir}/bin/taosdemo      ${install_dir}/bin/tqdemo
  cp ${build_dir}/bin/taosdump      ${install_dir}/bin/tqdump
  cp ${build_dir}/bin/tarbitrator   ${install_dir}/bin

--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
 #!/bin/bash
 #
-# This file is used to install tdengine rpm package on centos systems. The operating system 
+# This file is used to install tdengine rpm package on centos systems. The operating system
 # is required to use systemd to manage services at boot
 #set -x
@@ -48,11 +48,11 @@ initd_mod=0
 service_mod=2
 if pidof systemd &> /dev/null; then
    service_mod=0
-elif $(which service &> /dev/null); then    
+elif $(which service &> /dev/null); then
    service_mod=1
-    service_config_dir="/etc/init.d" 
+    service_config_dir="/etc/init.d"
    if $(which chkconfig &> /dev/null); then
-         initd_mod=1 
+         initd_mod=1
    elif $(which insserv &> /dev/null); then
        initd_mod=2
    elif $(which update-rc.d &> /dev/null); then
@@ -60,10 +60,18 @@ elif $(which service &> /dev/null); then
    else
        service_mod=2
    fi
-else 
+else
    service_mod=2
 fi
+function kill_blm3() {
+#  ${csudo} pkill -f blm3 || :
+  pid=$(ps -ef | grep "blm3" | grep -v "grep" | awk '{print $2}')
+  if [ -n "$pid" ]; then
+    ${csudo} kill -9 $pid   || :
+  fi
+}
 function kill_taosd() {
 #  ${csudo} pkill -f taosd || :
  pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
@@ -74,17 +82,17 @@ function kill_taosd() {
 function install_include() {
    ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h|| :
-    ${csudo} ln -s ${inc_dir}/taos.h ${inc_link_dir}/taos.h  
+    ${csudo} ln -s ${inc_dir}/taos.h ${inc_link_dir}/taos.h
-    ${csudo} ln -s ${inc_dir}/taoserror.h ${inc_link_dir}/taoserror.h  
+    ${csudo} ln -s ${inc_dir}/taoserror.h ${inc_link_dir}/taoserror.h
 }
 function install_lib() {
    ${csudo} rm -f ${lib_link_dir}/libtaos* || :
    ${csudo} rm -f ${lib64_link_dir}/libtaos* || :
    ${csudo} ln -s ${lib_dir}/libtaos.* ${lib_link_dir}/libtaos.so.1
    ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
    if [[ -d ${lib64_link_dir} && ! -e ${lib64_link_dir}/libtaos.so ]]; then
      ${csudo} ln -s ${lib_dir}/libtaos.* ${lib64_link_dir}/libtaos.so.1           || :
      ${csudo} ln -s ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so   || :
@@ -95,6 +103,7 @@ function install_bin() {
    # Remove links
    ${csudo} rm -f ${bin_link_dir}/taos     || :
    ${csudo} rm -f ${bin_link_dir}/taosd    || :
+    ${csudo} rm -f ${bin_link_dir}/blm3     || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo || :
    ${csudo} rm -f ${bin_link_dir}/taosdump || :
    ${csudo} rm -f ${bin_link_dir}/rmtaos   || :
@@ -105,6 +114,7 @@ function install_bin() {
    #Make link
    [ -x ${bin_dir}/taos ] && ${csudo} ln -s ${bin_dir}/taos ${bin_link_dir}/taos             || :
    [ -x ${bin_dir}/taosd ] && ${csudo} ln -s ${bin_dir}/taosd ${bin_link_dir}/taosd          || :
+    [ -x ${bin_dir}/blm3 ] && ${csudo} ln -s ${bin_dir}/blm3 ${bin_link_dir}/blm3             || :
    [ -x ${bin_dir}/taosdemo ] && ${csudo} ln -s ${bin_dir}/taosdemo ${bin_link_dir}/taosdemo || :
    [ -x ${bin_dir}/taosdump ] && ${csudo} ln -s ${bin_dir}/taosdump ${bin_link_dir}/taosdump || :
    [ -x ${bin_dir}/set_core.sh ] && ${csudo} ln -s ${bin_dir}/set_core.sh ${bin_link_dir}/set_core || :
@@ -122,13 +132,13 @@ function add_newHostname_to_hosts() {
    if [[ "$s" == "$localIp" ]]; then
      return
    fi
-  done 
+  done
  ${csudo} echo "127.0.0.1  $1" >> /etc/hosts   ||:
 }
 function set_hostname() {
  echo -e -n "${GREEN}Please enter one hostname(must not be 'localhost')${NC}:"
-	read newHostname
+  read newHostname
  while true; do
    if [[ ! -z "$newHostname" && "$newHostname" != "localhost" ]]; then
      break
@@ -142,25 +152,25 @@ function set_hostname() {
  if [[ $retval != 0 ]]; then
   echo
   echo "set hostname fail!"
-   return 
+   return
  fi
  #echo -e -n "$(hostnamectl status --static)"
  #echo -e -n "$(hostnamectl status --transient)"
  #echo -e -n "$(hostnamectl status --pretty)"
  #ubuntu/centos /etc/hostname
  if [[ -e /etc/hostname ]]; then
    ${csudo} echo $newHostname > /etc/hostname   ||:
  fi
  #debian: #HOSTNAME=yourname
  if [[ -e /etc/sysconfig/network ]]; then
    ${csudo} sed -i -r "s/#*\s*(HOSTNAME=\s*).*/\1$newHostname/" /etc/sysconfig/network   ||:
  fi
  ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$newHostname/" ${cfg_install_dir}/taos.cfg
-  serverFqdn=$newHostname  
+  serverFqdn=$newHostname
  if [[ -e /etc/hosts ]]; then
    add_newHostname_to_hosts $newHostname
  fi
@@ -178,7 +188,7 @@ function is_correct_ipaddr() {
     return 0
   fi
  done
  return 1
 }
@@ -192,13 +202,13 @@ function set_ipAsFqdn() {
    echo
    echo -e -n "${GREEN}Unable to get local ip, use 127.0.0.1${NC}"
    localFqdn="127.0.0.1"
-    # Write the local FQDN to configuration file                    
+    # Write the local FQDN to configuration file
-    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg
    serverFqdn=$localFqdn
    echo
    return
-  fi  
+  fi
  echo -e -n "${GREEN}Please choose an IP from local IP list${NC}:"
  echo
  echo -e -n "${GREEN}$iplist${NC}"
@@ -207,15 +217,15 @@ function set_ipAsFqdn() {
  echo -e -n "${GREEN}Notes: if IP is used as the node name, data can NOT be migrated to other machine directly${NC}:"
  read localFqdn
    while true; do
-      if [ ! -z "$localFqdn" ]; then            
+      if [ ! -z "$localFqdn" ]; then
        # Check if correct ip address
        is_correct_ipaddr $localFqdn
        retval=`echo $?`
        if [[ $retval != 0 ]]; then
          read -p "Please choose an IP from local IP list:" localFqdn
        else
-          # Write the local FQDN to configuration file                    
+          # Write the local FQDN to configuration file
-          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg
          serverFqdn=$localFqdn
          break
        fi
@@ -230,49 +240,68 @@ function local_fqdn_check() {
  echo
  echo -e -n "System hostname is: ${GREEN}$serverFqdn${NC}"
  echo
-  if [[ "$serverFqdn" == "" ]] || [[ "$serverFqdn" == "localhost"  ]]; then    
+  if [[ "$serverFqdn" == "" ]] || [[ "$serverFqdn" == "localhost"  ]]; then
    echo -e -n "${GREEN}It is strongly recommended to configure a hostname for this machine ${NC}"
    echo
    while true
    do
-	    read -r -p "Set hostname now? [Y/n] " input
+        read -r -p "Set hostname now? [Y/n] " input
-	    if [ ! -n "$input" ]; then
+        if [ ! -n "$input" ]; then
-       set_hostname
+            set_hostname
-       break
+            break
-      else
+        else
-	      case $input in
+            case $input in
-	        [yY][eE][sS]|[yY])
+            [yY][eE][sS]|[yY])
-          set_hostname
+                set_hostname
-          break
+                break
-			    ;;
+                ;;
-	        [nN][oO]|[nN])
+            [nN][oO]|[nN])
-			    set_ipAsFqdn
+                set_ipAsFqdn
-			    break   	
+                break
-			    ;;
+                ;;
-	        *)
+            *)
-			    echo "Invalid input..."
+                echo "Invalid input..."
-			    ;;
+                ;;
-	      esac
+            esac
-	    fi
+        fi
    done
  fi
 }
+function install_blm3_config() {
+    if [ ! -f "${cfg_install_dir}/blm.toml" ]; then
+        [ ! -d %{cfg_install_dir} ] &&
+            ${csudo} ${csudo} mkdir -p ${cfg_install_dir}
+        [ -f ${cfg_dir}/blm.toml ] && ${csudo} cp ${cfg_dir}/blm.toml ${cfg_install_dir}
+        [ -f ${cfg_install_dir}/blm.toml ] &&
+            ${csudo} chmod 644 ${cfg_install_dir}/blm.toml
+    fi
+    # restore the backup standard input, and turn off 6
+    exec 0<&6 6<&-
+    [ -f ${cfg_dir}/blm.toml ] &&
+        ${csudo} mv ${cfg_dir}/blm.toml ${cfg_dir}/blm.toml.org
+    [ -f ${cfg_install_dir}/blm.toml ] &&
+        ${csudo} ln -s ${cfg_install_dir}/blm.toml ${cfg_dir}
+}
 function install_config() {
-    if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
+    if [ ! -f "${cfg_install_dir}/taos.cfg" ]; then
        ${csudo} ${csudo} mkdir -p ${cfg_install_dir}
        [ -f ${cfg_dir}/taos.cfg ] && ${csudo} cp ${cfg_dir}/taos.cfg ${cfg_install_dir}
        ${csudo} chmod 644 ${cfg_install_dir}/*
    fi
    # Save standard input to 6 and open / dev / TTY on standard input
-    exec 6<&0 0</dev/tty 
+    exec 6<&0 0</dev/tty
    local_fqdn_check
    # restore the backup standard input, and turn off 6
    exec 0<&6 6<&-
@@ -290,14 +319,14 @@ function install_config() {
    echo -e -n "${GREEN}OR leave it blank to build one${NC}:"
    #read firstEp
    if exec < /dev/tty; then
-    	read firstEp;
+        read firstEp;
-	fi
+    fi
-	while true; do
+    while true; do
    if [ ! -z "$firstEp" ]; then
        # check the format of the firstEp
        #if [[ $firstEp == $FQDN_PATTERN ]]; then
-            # Write the first FQDN to configuration file                    
+            # Write the first FQDN to configuration file
-            ${csudo} sed -i -r "s/#*\s*(firstEp\s*).*/\1$firstEp/" ${cfg_install_dir}/taos.cfg    
+            ${csudo} sed -i -r "s/#*\s*(firstEp\s*).*/\1$firstEp/" ${cfg_install_dir}/taos.cfg
            break
        #else
        #    read -p "Please enter the correct FQDN:port: " firstEp
@@ -305,9 +334,9 @@ function install_config() {
    else
        break
    fi
-  done		
+  done
-    # user email 
+    # user email
    #EMAIL_PATTERN='^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$'
    #EMAIL_PATTERN='^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$'
    #EMAIL_PATTERN="^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"
@@ -318,27 +347,27 @@ function install_config() {
        if [ ! -z "$emailAddr" ]; then
            # check the format of the emailAddr
            #if [[ "$emailAddr" =~ $EMAIL_PATTERN ]]; then
-                # Write the email address to temp file                    
+                # Write the email address to temp file
-                email_file="${install_main_dir}/email" 
+                email_file="${install_main_dir}/email"
                ${csudo} bash -c "echo $emailAddr > ${email_file}"
-                break         
+                break
            #else
-            #    read -p "Please enter the correct email address: " emailAddr   
+            #    read -p "Please enter the correct email address: " emailAddr
            #fi
        else
            break
        fi
-    done	
+    done
 }
 function clean_service_on_sysvinit() {
    #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"
-    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :    
+    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :
    if pidof taosd &> /dev/null; then
        ${csudo} service taosd stop || :
    fi
    if ((${initd_mod}==1)); then
        ${csudo} chkconfig --del taosd || :
    elif ((${initd_mod}==2)); then
@@ -346,9 +375,9 @@ function clean_service_on_sysvinit() {
    elif ((${initd_mod}==3)); then
        ${csudo} update-rc.d -f taosd remove || :
    fi
    ${csudo} rm -f ${service_config_dir}/taosd || :
    if $(which init &> /dev/null); then
        ${csudo} init q || :
    fi
@@ -359,12 +388,12 @@ function install_service_on_sysvinit() {
    sleep 1
-    # Install taosd service  
+    # Install taosd service
    ${csudo} cp %{init_d_dir}/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
    #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"
    #${csudo} grep -q -F "$restart_config_str" /etc/inittab || ${csudo} bash -c "echo '${restart_config_str}' >> /etc/inittab"
    if ((${initd_mod}==1)); then
        ${csudo} chkconfig --add taosd || :
        ${csudo} chkconfig --level 2345 taosd on || :
@@ -427,6 +456,7 @@ function install_service() {
        install_service_on_sysvinit
    else
        # manual start taosd
+        kill_blm3
        kill_taosd
    fi
 }
@@ -436,20 +466,21 @@ function install_TDengine() {
    #install log and data dir , then ln to /usr/local/taos
    ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
-    ${csudo} mkdir -p ${data_dir} 
+    ${csudo} mkdir -p ${data_dir}
    ${csudo} rm -rf ${log_link_dir}   || :
    ${csudo} rm -rf ${data_link_dir}  || :
    ${csudo} ln -s ${log_dir} ${log_link_dir}     || :
    ${csudo} ln -s ${data_dir} ${data_link_dir}   || :
    # Install include, lib, binary and service
    install_include
    install_lib
    install_bin
    install_service
-    install_config	
+    install_config
+    install_blm3_config
    # Ask if to start the service
    #echo
@@ -461,12 +492,12 @@ function install_TDengine() {
    elif ((${service_mod}==1)); then
        echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} update-rc.d taosd default  ${RED} for the first time${NC}"
        echo -e "                      : ${csudo} service taosd start ${RED} after${NC}"
-    else 
+    else
        echo -e "${GREEN_DARK}To start TDengine     ${NC}: ./taosd${NC}"
    fi
    if [ ! -z "$firstEp" ]; then
      tmpFqdn=${firstEp%%:*}
      substr=":"
@@ -476,16 +507,16 @@ function install_TDengine() {
        tmpPort=""
      fi
      if [[ "$tmpPort" != "" ]];then
-	      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+           echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
-	    else
+      else
-	      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+          echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
-	    fi
+      fi
-	    echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+      echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
      echo
    elif [ ! -z "$serverFqdn" ]; then
-	    echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $serverFqdn${GREEN_DARK} to login into TDengine server${NC}"
+      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $serverFqdn${GREEN_DARK} to login into TDengine server${NC}"
      echo
-    fi    
+    fi
    echo
    echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
 }

--- a/packaging/tools/preun.sh
+++ b/packaging/tools/preun.sh
@@ -27,11 +27,11 @@ initd_mod=0
 service_mod=2
 if pidof systemd &> /dev/null; then
    service_mod=0
-elif $(which service &> /dev/null); then    
+elif $(which service &> /dev/null); then
    service_mod=1
-    service_config_dir="/etc/init.d" 
+    service_config_dir="/etc/init.d"
    if $(which chkconfig &> /dev/null); then
-         initd_mod=1 
+         initd_mod=1
    elif $(which insserv &> /dev/null); then
        initd_mod=2
    elif $(which update-rc.d &> /dev/null); then
@@ -39,10 +39,17 @@ elif $(which service &> /dev/null); then
    else
        service_mod=2
    fi
-else 
+else
    service_mod=2
 fi
+function kill_blm3() {
+  pid=$(ps -ef | grep "blm3" | grep -v "grep" | awk '{print $2}')
+  if [ -n "$pid" ]; then
+    ${csudo} kill -9 $pid   || :
+  fi
+}
 function kill_taosd() {
  pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
  if [ -n "$pid" ]; then
@@ -59,13 +66,13 @@ function clean_service_on_systemd() {
    fi
    ${csudo} systemctl disable ${taos_service_name} &> /dev/null || echo &> /dev/null
-    ${csudo} rm -f ${taosd_service_config}	
+    ${csudo} rm -f ${taosd_service_config}
 }
 function clean_service_on_sysvinit() {
    #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"
-    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :    
+    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :
    if pidof taosd &> /dev/null; then
        echo "TDengine taosd is running, stopping it..."
        ${csudo} service taosd stop || :
@@ -78,9 +85,9 @@ function clean_service_on_sysvinit() {
    elif ((${initd_mod}==3)); then
        ${csudo} update-rc.d -f taosd remove || :
    fi
    ${csudo} rm -f ${service_config_dir}/taosd || :
    if $(which init &> /dev/null); then
        ${csudo} init q || :
    fi
@@ -93,6 +100,7 @@ function clean_service() {
        clean_service_on_sysvinit
    else
        # must manual stop taosd
+        kill_blm3
        kill_taosd
    fi
 }
@@ -103,6 +111,7 @@ clean_service
 # Remove all links
 ${csudo} rm -f ${bin_link_dir}/taos       || :
 ${csudo} rm -f ${bin_link_dir}/taosd      || :
+${csudo} rm -f ${bin_link_dir}/blm3       || :
 ${csudo} rm -f ${bin_link_dir}/taosdemo   || :
 ${csudo} rm -f ${bin_link_dir}/taosdump   || :
 ${csudo} rm -f ${bin_link_dir}/set_core   || :
@@ -116,6 +125,7 @@ ${csudo} rm -f ${log_link_dir}            || :
 ${csudo} rm -f ${data_link_dir}           || :
 if ((${service_mod}==2)); then
+    kill_blm3
    kill_taosd
 fi

--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
@@ -38,11 +38,11 @@ initd_mod=0
 service_mod=2
 if pidof systemd &> /dev/null; then
    service_mod=0
-elif $(which service &> /dev/null); then    
+elif $(which service &> /dev/null); then
    service_mod=1
-    service_config_dir="/etc/init.d" 
+    service_config_dir="/etc/init.d"
    if $(which chkconfig &> /dev/null); then
-         initd_mod=1 
+         initd_mod=1
    elif $(which insserv &> /dev/null); then
        initd_mod=2
    elif $(which update-rc.d &> /dev/null); then
@@ -50,10 +50,17 @@ elif $(which service &> /dev/null); then
    else
        service_mod=2
    fi
-else 
+else
    service_mod=2
 fi
+function kill_blm3() {
+  pid=$(ps -ef | grep "blm3" | grep -v "grep" | awk '{print $2}')
+  if [ -n "$pid" ]; then
+    ${csudo} kill -9 $pid   || :
+  fi
+}
 function kill_taosd() {
  pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
  if [ -n "$pid" ]; then
@@ -71,6 +78,7 @@ function clean_bin() {
    # Remove link
    ${csudo} rm -f ${bin_link_dir}/taos        || :
    ${csudo} rm -f ${bin_link_dir}/taosd       || :
+    ${csudo} rm -f ${bin_link_dir}/blm3        || :
    ${csudo} rm -f ${bin_link_dir}/taosdemo    || :
    ${csudo} rm -f ${bin_link_dir}/taosdump    || :
    ${csudo} rm -f ${bin_link_dir}/rmtaos      || :
@@ -93,7 +101,7 @@ function clean_header() {
 function clean_config() {
    # Remove link
-    ${csudo} rm -f ${cfg_link_dir}/*            || :    
+    ${csudo} rm -f ${cfg_link_dir}/*            || :
 }
 function clean_log() {
@@ -109,7 +117,7 @@ function clean_service_on_systemd() {
    fi
    ${csudo} systemctl disable ${taos_service_name} &> /dev/null || echo &> /dev/null
    ${csudo} rm -f ${taosd_service_config}
    tarbitratord_service_config="${service_config_dir}/${tarbitrator_service_name}.service"
    if systemctl is-active --quiet ${tarbitrator_service_name}; then
        echo "TDengine tarbitrator is running, stopping it..."
@@ -117,60 +125,60 @@ function clean_service_on_systemd() {
    fi
    ${csudo} systemctl disable ${tarbitrator_service_name} &> /dev/null || echo &> /dev/null
    ${csudo} rm -f ${tarbitratord_service_config}
    if [ "$verMode" == "cluster" ]; then
-		  nginx_service_config="${service_config_dir}/${nginx_service_name}.service"	
+        nginx_service_config="${service_config_dir}/${nginx_service_name}.service"
-   	 	if [ -d ${install_nginxd_dir} ]; then
+        if [ -d ${install_nginxd_dir} ]; then
-   	    if systemctl is-active --quiet ${nginx_service_name}; then
+            if systemctl is-active --quiet ${nginx_service_name}; then
-   	      echo "Nginx for TDengine is running, stopping it..."
+                echo "Nginx for TDengine is running, stopping it..."
-   	      ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null
+                ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null
-   	    fi
+            fi
-   	    ${csudo} systemctl disable ${nginx_service_name} &> /dev/null || echo &> /dev/null
+            ${csudo} systemctl disable ${nginx_service_name} &> /dev/null || echo &> /dev/null
-   	    ${csudo} rm -f ${nginx_service_config}
+            ${csudo} rm -f ${nginx_service_config}
-   	  fi
+        fi
-    fi 
+    fi
 }
 function clean_service_on_sysvinit() {
    #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"
-    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :    
+    #${csudo} sed -i "\|${restart_config_str}|d" /etc/inittab || :
    if pidof taosd &> /dev/null; then
        echo "TDengine taosd is running, stopping it..."
        ${csudo} service taosd stop || :
    fi
    if pidof tarbitrator &> /dev/null; then
        echo "TDengine tarbitrator is running, stopping it..."
        ${csudo} service tarbitratord stop || :
    fi
-    if ((${initd_mod}==1)); then    
+    if ((${initd_mod}==1)); then
-      if [ -e ${service_config_dir}/taosd ]; then 
+      if [ -e ${service_config_dir}/taosd ]; then
        ${csudo} chkconfig --del taosd || :
      fi
-      if [ -e ${service_config_dir}/tarbitratord ]; then 
+      if [ -e ${service_config_dir}/tarbitratord ]; then
        ${csudo} chkconfig --del tarbitratord || :
      fi
-    elif ((${initd_mod}==2)); then   
+    elif ((${initd_mod}==2)); then
-      if [ -e ${service_config_dir}/taosd ]; then 
+      if [ -e ${service_config_dir}/taosd ]; then
        ${csudo} insserv -r taosd || :
      fi
-      if [ -e ${service_config_dir}/tarbitratord ]; then 
+      if [ -e ${service_config_dir}/tarbitratord ]; then
        ${csudo} insserv -r tarbitratord || :
      fi
-    elif ((${initd_mod}==3)); then  
+    elif ((${initd_mod}==3)); then
-      if [ -e ${service_config_dir}/taosd ]; then 
+      if [ -e ${service_config_dir}/taosd ]; then
        ${csudo} update-rc.d -f taosd remove || :
      fi
-      if [ -e ${service_config_dir}/tarbitratord ]; then 
+      if [ -e ${service_config_dir}/tarbitratord ]; then
        ${csudo} update-rc.d -f tarbitratord remove || :
      fi
    fi
    ${csudo} rm -f ${service_config_dir}/taosd || :
    ${csudo} rm -f ${service_config_dir}/tarbitratord || :
    if $(which init &> /dev/null); then
        ${csudo} init q || :
    fi
@@ -183,6 +191,7 @@ function clean_service() {
        clean_service_on_sysvinit
    else
        # must manual stop taosd
+        kill_blm3
        kill_taosd
        kill_tarbitrator
    fi
@@ -201,7 +210,7 @@ clean_log
 # Remove link configuration file
 clean_config
 # Remove data link directory
-${csudo} rm -rf ${data_link_dir}    || : 
+${csudo} rm -rf ${data_link_dir}    || :
 ${csudo} rm -rf ${install_main_dir}
 ${csudo} rm -rf ${install_nginxd_dir}
@@ -213,14 +222,14 @@ fi
 if echo $osinfo | grep -qwi "ubuntu" ; then
 #  echo "this is ubuntu system"
-   ${csudo} dpkg --force-all  -P tdengine || :
+   ${csudo} dpkg --force-all  -P tdengine > /dev/null 2>&1 || :
 elif echo $osinfo | grep -qwi "debian" ; then
 #  echo "this is debian system"
-   ${csudo} dpkg --force-all  -P tdengine || :
+   ${csudo} dpkg --force-all  -P tdengine > /dev/null 2>&1 || :
 elif  echo $osinfo | grep -qwi "centos" ; then
 #  echo "this is centos system"
-  ${csudo} rpm -e --noscripts tdengine || :
+  ${csudo} rpm -e --noscripts tdengine > /dev/null 2>&1 || :
 fi
 echo -e "${GREEN}TDengine is removed successfully!${NC}"
-echo 
+echo
--- a/packaging/tools/startPre.sh
+++ b/packaging/tools/startPre.sh
@@ -19,7 +19,7 @@ if [[ ! -e ${startSeqFile} ]]; then
 else
  startSeq=$(cat ${startSeqFile})
 fi
 nextSeq=`expr $startSeq + 1`
 echo "${nextSeq}" > ${startSeqFile}
@@ -48,3 +48,4 @@ if [ ${coreFlag} = "unlimited" ];then
  fi
 fi
+/usr/bin/blm3 &
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
 name: tdengine
 base: core18
-version: '2.1.7.2'
+version: '2.2.0.5'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
      - usr/bin/taosd
      - usr/bin/taos
      - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.1.7.2
+      - usr/lib/libtaos.so.2.2.0.5
      - usr/lib/libtaos.so.1
      - usr/lib/libtaos.so

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 # Base compile

--- a/src/balance/CMakeLists.txt
+++ b/src/balance/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc)

--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 INCLUDE_DIRECTORIES(inc)

--- a/src/client/inc/tscGlobalmerge.h
+++ b/src/client/inc/tscGlobalmerge.h
@@ -58,6 +58,7 @@ typedef struct SRetrieveSupport {
  int32_t           subqueryIndex;     // index of current vnode in vnode list
  struct SSqlObj   *pParentSql;
  tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
+  uint32_t          localBufferSize;
  uint32_t          numOfRetry;        // record the number of retry times
 } SRetrieveSupport;

--- a/src/client/inc/tscParseLine.h
+++ b/src/client/inc/tscParseLine.h
@@ -20,11 +20,15 @@
 extern "C" {
 #endif
+#define SML_TIMESTAMP_SECOND_DIGITS 10
+#define SML_TIMESTAMP_MILLI_SECOND_DIGITS 13
 typedef struct {
  char* key;
  uint8_t type;
  int16_t length;
  char* value;
+  uint32_t fieldSchemaIdx;
 } TAOS_SML_KV;
 typedef struct {
@@ -37,18 +41,31 @@ typedef struct {
  // first kv must be timestamp
  TAOS_SML_KV* fields;
  int32_t fieldNum;
+  uint32_t schemaIdx;
 } TAOS_SML_DATA_POINT;
 typedef enum {
  SML_TIME_STAMP_NOW,
+  SML_TIME_STAMP_HOURS,
+  SML_TIME_STAMP_MINUTES,
  SML_TIME_STAMP_SECONDS,
  SML_TIME_STAMP_MILLI_SECONDS,
  SML_TIME_STAMP_MICRO_SECONDS,
-  SML_TIME_STAMP_NANO_SECONDS
+  SML_TIME_STAMP_NANO_SECONDS,
+  SML_TIME_STAMP_NOT_CONFIGURED
 } SMLTimeStampType;
+typedef enum {
+  SML_LINE_PROTOCOL = 0,
+  SML_TELNET_PROTOCOL = 1,
+  SML_JSON_PROTOCOL = 2,
+} SMLProtocolType;
 typedef struct {
  uint64_t id;
+  SMLProtocolType protocol;
+  SMLTimeStampType tsType;
  SHashObj* smlDataToSchema;
 } SSmlLinesInfo;
@@ -57,15 +74,23 @@ bool checkDuplicateKey(char *key, SHashObj *pHash, SSmlLinesInfo* info);
 bool isValidInteger(char *str);
 bool isValidFloat(char *str);
-int32_t isValidChildTableName(const char *pTbName, int16_t len);
+int32_t isValidChildTableName(const char *pTbName, int16_t len, SSmlLinesInfo* info);
 bool convertSmlValueType(TAOS_SML_KV *pVal, char *value,
-                         uint16_t len, SSmlLinesInfo* info);
+                         uint16_t len, SSmlLinesInfo* info, bool isTag);
 int32_t convertSmlTimeStamp(TAOS_SML_KV *pVal, char *value,
                            uint16_t len, SSmlLinesInfo* info);
 void destroySmlDataPoint(TAOS_SML_DATA_POINT* point);
+int taos_insert_sml_lines(TAOS* taos, char* lines[], int numLines,
+                          SMLProtocolType protocol, SMLTimeStampType tsType);
+int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines,
+                             SMLProtocolType protocol, SMLTimeStampType tsType);
+int taos_insert_json_payload(TAOS* taos, char* payload,
+                             SMLProtocolType protocol, SMLTimeStampType tsType);
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -52,7 +52,7 @@ int tsInsertInitialCheck(SSqlObj *pSql);
 void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
-void tscFreeRetrieveSup(SSqlObj *pSql);
+void tscFreeRetrieveSup(void **param);

--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -64,7 +64,7 @@ typedef struct STidTags {
 #pragma pack(pop)
 typedef struct SJoinSupporter {
-  SSqlObj*        pObj;           // parent SqlObj
+  int64_t         pObj;           // parent SqlObj
  int32_t         subqueryIndex;  // index of sub query
  SInterval       interval;
  SLimitVal       limit;          // limit info
@@ -180,7 +180,7 @@ bool tscQueryBlockInfo(SQueryInfo* pQueryInfo);
 SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType, int16_t colId);
-int32_t tscSetTableFullName(SName* pName, SStrToken* pzTableName, SSqlObj* pSql);
+int32_t tscSetTableFullName(SName* pName, SStrToken* pzTableName, SSqlObj* pSql, bool dbIncluded);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 bool tscIsInsertData(char* sqlstr);
@@ -251,7 +251,7 @@ void tscColumnListCopyAll(SArray* dst, const SArray* src);
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo, uint64_t objId, bool convertNchar);
 void tscDequoteAndTrimToken(SStrToken* pToken);
-int32_t tscValidateName(SStrToken* pToken);
+int32_t tscValidateName(SStrToken* pToken, bool escapeEnabled, bool *dbIncluded);
 void tscIncStreamExecutionCount(void* pStream);
@@ -386,6 +386,8 @@ void tscRemoveCachedTableMeta(STableMetaInfo* pTableMetaInfo, uint64_t id);
 char* cloneCurrentDBName(SSqlObj* pSql);
+char* cloneCurrentDBName(SSqlObj* pSql);
 #ifdef __cplusplus
 }
 #endif

--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -47,6 +47,7 @@ typedef enum {
 struct SSqlInfo;
 typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int32_t numOfRows);
+typedef void (*_freeSqlSupporter)(void **);
 typedef struct SNewVgroupInfo {
@@ -311,6 +312,7 @@ typedef struct {
  char *         data;
  TAOS_ROW       tsrow;
  TAOS_ROW       urow;
+  bool           dataConverted;
  int32_t*       length;  // length for each field for current row
  char **        buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
  SColumnIndex*  pColumnIndex;
@@ -364,6 +366,7 @@ typedef struct SSqlObj {
  __async_cb_func_t  fp;
  __async_cb_func_t  fetchFp;
  void            *param;
+  _freeSqlSupporter  freeParam;
  int64_t          stime;
  uint32_t         queryId;
  void *           pStream;
@@ -381,6 +384,7 @@ typedef struct SSqlObj {
  SSubqueryState   subState;
  struct SSqlObj **pSubs;
+  struct SSqlObj  *rootObj;
  int64_t          metaRid;
  int64_t          svgroupRid;
@@ -448,7 +452,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo *pQueryInfo);
 void    tscRestoreFuncForSTableQuery(SQueryInfo *pQueryInfo);
 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock, bool convertNchar);
 void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlObj* pParent);

--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -17,6 +17,7 @@
 #include "taos.h"
 #include "tlog.h"
 #include "tscUtil.h"
+#include "tscParseLine.h"
 #include "com_taosdata_jdbc_TSDBJNIConnector.h"
@@ -1070,7 +1071,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_insertLinesImp(J
    c_lines[i] = (char *)(*env)->GetStringUTFChars(env, line, 0);
  }
-  int code = taos_insert_lines(taos, c_lines, numLines);
+  int code = taos_schemaless_insert(taos, c_lines, numLines, SML_LINE_PROTOCOL, "ms");
  for (int i = 0; i < numLines; ++i) {
    jstring line = (jstring)((*env)->GetObjectArrayElement(env, lines, i));
@@ -1084,4 +1085,4 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_insertLinesImp(J
    return JNI_TDENGINE_ERROR;
  }
  return code;
 }
\ No newline at end of file
--- a/src/client/src/taos.def
+++ b/src/client/src/taos.def
@@ -44,3 +44,10 @@ taos_unsubscribe
 taos_open_stream
 taos_close_stream
 taos_load_table_info
+taos_data_type
+taos_stmt_set_sub_tbname
+taos_stmt_get_param
+taos_stmt_bind_param_batch
+taos_stmt_bind_single_param_batch
+taos_is_null
+taos_insert_lines
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -44,6 +44,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
  pSql->maxRetry  = TSDB_MAX_REPLICA;
  pSql->fp        = fp;
  pSql->fetchFp   = fp;
+  pSql->rootObj   = pSql;
  registerSqlObj(pSql);
@@ -176,6 +177,9 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
    } else {
      pRes->code = numOfRows;
    }
+    if (pRes->code == TSDB_CODE_SUCCESS) {
+      pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;           
+    }
    tscAsyncResultOnError(pSql);
    return;

--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -398,7 +398,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
  TAOS_FIELD f; 
  if (type == SCREATE_BUILD_TABLE) {
    f.type  = TSDB_DATA_TYPE_BINARY;
-    f.bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
+    f.bytes = (TSDB_TABLE_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
    tstrncpy(f.name, "Table", sizeof(f.name));
  } else {
    f.type  = TSDB_DATA_TYPE_BINARY;
@@ -465,7 +465,7 @@ int32_t tscRebuildCreateTableStatement(void *param,char *result) {
  code = tscGetTableTagValue(builder, buf);
  if (code == TSDB_CODE_SUCCESS) {
-    snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE TABLE %s USING %s TAGS %s", builder->buf, builder->sTableName, buf);
+    snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE TABLE `%s` USING `%s` TAGS %s", builder->buf, builder->sTableName, buf);
    code = tscSCreateBuildResult(builder->pParentSql, SCREATE_BUILD_TABLE, builder->buf, result);    
  }  
  free(buf);
@@ -574,12 +574,14 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
  }
  char fullName[TSDB_TABLE_FNAME_LEN * 2] = {0};
+  char tblName[TSDB_TABLE_NAME_LEN + 1] = {0};
  tNameGetDbName(&pTableMetaInfo->name, fullName);
  extractTableName(pMeta->sTableName, param->sTableName);
-  snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName),  ".%s", param->sTableName);
+  snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName),  ".`%s`", param->sTableName);
  strncpy(param->buf, tNameGetTableName(&pTableMetaInfo->name), TSDB_TABLE_NAME_LEN);
+  tableNameToStr(tblName, param->buf, '\'');
  param->pParentSql = pSql;
  param->pInterSql  = pInterSql;
@@ -602,7 +604,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
    return code;
  }
-  snprintf(query + strlen(query), TSDB_MAX_BINARY_LEN - strlen(query), "SELECT %s FROM %s WHERE TBNAME IN(\'%s\')", columns, fullName, param->buf);
+  snprintf(query + strlen(query), TSDB_MAX_BINARY_LEN - strlen(query), "SELECT %s FROM %s WHERE TBNAME IN(\'%s\')", columns, fullName, tblName);
  doAsyncQuery(pSql->pTscObj, pInterSql, tscSCreateCallBack, param, query, strlen(query));
  free(query);
  free(columns);
@@ -619,7 +621,7 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
  SSchema *pSchema = tscGetTableSchema(pMeta);
  char *result = ddl;
-  sprintf(result, "create table %s (", tableName);
+  sprintf(result, "create table `%s` (", tableName);
  for (int32_t i = 0; i < numOfRows; ++i) {
    uint8_t type = pSchema[i].type;
    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
@@ -646,7 +648,7 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
  int32_t totalRows = numOfRows + tscGetNumOfTags(pMeta);
  SSchema *pSchema = tscGetTableSchema(pMeta);
-  sprintf(result, "create table %s (", tableName);
+  sprintf(result, "create table `%s` (", tableName);
  for (int32_t i = 0; i < numOfRows; ++i) {
    uint8_t type = pSchema[i].type;
    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {

--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -114,7 +114,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
  }
  for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
-    if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+    if (isspace(pToken->z[k])) continue;
    if (pToken->z[k] == ',') {
      *next = pTokenEnd;
      *time = useconds;
@@ -906,6 +906,18 @@ static int32_t doParseInsertStatement(SInsertStatementParam *pInsertParam, char
  return TSDB_CODE_SUCCESS;
 }
+int validateTableName(char *tblName, int len, SStrToken* psTblToken, bool *dbIncluded) {
+  tstrncpy(psTblToken->z, tblName, TSDB_TABLE_FNAME_LEN);
+  psTblToken->n    = len;
+  psTblToken->type = TK_ID;
+  tGetToken(psTblToken->z, &psTblToken->type);
+  return tscValidateName(psTblToken, true, dbIncluded);
+}
 static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundColumn) {
  int32_t   index = 0;
  SStrToken sToken = {0};
@@ -968,13 +980,27 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
    sToken = tStrGetToken(sql, &index, false);
    sql += index;
+    if (sToken.type == TK_ILLEGAL) {
+      return tscSQLSyntaxErrMsg(pCmd->payload, NULL, sql);
+    }
    //the source super table is moved to the secondary position of the pTableMetaInfo list
    if (pQueryInfo->numOfTables < 2) {
      tscAddEmptyMetaInfo(pQueryInfo);
    }
+    bool dbIncluded1 = false;
+    char      buf[TSDB_TABLE_FNAME_LEN];
+    SStrToken sTblToken;
+    sTblToken.z = buf;
+    code = validateTableName(sToken.z, sToken.n, &sTblToken, &dbIncluded1);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
    STableMetaInfo *pSTableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
-    code = tscSetTableFullName(&pSTableMetaInfo->name, &sToken, pSql);
+    code = tscSetTableFullName(&pSTableMetaInfo->name, &sTblToken, pSql, dbIncluded1);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }
@@ -988,7 +1014,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
    }
    if (!UTIL_TABLE_IS_SUPER_TABLE(pSTableMetaInfo)) {
-      return tscInvalidOperationMsg(pInsertParam->msg, "create table only from super table is allowed", sToken.z);
+      return tscInvalidOperationMsg(pInsertParam->msg, "create table only from super table is allowed", sTblToken.z);
    }
    SSchema *pTagSchema = tscGetTableTagSchema(pSTableMetaInfo->pTableMeta);
@@ -1144,12 +1170,16 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
    }
    sql = sToken.z;
+    bool dbIncluded2 = false;
-    if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+    sTblToken.z = buf;
+    code = validateTableName(tableToken.z, tableToken.n, &sTblToken, &dbIncluded2);
+    if (code != TSDB_CODE_SUCCESS) {
      return tscInvalidOperationMsg(pInsertParam->msg, "invalid table name", *sqlstr);
    }
-    int32_t ret = tscSetTableFullName(&pTableMetaInfo->name, &tableToken, pSql);
+    int32_t ret = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded2);
    if (ret != TSDB_CODE_SUCCESS) {
      return ret;
    }
@@ -1179,16 +1209,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
  return code;
 }
-int validateTableName(char *tblName, int len, SStrToken* psTblToken) {
-  tstrncpy(psTblToken->z, tblName, TSDB_TABLE_FNAME_LEN);
-  psTblToken->n    = len;
-  psTblToken->type = TK_ID;
-  tGetToken(psTblToken->z, &psTblToken->type);
-  return tscValidateName(psTblToken);
-}
 static int32_t validateDataSource(SInsertStatementParam *pInsertParam, int32_t type, const char *sql) {
  uint32_t *insertType = &pInsertParam->insertType;
  if (*insertType == TSDB_QUERY_TYPE_STMT_INSERT && type == TSDB_QUERY_TYPE_INSERT) {
@@ -1409,13 +1429,14 @@ int tsParseInsertSql(SSqlObj *pSql) {
    char      buf[TSDB_TABLE_FNAME_LEN];
    SStrToken sTblToken;
    sTblToken.z = buf;
+    bool dbIncluded = false;
    // Check if the table name available or not
-    if (validateTableName(sToken.z, sToken.n, &sTblToken) != TSDB_CODE_SUCCESS) {
+    if (validateTableName(sToken.z, sToken.n, &sTblToken, &dbIncluded) != TSDB_CODE_SUCCESS) {
      code = tscInvalidOperationMsg(pInsertParam->msg, "table name invalid", sToken.z);
      goto _clean;
    }
-    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql, dbIncluded)) != TSDB_CODE_SUCCESS) {
      goto _clean;
    }
@@ -1597,7 +1618,8 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
    ret = tsParseInsertSql(pSql);
    if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION)) {
-      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+      SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, msg:%s, clear meta cache and retry ", pSql->self, pInsertParam->msg, tstrerror(ret));
      tscResetSqlCmd(pCmd, true, pSql->self);
      pSql->parseRetry++;
@@ -1765,6 +1787,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
      pSql->res.numOfRows = 0;
      code = doPackSendDataBlock(pSql, pInsertParam, pTableMeta, count, pTableDataBlock);
      if (code != TSDB_CODE_SUCCESS) {
+        pParentSql->res.code = code;
        goto _error;
      }

--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
--- a/src/client/src/tscParseOpenTSDB.c
+++ b/src/client/src/tscParseOpenTSDB.c
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -86,6 +86,10 @@ typedef struct STscStmt {
  return _code;             \
 } while (0)
+#define STMT_CHECK if (pStmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) { \
+                      STMT_RET(TSDB_CODE_TSC_DISCONNECTED);  \
+                    }
 static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
  return tscInvalidOperationMsg(dstBuffer, errMsg, NULL);
 }
@@ -155,6 +159,22 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
        var->i64 = *(int64_t*)tb->buffer;
        break;
+      case  TSDB_DATA_TYPE_UTINYINT:
+        var->u64 = *(uint8_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_USMALLINT:
+        var->u64 = *(uint16_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_UINT:
+        var->u64 = *(uint32_t*)tb->buffer;
+        break;
+      case  TSDB_DATA_TYPE_UBIGINT:
+        var->u64 = *(uint64_t*)tb->buffer;
+        break;
      case TSDB_DATA_TYPE_FLOAT:
        var->dKey = GET_FLOAT_VAL(tb->buffer);
        break;
@@ -261,9 +281,17 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
      taosStringBuilderAppendInteger(&sb, var->i64);
      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+      taosStringBuilderAppendUnsignedInteger(&sb, var->u64);
+      break;
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
      taosStringBuilderAppendDouble(&sb, var->dKey);
@@ -1493,6 +1521,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
  pSql->maxRetry  = TSDB_MAX_REPLICA;
  pStmt->pSql     = pSql;
  pStmt->last     = STMT_INIT;
+  registerSqlObj(pSql);
  return pStmt;
 }
@@ -1500,9 +1529,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
 int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (sql == NULL) {
    tscError("sql is NULL");
@@ -1579,15 +1606,14 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
  STscStmt* pStmt = (STscStmt*)stmt;
  int32_t code = 0;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  SSqlObj* pSql = pStmt->pSql;
  SSqlCmd* pCmd = &pSql->cmd;
+  uint32_t nameLen = (uint32_t)strlen(name);
-  if (name == NULL) {
+  if (name == NULL || nameLen <= 0) {
-    tscError("0x%"PRIx64" name is NULL", pSql->self);
+    tscError("0x%"PRIx64" tbname is NULL", pSql->self);
    STMT_RET(invalidOperationMsg(tscGetErrorMsgPayload(&pStmt->pSql->cmd), "name is NULL"));
  }
@@ -1603,6 +1629,20 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
  pStmt->last = STMT_SETTBNAME;
+  SStrToken tname = {0};
+  tname.type = TK_STRING;
+  tname.z = (char *)strdup(name);
+  tname.n = (uint32_t)strlen(name);
+  bool dbIncluded = false;
+  // Check if the table name available or not
+  if (tscValidateName(&tname, true, &dbIncluded) != TSDB_CODE_SUCCESS) {
+    tscError("0x%"PRIx64" tbname[%s] is invalid", pSql->self, name);
+    free(tname.z);
+    STMT_RET(invalidOperationMsg(tscGetErrorMsgPayload(&pStmt->pSql->cmd), "name is invalid"));
+  }
  uint64_t* uid = (uint64_t*)taosHashGet(pStmt->mtb.pTableHash, name, strlen(name));
  if (uid != NULL) {
    pStmt->mtb.currentUid = *uid;
@@ -1610,6 +1650,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pStmt->mtb.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
    if (t1 == NULL) {
      tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pSql->self, pStmt->mtb.currentUid);
+      free(tname.z);
      STMT_RET(TSDB_CODE_TSC_APP_ERROR);
    }
@@ -1624,6 +1665,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
    taosHashPut(pCmd->insertParam.pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
    tscDebug("0x%"PRIx64" table:%s is already prepared, uid:%" PRIu64, pSql->self, name, pStmt->mtb.currentUid);
+    free(tname.z);
    STMT_RET(TSDB_CODE_SUCCESS);
  }
@@ -1632,13 +1674,10 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
    char sTableName[TSDB_TABLE_FNAME_LEN] = {0};
    tstrncpy(sTableName, pTableMeta->sTableName, sizeof(sTableName));
-    SStrToken tname = {0};
-    tname.type = TK_STRING;
-    tname.z = (char *)name;
-    tname.n = (uint32_t)strlen(name);
    SName fullname = {0};
-    tscSetTableFullName(&fullname, &tname, pSql);
+    tscSetTableFullName(&fullname, &tname, pSql, dbIncluded);
+    free(tname.z);
    memcpy(&pTableMetaInfo->name, &fullname, sizeof(fullname));
@@ -1672,6 +1711,8 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
    STMT_RET(TSDB_CODE_SUCCESS);
  }
+  free(tname.z);
  if (pStmt->mtb.tagSet) {
    pStmt->mtb.tbname = tscReplaceStrToken(&pSql->sqlstr, &pStmt->mtb.tbname, name);
  } else {
@@ -1741,6 +1782,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
 int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
  pStmt->mtb.subSet = true;
  return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1749,6 +1791,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
 int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
  pStmt->mtb.subSet = false;
  return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1756,6 +1799,9 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 int taos_stmt_close(TAOS_STMT* stmt) {
  STscStmt* pStmt = (STscStmt*)stmt;
+  if (pStmt == NULL || pStmt->taos == NULL) {
+    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
+  }
  if (!pStmt->isInsert) {
    SNormalStmt* normal = &pStmt->normal;
    if (normal->params != NULL) {
@@ -1777,8 +1823,9 @@ int taos_stmt_close(TAOS_STMT* stmt) {
      pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->pSql, pStmt->mtb.pTableBlockHashList, rmMeta);
      if (pStmt->pSql){
        taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
+        pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
      }
-      pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
      taosArrayDestroy(pStmt->mtb.tags);
      tfree(pStmt->mtb.sqlstr);
    }
@@ -1791,9 +1838,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
 int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->multiTbInsert) {
@@ -1822,9 +1867,7 @@ int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
 int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1855,9 +1898,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
 int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX || colIdx < 0) {
    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1890,9 +1931,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, in
 int taos_stmt_add_batch(TAOS_STMT* stmt) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
@@ -1919,9 +1958,7 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
 int taos_stmt_execute(TAOS_STMT* stmt) {
  int ret = 0;
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    if (pStmt->last != STMT_ADD_BATCH) {
@@ -1942,11 +1979,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
    if (sql == NULL) {
      ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
    } else {
-      if (pStmt->pSql != NULL) {
+      taosReleaseRef(tscObjRef, pStmt->pSql->self);
-        tscFreeSqlObj(pStmt->pSql);
-        pStmt->pSql = NULL;
-      }
      pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
      ret = taos_errno(pStmt->pSql);
      free(sql);
@@ -1967,7 +2000,6 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
    tscError("result has been used already.");
    return NULL;
  }
  TAOS_RES* result = pStmt->pSql;
  pStmt->pSql = NULL;
  return result;
@@ -1976,9 +2008,7 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
 int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (insert) *insert = pStmt->isInsert;
@@ -1988,9 +2018,7 @@ int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
 int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    SSqlObj* pSql = pStmt->pSql;
@@ -2007,9 +2035,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
 int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
  STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+  STMT_CHECK
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
  if (pStmt->isInsert) {
    SSqlCmd* pCmd = &pStmt->pSql->cmd;

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -880,6 +880,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  pSql->pTscObj  = taos;
  pSql->signature = pSql;
+  pSql->rootObj = pSql;
  SSqlCmd *pCmd = &pSql->cmd;
  pCmd->resColumnId = TSDB_RES_COL_ID;
@@ -988,6 +989,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  pSql->pTscObj   = taos;
  pSql->signature = pSql;
+  pSql->rootObj = pSql;
  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
  free(str);

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -682,6 +682,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
  pSql->signature = pSql;
  pSql->pTscObj = pObj;
+  pSql->rootObj = pSql;
  SSqlCmd *pCmd = &pSql->cmd;
  SSqlRes *pRes = &pSql->res;

--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -127,6 +127,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
  pSql->signature = pSql;
  pSql->pTscObj = pObj;
  pSql->pSubscription = pSub;
+  pSql->rootObj = pSql;
  pSub->pSql = pSql;
  SSqlCmd* pCmd = &pSql->cmd;
@@ -265,12 +266,14 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
  SSqlCmd* pCmd = &pSql->cmd;
-  TSDB_QUERY_CLEAR_TYPE(tscGetQueryInfo(pCmd)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  TSDB_QUERY_CLEAR_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
  if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
    STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
-    SSubscriptionProgress target = {.uid = pTableMeta->id.uid, .key = 0};
+    SSubscriptionProgress target = {.uid = pTableMeta->id.uid, .key = pQueryInfo->window.skey};
    SSubscriptionProgress* p = taosArraySearch(pSub->progress, &target, tscCompareSubscriptionProgress, TD_EQ);
    if (p == NULL) {
      taosArrayClear(pSub->progress);
@@ -288,7 +291,6 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
  }
  size_t numOfTables = taosArrayGetSize(tables);
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
  SArray* progress = taosArrayInit(numOfTables, sizeof(SSubscriptionProgress));
  for( size_t i = 0; i < numOfTables; i++ ) {
    STidTags* tt = taosArrayGet( tables, i );

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
--- a/src/client/tests/CMakeLists.txt
+++ b/src/client/tests/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 FIND_PATH(HEADER_GTEST_INCLUDE_DIR gtest.h /usr/include/gtest /usr/local/include/gtest)

--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 INCLUDE_DIRECTORIES(inc)

--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -92,6 +92,10 @@ size_t tableIdPrefix(const char* name, char* prefix, int32_t len);
 void extractTableNameFromToken(SStrToken *pToken, SStrToken* pTable);
+char *tableNameGetPosition(SStrToken* pToken, char target);
+char *tableNameToStr(char *dst, char *src, char quote);
 SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name);
 bool tscValidateTableNameLength(size_t len);

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
--- a/src/common/src/tname.c
+++ b/src/common/src/tname.c
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -81,7 +81,7 @@ void tVariantCreate(tVariant *pVar, SStrToken *token) {
    case TSDB_DATA_TYPE_BINARY: {
      pVar->pz = strndup(token->z, token->n);
-      pVar->nLen = strRmquote(pVar->pz, token->n);
+      pVar->nLen = strRmquoteEscape(pVar->pz, token->n);
      break;
    }
    case TSDB_DATA_TYPE_TIMESTAMP: {

--- a/grafanaplugin @ edad7465
+++ b/grafanaplugin @ edad7465
-Subproject commit 016d8e82a24d72779be0ab0090580a372b4fffca
+Subproject commit edad746514b2a53a8cf6061c93b98b52a5388692
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)

--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/DatabaseMetaDataResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/DatabaseMetaDataResultSet.java
@@ -149,7 +149,7 @@ public class DatabaseMetaDataResultSet extends AbstractResultSet {
    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
        int colType = columnMetaDataList.get(columnIndex - 1).getColType();
        double value = rowCursor.getDouble(columnIndex, colType);
-        return new BigDecimal(value);
+        return BigDecimal.valueOf(value);
    }
    @Override

--- a/src/connector/odbc/CMakeLists.txt
+++ b/src/connector/odbc/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 IF (TD_LINUX_64)

--- a/src/connector/odbc/src/CMakeLists.txt
+++ b/src/connector/odbc/src/CMakeLists.txt
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0...3.20)
 PROJECT(TDengine)
 add_subdirectory(base)

--- a/src/connector/odbc/src/base/CMakeLists.txt
+++ b/src/connector/odbc/src/base/CMakeLists.txt
--- a/src/connector/python/README.md
+++ b/src/connector/python/README.md
--- a/src/connector/python/examples/insert-lines.py
+++ b/src/connector/python/examples/insert-lines.py
--- a/src/connector/python/taos/__init__.py
+++ b/src/connector/python/taos/__init__.py
--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
--- a/src/connector/python/taos/connection.py
+++ b/src/connector/python/taos/connection.py
--- a/src/connector/python/taos/error.py
+++ b/src/connector/python/taos/error.py
--- a/src/connector/python/tests/test_lines.py
+++ b/src/connector/python/tests/test_lines.py
--- a/src/cq/CMakeLists.txt
+++ b/src/cq/CMakeLists.txt
--- a/src/cq/test/CMakeLists.txt
+++ b/src/cq/test/CMakeLists.txt
--- a/src/dnode/CMakeLists.txt
+++ b/src/dnode/CMakeLists.txt
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/kit/CMakeLists.txt
+++ b/src/kit/CMakeLists.txt
--- a/src/kit/shell/CMakeLists.txt
+++ b/src/kit/shell/CMakeLists.txt
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
--- a/src/kit/shell/src/shellCheck.c
+++ b/src/kit/shell/src/shellCheck.c
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
--- a/src/kit/shell/src/shellImport.c
+++ b/src/kit/shell/src/shellImport.c
--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/src/kit/taosdemo/CMakeLists.txt
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
--- a/src/kit/taosdump/CMakeLists.txt
+++ b/src/kit/taosdump/CMakeLists.txt
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
--- a/src/kit/taospack/CMakeLists.txt
+++ b/src/kit/taospack/CMakeLists.txt
--- a/src/kit/taospack/taospack.c
+++ b/src/kit/taospack/taospack.c
--- a/src/mnode/CMakeLists.txt
+++ b/src/mnode/CMakeLists.txt
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
--- a/src/os/CMakeLists.txt
+++ b/src/os/CMakeLists.txt
--- a/src/os/src/darwin/CMakeLists.txt
+++ b/src/os/src/darwin/CMakeLists.txt
--- a/src/os/src/detail/CMakeLists.txt
+++ b/src/os/src/detail/CMakeLists.txt
--- a/src/os/src/detail/osTime.c
+++ b/src/os/src/detail/osTime.c
--- a/src/os/src/linux/CMakeLists.txt
+++ b/src/os/src/linux/CMakeLists.txt
--- a/src/os/src/windows/CMakeLists.txt
+++ b/src/os/src/windows/CMakeLists.txt
--- a/src/os/tests/CMakeLists.txt
+++ b/src/os/tests/CMakeLists.txt
--- a/src/plugins/CMakeLists.txt
+++ b/src/plugins/CMakeLists.txt
--- a/blm3 @ 4bfae86d
+++ b/blm3 @ 4bfae86d
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
--- a/src/plugins/monitor/CMakeLists.txt
+++ b/src/plugins/monitor/CMakeLists.txt
--- a/src/plugins/mqtt/CMakeLists.txt
+++ b/src/plugins/mqtt/CMakeLists.txt
--- a/src/query/CMakeLists.txt
+++ b/src/query/CMakeLists.txt
--- a/src/query/inc/qAggMain.h
+++ b/src/query/inc/qAggMain.h
--- a/src/query/inc/qHistogram.h
+++ b/src/query/inc/qHistogram.h
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/inc/tdigest.h
+++ b/src/query/inc/tdigest.h
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qFilter.c
+++ b/src/query/src/qFilter.c
--- a/src/query/src/qHistogram.c
+++ b/src/query/src/qHistogram.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/query/src/tdigest.c
+++ b/src/query/src/tdigest.c
--- a/src/query/tests/CMakeLists.txt
+++ b/src/query/tests/CMakeLists.txt
--- a/src/query/tests/apercentileTest.cpp
+++ b/src/query/tests/apercentileTest.cpp
--- a/src/query/tests/histogramTest.cpp
+++ b/src/query/tests/histogramTest.cpp
--- a/src/query/tests/unitTest.cpp
+++ b/src/query/tests/unitTest.cpp
--- a/src/rpc/CMakeLists.txt
+++ b/src/rpc/CMakeLists.txt
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
--- a/src/rpc/test/CMakeLists.txt
+++ b/src/rpc/test/CMakeLists.txt
--- a/src/sync/CMakeLists.txt
+++ b/src/sync/CMakeLists.txt
--- a/src/sync/test/CMakeLists.txt
+++ b/src/sync/test/CMakeLists.txt
--- a/src/tfs/CMakeLists.txt
+++ b/src/tfs/CMakeLists.txt
--- a/src/tsdb/CMakeLists.txt
+++ b/src/tsdb/CMakeLists.txt
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
--- a/src/tsdb/src/tsdbCompact.c
+++ b/src/tsdb/src/tsdbCompact.c
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/tsdb/src/tsdbReadImpl.c
+++ b/src/tsdb/src/tsdbReadImpl.c
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
--- a/src/util/inc/tstrbuild.h
+++ b/src/util/inc/tstrbuild.h
--- a/src/util/inc/tutil.h
+++ b/src/util/inc/tutil.h
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
--- a/src/util/src/tref.c
+++ b/src/util/src/tref.c
--- a/src/util/src/tstrbuild.c
+++ b/src/util/src/tstrbuild.c
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
--- a/src/util/tests/CMakeLists.txt
+++ b/src/util/tests/CMakeLists.txt
--- a/src/vnode/CMakeLists.txt
+++ b/src/vnode/CMakeLists.txt
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
--- a/src/wal/CMakeLists.txt
+++ b/src/wal/CMakeLists.txt
--- a/src/wal/test/CMakeLists.txt
+++ b/src/wal/test/CMakeLists.txt
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
--- a/tests/comparisonTest/tdengine/CMakeLists.txt
+++ b/tests/comparisonTest/tdengine/CMakeLists.txt
--- a/tests/connectorTest/C#Test/nanosupport/nanotest.cs
+++ b/tests/connectorTest/C#Test/nanosupport/nanotest.cs
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
--- a/tests/examples/c/asyncdemo.c
+++ b/tests/examples/c/asyncdemo.c
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
--- a/tests/examples/c/epoll.c
+++ b/tests/examples/c/epoll.c
--- a/tests/examples/c/makefile
+++ b/tests/examples/c/makefile
--- a/tests/examples/c/prepare.c
+++ b/tests/examples/c/prepare.c
--- a/tests/examples/c/schemaless.c
+++ b/tests/examples/c/schemaless.c
--- a/tests/examples/c/stream.c
+++ b/tests/examples/c/stream.c
--- a/tests/examples/c/subscribe.c
+++ b/tests/examples/c/subscribe.c
--- a/tests/nettest/TCPUDP.sh
+++ b/tests/nettest/TCPUDP.sh
--- a/tests/pytest/client/taoshellCheckCase.py
+++ b/tests/pytest/client/taoshellCheckCase.py
--- a/tests/pytest/client/twoClients.py
+++ b/tests/pytest/client/twoClients.py
--- a/tests/pytest/client/version.py
+++ b/tests/pytest/client/version.py
--- a/tests/pytest/crash_gen/service_manager.py
+++ b/tests/pytest/crash_gen/service_manager.py
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
--- a/tests/pytest/functions/function_arithmetic.py
+++ b/tests/pytest/functions/function_arithmetic.py
--- a/tests/pytest/functions/function_interp.py
+++ b/tests/pytest/functions/function_interp.py
--- a/tests/pytest/functions/queryTestCases.py
+++ b/tests/pytest/functions/queryTestCases.py
--- a/tests/pytest/insert/boundary2.py
+++ b/tests/pytest/insert/boundary2.py
--- a/tests/pytest/insert/insertJSONPayload.py
+++ b/tests/pytest/insert/insertJSONPayload.py
--- a/tests/pytest/insert/insertTelnetLines.py
+++ b/tests/pytest/insert/insertTelnetLines.py
--- a/tests/pytest/insert/line_insert.py
+++ b/tests/pytest/insert/line_insert.py
--- a/tests/pytest/insert/openTsdbTelnetLinesInsert.py
+++ b/tests/pytest/insert/openTsdbTelnetLinesInsert.py
--- a/tests/pytest/insert/schemalessInsert.py
+++ b/tests/pytest/insert/schemalessInsert.py
--- a/tests/pytest/insert/specialSql.py
+++ b/tests/pytest/insert/specialSql.py
--- a/tests/pytest/insert/verifyMemToDiskCrash.py
+++ b/tests/pytest/insert/verifyMemToDiskCrash.py
--- a/tests/pytest/query/nestedQuery/nestedQuery.py
+++ b/tests/pytest/query/nestedQuery/nestedQuery.py
--- a/tests/pytest/query/nestquery_last_row.py
+++ b/tests/pytest/query/nestquery_last_row.py
--- a/tests/pytest/query/query.py
+++ b/tests/pytest/query/query.py
--- a/tests/pytest/query/queryDiffColsOr.py
+++ b/tests/pytest/query/queryDiffColsOr.py
--- a/tests/pytest/query/queryGroupTbname.py
+++ b/tests/pytest/query/queryGroupTbname.py
--- a/tests/pytest/query/queryTbnameUpperLower.py
+++ b/tests/pytest/query/queryTbnameUpperLower.py
--- a/tests/pytest/query/udf.py
+++ b/tests/pytest/query/udf.py
--- a/tests/pytest/table/create.py
+++ b/tests/pytest/table/create.py
--- a/tests/pytest/tools/insert-interlace.json
+++ b/tests/pytest/tools/insert-interlace.json
--- a/tests/pytest/tools/insert-tblimit-tboffset-createdb.json
+++ b/tests/pytest/tools/insert-tblimit-tboffset-createdb.json
--- a/tests/pytest/tools/insert-tblimit-tboffset-insertrec.json
+++ b/tests/pytest/tools/insert-tblimit-tboffset-insertrec.json
--- a/tests/pytest/tools/insert-tblimit-tboffset.json
+++ b/tests/pytest/tools/insert-tblimit-tboffset.json
--- a/tests/pytest/tools/insert-tblimit-tboffset0.json
+++ b/tests/pytest/tools/insert-tblimit-tboffset0.json
--- a/tests/pytest/tools/insert-tblimit1-tboffset.json
+++ b/tests/pytest/tools/insert-tblimit1-tboffset.json
--- a/tests/pytest/tools/schemalessInsertPerformance.py
+++ b/tests/pytest/tools/schemalessInsertPerformance.py
--- a/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
+++ b/tests/pytest/tools/taosdemoAllTest/TD-4985/query-limit-offset.py
--- a/tests/pytest/tools/taosdemoAllTest/insert-1s1tnt1r.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-1s1tnt1r.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-1s1tntmr.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-1s1tntmr.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-allDataType.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-allDataType.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-disorder.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-disorder.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-N00.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-N00.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-Y00.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-drop-exist-auto-Y00.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-illegal.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-illegal.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-interlace-row.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-interlace-row.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-interval-speed.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-interval-speed.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-newdb.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-newdb.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-newtable.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-newtable.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-nodbnodrop.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-nodbnodrop.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-offset.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-offset.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-renewdb.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-renewdb.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-sample.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-sample.json
--- a/tests/pytest/tools/taosdemoAllTest/insert-timestep.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert-timestep.json
--- a/tests/pytest/tools/taosdemoAllTest/insertBinaryLenLarge16374AllcolLar49151.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertBinaryLenLarge16374AllcolLar49151.json
--- a/tests/pytest/tools/taosdemoAllTest/insertChildTab0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertChildTab0.json
--- a/tests/pytest/tools/taosdemoAllTest/insertChildTabLess0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertChildTabLess0.json
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNum4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNum4096.json
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNumLarge4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsAndTagNumLarge4096.json
--- a/tests/pytest/tools/taosdemoAllTest/insertColumnsNum0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertColumnsNum0.json
--- a/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertInterlaceRowsLarge1M.json
--- a/tests/pytest/tools/taosdemoAllTest/insertMaxNumPerReq.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertMaxNumPerReq.json
--- a/tests/pytest/tools/taosdemoAllTest/insertNumOfrecordPerReq0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertNumOfrecordPerReq0.json
--- a/tests/pytest/tools/taosdemoAllTest/insertNumOfrecordPerReqless0.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertNumOfrecordPerReqless0.json
--- a/tests/pytest/tools/taosdemoAllTest/insertRestful.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertRestful.json
--- a/tests/pytest/tools/taosdemoAllTest/insertSigcolumnsNum4096.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertSigcolumnsNum4096.json
--- a/tests/pytest/tools/taosdemoAllTest/insertTagsNumLarge128.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertTagsNumLarge128.json
--- a/tests/pytest/tools/taosdemoAllTest/insertTimestepMulRowsLargeint16.json
+++ b/tests/pytest/tools/taosdemoAllTest/insertTimestepMulRowsLargeint16.json
--- a/tests/pytest/tools/taosdemoAllTest/insert_5M_rows.json
+++ b/tests/pytest/tools/taosdemoAllTest/insert_5M_rows.json
--- a/tests/pytest/tools/taosdemoAllTest/manual_block1_comp.json
+++ b/tests/pytest/tools/taosdemoAllTest/manual_block1_comp.json
--- a/tests/pytest/tools/taosdemoAllTest/manual_block2.json
+++ b/tests/pytest/tools/taosdemoAllTest/manual_block2.json
--- a/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit1.json
+++ b/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit1.json
--- a/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit5.json
+++ b/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit5.json
--- a/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit94.json
+++ b/tests/pytest/tools/taosdemoAllTest/moredemo-offset-limit94.json
--- a/tests/pytest/tools/taosdemoAllTest/moredemo-offset-newdb.json
+++ b/tests/pytest/tools/taosdemoAllTest/moredemo-offset-newdb.json
--- a/tests/pytest/tools/taosdemoAllTest/query-interrupt.json
+++ b/tests/pytest/tools/taosdemoAllTest/query-interrupt.json
--- a/tests/pytest/tools/taosdemoAllTest/queryInsertdata.json
+++ b/tests/pytest/tools/taosdemoAllTest/queryInsertdata.json
--- a/tests/pytest/tools/taosdemoAllTest/queryInsertrestdata.json
+++ b/tests/pytest/tools/taosdemoAllTest/queryInsertrestdata.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/1174-large-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/1174-large-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/1174-large-taosc.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/1174-large-taosc.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-stmt-random.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-stmt-random.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-taosc.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/1174-small-taosc.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-1s1tnt1r-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-1s1tnt1r-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-1s1tntmr-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-1s1tntmr-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-allDataType-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-allDataType-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-disorder-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-disorder-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-drop-exist-auto-N00-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-drop-exist-auto-N00-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-drop-exist-auto-Y00-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-drop-exist-auto-Y00-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-interlace-row-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-interlace-row-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-interval-speed-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-interval-speed-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-newdb-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-newdb-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-newtable-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-newtable-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-nodbnodrop-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-nodbnodrop-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-offset-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-offset-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-renewdb-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-renewdb-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-sample-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-sample-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insert-timestep-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insert-timestep-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertBinaryLenLarge16374AllcolLar49151-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertBinaryLenLarge16374AllcolLar49151-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertChildTab0-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertChildTab0-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertChildTabLess0-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertChildTabLess0-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertColumnsAndTagNum4096-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertColumnsAndTagNum4096-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertColumnsNum0-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertColumnsNum0-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertInterlaceRowsLarge1M-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertInterlaceRowsLarge1M-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertMaxNumPerReq-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertMaxNumPerReq-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertNumOfrecordPerReq0-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertNumOfrecordPerReq0-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertNumOfrecordPerReqless0-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertNumOfrecordPerReqless0-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertSigcolumnsNum4096-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertSigcolumnsNum4096-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/insertTagsNumLarge128-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/insertTagsNumLarge128-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/stmt/nsertColumnsAndTagNumLarge4096-stmt.json
+++ b/tests/pytest/tools/taosdemoAllTest/stmt/nsertColumnsAndTagNumLarge4096-stmt.json
--- a/tests/pytest/tools/taosdemoAllTest/subInsertdata.json
+++ b/tests/pytest/tools/taosdemoAllTest/subInsertdata.json
--- a/tests/pytest/tools/taosdemoAllTest/subInsertdataMaxsql100.json
+++ b/tests/pytest/tools/taosdemoAllTest/subInsertdataMaxsql100.json
--- a/tests/pytest/tools/taosdemoAllTest/taosdemoTestInsertAllType.py
+++ b/tests/pytest/tools/taosdemoAllTest/taosdemoTestInsertAllType.py
--- a/tests/pytest/tools/taosdumpTest3.py
+++ b/tests/pytest/tools/taosdumpTest3.py
--- a/tests/pytest/tools/taosdumpTestNanoSupport.py
+++ b/tests/pytest/tools/taosdumpTestNanoSupport.py
--- a/tests/pytest/update/bug_td2279.py
+++ b/tests/pytest/update/bug_td2279.py
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
--- a/tests/script/api/makefile
+++ b/tests/script/api/makefile
--- a/tests/script/api/openTSDBTest.c
+++ b/tests/script/api/openTSDBTest.c
--- a/tests/script/api/stmt.c
+++ b/tests/script/api/stmt.c
--- a/tests/script/api/stmt_function.c
+++ b/tests/script/api/stmt_function.c
--- a/tests/script/fullGeneralSuite.sim
+++ b/tests/script/fullGeneralSuite.sim
--- a/tests/script/general/parser/apercentile.sim
+++ b/tests/script/general/parser/apercentile.sim
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
--- a/tests/script/general/parser/interp_blocks.sim
+++ b/tests/script/general/parser/interp_blocks.sim
--- a/tests/script/general/parser/line_insert.sim
+++ b/tests/script/general/parser/line_insert.sim
--- a/tests/script/general/parser/tbnameIn_query.sim
+++ b/tests/script/general/parser/tbnameIn_query.sim
--- a/tests/script/general/parser/tbname_escape.sim
+++ b/tests/script/general/parser/tbname_escape.sim
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
--- a/tests/test/c/CMakeLists.txt
+++ b/tests/test/c/CMakeLists.txt
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c