Merge branch 'develop' into szhou/feature/support-math-functions

.drone.yml

@@ -12,6 +12,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y cmake build-essential 
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. 
@@ -37,6 +38,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y cmake build-essential
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -64,6 +66,7 @@ steps:
   - echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
   - apt-get update 
   - apt-get install -y -qq cmake build-essential
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -89,6 +92,7 @@ steps:
   image: arm64v8/centos:7
   commands:
   - yum install -y gcc gcc-c++ make cmake git
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -114,6 +118,7 @@ steps:
   image: arm64v8/centos:8
   commands:
   - dnf install -y gcc gcc-c++ make cmake epel-release git libarchive
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. -DCPUTYPE=aarch64 > /dev/null
@@ -140,6 +145,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y cmake build-essential
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. -DCPUTYPE=aarch32 > /dev/null
@@ -166,7 +172,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y gcc cmake3 build-essential git binutils-2.26
- 
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. 
@@ -193,6 +199,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y gcc cmake build-essential
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. 
@@ -218,6 +225,7 @@ steps:
   commands:
   - apt-get update
   - apt-get install -y gcc cmake build-essential
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. 
@@ -242,6 +250,7 @@ steps:
   image: ansible/centos7-ansible
   commands:
   - yum install -y gcc gcc-c++ make cmake
+  - git submodule update --init --recursive
   - mkdir debug
   - cd debug
   - cmake .. 

.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

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 
-
+    git submodule update --init --recursive
     export TZ=Asia/Harbin
     date
     git clean -dfx

README.md

@@ -88,6 +88,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:

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
 

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 ()
 

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)

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")
-  SET(TD_BUILD_HTTP FALSE)
+IF (${BUILD_HTTP} MATCHES "true")
+  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()

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 .)

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)

documentation20/cn/00.index/docs.md

@@ -118,6 +118,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)

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

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 )。
 
 ## 客户端和报警模块
 

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 建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得更简单。
 

documentation20/cn/05.insert/docs.md

@@ -183,7 +183,73 @@ use prometheus;
 select * from apiserver_request_latencies_bucket;
 ```
 
-## <a class="anchor" id="telegraf"></a>Telegraf 直接写入
+## <a class="anchor" id="telegraf"></a> Telegraf 直接写入(通过 BLM v3)
+TDengine 新版本（2.3.0.0+）将包含一个 BLM3 独立程序，负责接受其他多种应用的数据写入。
+
+配置方法，假设 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
+```
+apt-get install collectd
+```
+
+在 /etc/collectd/collectd.conf 文件中增加如下内容：
+```
+LoadPlugin network
+<Plugin network>
+  Server "192.168.17.180" "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)。
+
+在 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中的示例，可以参考。
 

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。具体如下： 

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地址。
 

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 时间戳，需要设置正确的时区。
 

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

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**                 |
-| --------------- | ----------------------------- | ----------------------------------------- |
-| >               | larger than                   | **`timestamp`** and all numeric types     |
-| <               | smaller than                  | **`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     |
-| =               | equal to                      | all types                                 |
-| <>              | not equal to                  | all types                                 |
-| is [not] null   | is null or is not null        | all 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` |
-| like            | match a wildcard string       | **`binary`** **`nchar`**                  |
+| **Operation** | **Note**                 | **Applicable Data Types**                 |
+| ------------- | ------------------------ | ----------------------------------------- |
+| >             | larger than              | **`timestamp`** and all numeric types     |
+| <             | smaller than             | **`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     |
+| =             | equal to                 | all types                                 |
+| <>            | not equal to             | all types                                 |
+| is [not] null | is null or is not null   | all 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` |
+| 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。

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 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品落地案例。

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 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品成功落地案例。

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
 

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

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 
-    fi  
+        exit 8
+    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
+echo -e $fin_result
\ No newline at end of file

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*   || :

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   || :

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

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

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!!!"

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}/*          || :

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)
 }

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
-      install_connector
-    fi
-    install_examples
+#    if [ "$pagMode" != "lite" ]; then
+#      install_connector
+#    fi
+#    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
-      install_connector
-    fi
-    install_examples
+#    if [ "$pagMode" != "lite" ]; then
+#      install_connector
+#    fi
+#    install_examples
 
     if [ -z $1 ]; then # install service and client
         # For installing new

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
-            if [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ]; then
+            [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ] &&
                 /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

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

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\
-             ${script_dir}/remove.sh ${script_dir}/set_core.sh ${script_dir}/startPre.sh  ${script_dir}/taosd-dump-cfg.gdb"
+  bin_files="${build_dir}/bin/taosd \
+      ${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

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

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
-examples_dir="${top_dir}/tests/examples"
-cp -r ${examples_dir}/c      ${install_dir}/examples
-sed -i '/passwd/ {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
-  cp -r ${examples_dir}/JDBC   ${install_dir}/examples
-  cp -r ${examples_dir}/matlab ${install_dir}/examples
-  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
-  cp -r ${examples_dir}/python ${install_dir}/examples
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/python/read_example.py
-  cp -r ${examples_dir}/R      ${install_dir}/examples
-  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/R/command.txt
-  cp -r ${examples_dir}/go     ${install_dir}/examples
-  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
-fi
+#mkdir -p ${install_dir}/examples
+#examples_dir="${top_dir}/tests/examples"
+#cp -r ${examples_dir}/c      ${install_dir}/examples
+#sed -i '/passwd/ {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
+#  cp -r ${examples_dir}/JDBC   ${install_dir}/examples
+#  cp -r ${examples_dir}/matlab ${install_dir}/examples
+#  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
+#  cp -r ${examples_dir}/python ${install_dir}/examples
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/python/read_example.py
+#  cp -r ${examples_dir}/R      ${install_dir}/examples
+#  sed -i '/password/ {s/taosdata/prodb/g}'  ${install_dir}/examples/R/command.txt
+#  cp -r ${examples_dir}/go     ${install_dir}/examples
+#  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
+#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"
-mkdir -p ${install_dir}/connector
-if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
-
-  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
-    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
-  else
-    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
-  fi
-  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
-    cp -r ${connector_dir}/go ${install_dir}/connector
-  else
-    echo "WARNING: go connector not found, please check if want to use it!"
-  fi
-  cp -r ${connector_dir}/python  ${install_dir}/connector/
-  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/subscription.py
-
-  sed -i '/self._password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/connection.py
-fi
+#connector_dir="${code_dir}/connector"
+#mkdir -p ${install_dir}/connector
+#if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
+#  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
+
+#  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+#    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+#  else
+#    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
+#  fi
+#  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+#    cp -r ${connector_dir}/go ${install_dir}/connector
+#  else
+#    echo "WARNING: go connector not found, please check if want to use it!"
+#  fi
+#  cp -r ${connector_dir}/python  ${install_dir}/connector/
+#  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/subscription.py
+
+#  sed -i '/self._password/ {s/taosdata/prodb/g}'  ${install_dir}/connector/python/prodb/connection.py
+#fi
 
 cd ${release_dir}
 

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

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}/taoserror.h ${inc_link_dir}/taoserror.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
 }
 
 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                    
-    ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+    # Write the local FQDN to configuration file
+    ${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                    
-          ${csudo} sed -i -r "s/#*\s*(fqdn\s*).*/\1$localFqdn/" ${cfg_install_dir}/taos.cfg    
+          # Write the local FQDN to configuration file
+          ${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
-	    if [ ! -n "$input" ]; then
-       set_hostname
-       break
-      else
-	      case $input in
-	        [yY][eE][sS]|[yY])
-          set_hostname
-          break
-			    ;;
-        
-	        [nN][oO]|[nN])
-			    set_ipAsFqdn
-			    break   	
-			    ;;
-        
-	        *)
-			    echo "Invalid input..."
-			    ;;
-	      esac
-	    fi
+        read -r -p "Set hostname now? [Y/n] " input
+        if [ ! -n "$input" ]; then
+            set_hostname
+            break
+        else
+            case $input in
+            [yY][eE][sS]|[yY])
+                set_hostname
+                break
+                ;;
+
+            [nN][oO]|[nN])
+                set_ipAsFqdn
+                break
+                ;;
+
+            *)
+                echo "Invalid input..."
+                ;;
+            esac
+        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;
-	fi
-	while true; do
+        read firstEp;
+    fi
+    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                    
-            ${csudo} sed -i -r "s/#*\s*(firstEp\s*).*/\1$firstEp/" ${cfg_install_dir}/taos.cfg    
+            # Write the first FQDN to configuration file
+            ${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                    
-                email_file="${install_main_dir}/email" 
+                # Write the email address to temp file
+                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}"
-	    else
-	      echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
-	    fi
-	    echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+           echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+      else
+          echo -e "${GREEN_DARK}To access TDengine    ${NC}: taos -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+      fi
+      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}"
 }

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
 

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"	
-   	 	if [ -d ${install_nginxd_dir} ]; then
-   	    if systemctl is-active --quiet ${nginx_service_name}; then
-   	      echo "Nginx for TDengine is running, stopping it..."
-   	      ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null
-   	    fi
-   	    ${csudo} systemctl disable ${nginx_service_name} &> /dev/null || echo &> /dev/null
-   	    ${csudo} rm -f ${nginx_service_config}
-   	  fi
-    fi 
+        nginx_service_config="${service_config_dir}/${nginx_service_name}.service"
+        if [ -d ${install_nginxd_dir} ]; then
+            if systemctl is-active --quiet ${nginx_service_name}; then
+                echo "Nginx for TDengine is running, stopping it..."
+                ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null
+            fi
+            ${csudo} systemctl disable ${nginx_service_name} &> /dev/null || echo &> /dev/null
+            ${csudo} rm -f ${nginx_service_config}
+        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 [ -e ${service_config_dir}/taosd ]; then 
+
+    if ((${initd_mod}==1)); 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   
-      if [ -e ${service_config_dir}/taosd ]; then 
+    elif ((${initd_mod}==2)); 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  
-      if [ -e ${service_config_dir}/taosd ]; then 
+    elif ((${initd_mod}==3)); 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

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 &

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
 

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;
 

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,14 +41,19 @@ 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 {
@@ -55,6 +64,8 @@ typedef enum {
 
 typedef struct {
   uint64_t id;
+  SMLProtocolType protocol;
+  SMLTimeStampType tsType;
   SHashObj* smlDataToSchema;
 } SSmlLinesInfo;
 
@@ -66,15 +77,18 @@ bool isValidFloat(char *str);
 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);
-int taos_insert_telnet_lines(TAOS* taos, char* lines[], int numLines);
-int taos_insert_json_payload(TAOS* taos, char* payload);
+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

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);
 
 
 

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

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);

src/client/src/TSDBJNIConnector.c

@@ -1071,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_schemaless_insert(taos, c_lines, numLines, SML_LINE_PROTOCOL);
+  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));

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

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;

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) {

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;
       }
 

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);

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;