diff --git a/.gitignore b/.gitignore
index e6e327327c2a72bc2262d9b2923314c950c78cf6..b400d719cc967fd4c1270355f876bd3c39cfc2f3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -79,3 +79,15 @@ tests/comparisonTest/opentsdb/opentsdbtest/.settings/
tests/examples/JDBC/JDBCDemo/.classpath
tests/examples/JDBC/JDBCDemo/.project
tests/examples/JDBC/JDBCDemo/.settings/
+
+# Emacs
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+TAGS
diff --git a/.gitmodules b/.gitmodules
index 156226d54486c17e64b9c514e47e3a7dc3fe6942..74afbbf9973abec6423633b848181b349de4ed6f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,9 +4,9 @@
[submodule "src/connector/grafanaplugin"]
path = src/connector/grafanaplugin
url = https://github.com/taosdata/grafanaplugin
+[submodule "src/connector/hivemq-tdengine-extension"]
+ path = src/connector/hivemq-tdengine-extension
+ url = https://github.com/huskar-t/hivemq-tdengine-extension.git
[submodule "tests/examples/rust"]
path = tests/examples/rust
url = https://github.com/songtianyi/tdengine-rust-bindings.git
-[submodule "src/connector/hivemq-tdengine-extension"]
- path = src/connector/hivemq-tdengine-extension
- url = https://github.com/huskar-t/hivemq-tdengine-extension.git
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a55b5fbed97c08117f23488cf3e0d60b894316e7..7bb36fe1b001473cf5641ad195959581affeb2cb 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
IF (CMAKE_VERSION VERSION_LESS 3.0)
PROJECT(TDengine CXX)
SET(PROJECT_VERSION_MAJOR "${LIB_MAJOR_VERSION}")
diff --git a/Jenkinsfile b/Jenkinsfile
index 6b3d9e51510ce10d38bd49a56a63e9859e5cd691..7a3da2b3a0a33e27c0dccc5126fdac13336f1356 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -5,7 +5,7 @@ node {
git url: 'https://github.com/taosdata/TDengine.git'
}
-def kipstage=0
+def skipstage=0
def abortPreviousBuilds() {
def currentJobName = env.JOB_NAME
def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@@ -80,25 +80,29 @@ pipeline {
}
steps {
sh'''
- cd ${WORKSPACE}
+ cp -r ${WORKSPACE} ${WORKSPACE}.tes
+ cd ${WORKSPACE}.tes
git checkout develop
git pull
git fetch origin +refs/pull/${CHANGE_ID}/merge
git checkout -qf FETCH_HEAD
'''
script{
- skipstage=sh(script:"git --no-pager diff --name-only FETCH_HEAD develop|grep -v -E '.*md|//src//connector|Jenkinsfile|test-all.sh' || echo 1 ",returnStdout:true)
+ env.skipstage=sh(script:"cd ${WORKSPACE}.tes && git --no-pager diff --name-only FETCH_HEAD develop|grep -v -E '.*md|//src//connector|Jenkinsfile|test-all.sh' || echo 0 ",returnStdout:true)
}
+ println env.skipstage
+ sh'''
+ rm -rf ${WORKSPACE}.tes
+ '''
}
}
stage('Parallel test stage') {
-
//only build pr
when {
changeRequest()
expression {
- skipstage != 1
+ env.skipstage != 0
}
}
parallel {
@@ -124,12 +128,12 @@ pipeline {
pre_test()
timeout(time: 45, unit: 'MINUTES'){
- sh '''
- date
- cd ${WKC}/tests
- find pytest -name '*'sql|xargs rm -rf
- ./test-all.sh p2
- date'''
+ sh '''
+ date
+ cd ${WKC}/tests
+ find pytest -name '*'sql|xargs rm -rf
+ ./test-all.sh p2
+ date'''
}
}
}
@@ -161,6 +165,7 @@ pipeline {
stage('test_crash_gen_s3') {
agent{label "b2"}
+
steps {
pre_test()
catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
@@ -169,20 +174,22 @@ pipeline {
./crash_gen.sh -a -p -t 4 -s 2000
'''
}
- catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+
+ sh '''
+ cd ${WKC}/tests/pytest
+ rm -rf /var/lib/taos/*
+ rm -rf /var/log/taos/*
+ ./handle_crash_gen_val_log.sh
+ '''
+ timeout(time: 45, unit: 'MINUTES'){
sh '''
- cd ${WKC}/tests/pytest
- ./handle_crash_gen_val_log.sh
+ date
+ cd ${WKC}/tests
+ ./test-all.sh b2fq
+ date
'''
- }
- timeout(time: 45, unit: 'MINUTES'){
- sh '''
- date
- cd ${WKC}/tests
- ./test-all.sh b2fq
- date
- '''
- }
+ }
+
}
}
@@ -216,6 +223,8 @@ pipeline {
date
cd ${WKC}/tests
./test-all.sh b4fq
+ cd ${WKC}/tests
+ ./test-all.sh p4
date'''
}
}
diff --git a/cmake/install.inc b/cmake/install.inc
index 2f0404334c06125e6ee8241ab91b22064ab20b89..ec0ec645198772d892461da64c1eaa2bc947f72c 100755
--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
#INSTALL(TARGETS taos RUNTIME DESTINATION driver)
#INSTALL(TARGETS shell RUNTIME DESTINATION .)
IF (TD_MVN_INSTALLED)
- INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.18-dist.jar DESTINATION connector/jdbc)
+ INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.19-dist.jar DESTINATION connector/jdbc)
ENDIF ()
ELSEIF (TD_DARWIN)
SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
diff --git a/cmake/version.inc b/cmake/version.inc
index 07356bb2161bde20a2e6e0c9588a15cf2fb11b10..962f1f60406f3657a379ee99427e110985988c44 100755
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
IF (DEFINED VERNUMBER)
SET(TD_VER_NUMBER ${VERNUMBER})
ELSE ()
- SET(TD_VER_NUMBER "2.0.14.0")
+ SET(TD_VER_NUMBER "2.0.16.0")
ENDIF ()
IF (DEFINED VERCOMPATIBLE)
diff --git a/deps/CMakeLists.txt b/deps/CMakeLists.txt
index a4db6fd5fbc3e867cd30d2a1c871e48a7bfbd5eb..cfc17442f5c21c2d002ba42c45ce523c80eb957f 100644
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
ADD_SUBDIRECTORY(zlib-1.2.11)
diff --git a/deps/MQTT-C/CMakeLists.txt b/deps/MQTT-C/CMakeLists.txt
index 36ede467acfa05f893cbe99ed518458d57986c79..15b35525210ec90e6e2efbdcd0e6128cb4d34f91 100644
--- a/deps/MQTT-C/CMakeLists.txt
+++ b/deps/MQTT-C/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
# MQTT-C build options
option(MQTT_C_OpenSSL_SUPPORT "Build MQTT-C with OpenSSL support?" OFF)
diff --git a/deps/MsvcLibX/CMakeLists.txt b/deps/MsvcLibX/CMakeLists.txt
index c02e4c7a4d89cdf657756ec9786d5a624419d182..4428579e1c098425c9d72d7d58a5fda15cd34c93 100644
--- a/deps/MsvcLibX/CMakeLists.txt
+++ b/deps/MsvcLibX/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/deps/iconv/CMakeLists.txt b/deps/iconv/CMakeLists.txt
index f26f109735ee81bc999b9539185ce60ccb976bfd..286070fa9071f8fcd1949850cec87c1ced3245d7 100644
--- a/deps/iconv/CMakeLists.txt
+++ b/deps/iconv/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/deps/libcurl/lib/win64/libcurl_a.lib b/deps/libcurl/lib/win64/libcurl_a.lib
new file mode 100644
index 0000000000000000000000000000000000000000..69e9fe0a57ef49b3b95cbd369fed95ef885efb95
Binary files /dev/null and b/deps/libcurl/lib/win64/libcurl_a.lib differ
diff --git a/deps/pthread/CMakeLists.txt b/deps/pthread/CMakeLists.txt
index dcd9ed035814ac9efd66340b58b287ccbabe61df..04e5be7472a9b8cbdb384348697b919bf2dd0ece 100644
--- a/deps/pthread/CMakeLists.txt
+++ b/deps/pthread/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/deps/regex/CMakeLists.txt b/deps/regex/CMakeLists.txt
index c7e983b992fe8a2dd21b8420e652358976663a37..054b093d07c386d7ff9b0ffc4c05909d79b33129 100644
--- a/deps/regex/CMakeLists.txt
+++ b/deps/regex/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/deps/wepoll/CMakeLists.txt b/deps/wepoll/CMakeLists.txt
index a8b34112215fae0df7bcac034622015fd72d337b..a81fd782bbc4b05a1158273a7fcc6701bc4d980d 100644
--- a/deps/wepoll/CMakeLists.txt
+++ b/deps/wepoll/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/deps/zlib-1.2.11/CMakeLists.txt b/deps/zlib-1.2.11/CMakeLists.txt
index a8750471d694bcfa98b711348861449e3fc7b23a..f83aa70085491fb6575c0a6bf93252192cddd040 100644
--- a/deps/zlib-1.2.11/CMakeLists.txt
+++ b/deps/zlib-1.2.11/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
IF (TD_WINDOWS)
diff --git a/documentation20/cn/00.index/docs.md b/documentation20/cn/00.index/docs.md
new file mode 100644
index 0000000000000000000000000000000000000000..3c991547e7a7ccaf3701da6186c40b3ec6044ebf
--- /dev/null
+++ b/documentation20/cn/00.index/docs.md
@@ -0,0 +1,151 @@
+# TDengine文档
+
+TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](/architecture) 与 [数据建模](/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。如需查阅TDengine 1.6 文档，请点击 [这里](https://www.taosdata.com/cn/documentation16/) 访问。
+
+## [TDengine介绍](/evaluation)
+
+* [TDengine 简介及特色](/evaluation#intro)
+* [TDengine 适用场景](/evaluation#scenes)
+* [TDengine 性能指标介绍和验证方法](/evaluation#)
+
+## [立即开始](/getting-started)
+
+* [快捷安装](/getting-started#install)：可通过源码、安装包或docker安装，三秒钟搞定
+* [轻松启动](/getting-started#start)：使用systemctl 启停TDengine
+* [命令行程序TAOS](/getting-started#console)：访问TDengine的简便方式
+* [极速体验](/getting-started#demo)：运行示例程序，快速体验高效的数据插入、查询
+* [支持平台列表](/getting-started#platforms)：TDengine服务器和客户端支持的平台列表
+
+## [整体架构](/architecture)
+
+* [数据模型](/architecture#model)：关系型数据库模型，但要求每个采集点单独建表
+* [集群与基本逻辑单元](/architecture#cluster)：吸取NoSQL优点，支持水平扩展，支持高可靠
+* [存储模型与数据分区、分片](/architecture#sharding)：标签数据与时序数据完全分离，按vnode和时间两个维度对数据切分
+* [数据写入与复制流程](/architecture#replication)：先写入WAL、之后写入缓存，再给应用确认，支持多副本
+* [缓存与持久化](/architecture#persistence)：最新数据缓存在内存中，但落盘时采用列式存储、超高压缩比
+* [数据查询](/architecture#query)：支持各种函数、时间轴聚合、插值、多表聚合
+
+## [数据建模](/model)
+
+* [创建库](/model#create-db)：为具有相似数据特征的数据采集点创建一个库
+* [创建超级表](/model#create-stable)：为同一类型的数据采集点创建一个超级表
+* [创建表](/model#create-table)：使用超级表做模板，为每一个具体的数据采集点单独建表
+
+## [高效写入数据](/insert)
+
+* [SQL写入](/insert#sql)：使用SQL insert命令向一张或多张表写入单条或多条记录
+* [Prometheus写入](/insert#prometheus)：配置Prometheus, 不用任何代码，将数据直接写入
+* [Telegraf写入](/insert#telegraf)：配置Telegraf, 不用任何代码，将采集数据直接写入
+* [EMQ X Broker](/insert#emq)：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
+* [HiveMQ Broker](/insert#hivemq)：配置HiveMQ，不用任何代码，就可将MQTT数据直接写入
+
+## [高效查询数据](/queries)
+
+* [主要查询功能](/queries#queries)：支持各种标准函数，设置过滤条件，时间段查询
+* [多表聚合查询](/queries#aggregation)：使用超级表，设置标签过滤条件，进行高效聚合查询
+* [降采样查询值](/queries#sampling)：按时间段分段聚合，支持插值
+
+## [高级功能](/advanced-features)
+
+* [连续查询(Continuous Query)](/advanced-features#continuous-query)：基于滑动窗口，定时自动的对数据流进行查询计算
+* [数据订阅(Publisher/Subscriber)](/advanced-features#subscribe)：象典型的消息队列，应用可订阅接收到的最新数据
+* [缓存(Cache)](/advanced-features#cache)：每个设备最新的数据都会缓存在内存中，可快速获取
+* [报警监测](/advanced-features#alert)：根据配置规则，自动监测超限行为数据，并主动推送
+
+## [连接器](/connector)
+
+* [C/C++ Connector](/connector#c-cpp)：通过libtaos客户端的库，连接TDengine服务器的主要方法
+* [Java Connector(JDBC)](/connector/java)：通过标准的JDBC API，给Java应用提供到TDengine的连接
+* [Python Connector](/connector#python)：给Python应用提供一个连接TDengine服务器的驱动
+* [RESTful Connector](/connector#restful)：提供一最简单的连接TDengine服务器的方式
+* [Go Connector](/connector#go)：给Go应用提供一个连接TDengine服务器的驱动
+* [Node.js Connector](/connector#nodejs)：给node应用提供一个连接TDengine服务器的驱动
+* [C# Connector](/connector#csharp)：给C#应用提供一个连接TDengine服务器的驱动
+* [Windows客户端](https://www.taosdata.com/blog/2019/07/26/514.html)：自行编译windows客户端，Windows环境的各种连接器都需要它
+
+## [与其他工具的连接](/connections)
+
+* [Grafana](/connections#grafana)：获取并可视化保存在TDengine的数据
+* [Matlab](/connections#matlab)：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
+* [R](/connections#r)：通过配置R的JDBC数据源访问保存在TDengine的数据
+* [IDEA Database](https://www.taosdata.com/blog/2020/08/27/1767.html)：通过IDEA 数据库管理工具可视化使用 TDengine
+
+## [TDengine集群的安装、管理](/cluster)
+
+* [准备工作](/cluster#prepare)：部署环境前的几点注意事项
+* [创建第一个节点](/cluster#node-one)：与快捷安装完全一样，非常简单
+* [创建后续节点](/cluster#node-other)：配置新节点的taos.cfg, 在现有集群添加新的节点
+* [节点管理](/cluster#management)：增加、删除、查看集群的节点
+* [Vnode 的高可用性](/cluster#high-availability)：通过多副本的机制来提供 Vnode 的高可用性
+* [Mnode 的管理](/cluster#mnode)：系统自动创建、无需任何人工干预
+* [负载均衡](/cluster#load-balancing)：一旦节点个数或负载有变化，自动进行
+* [节点离线处理](/cluster#offline)：节点离线超过一定时长，将从集群中剔除
+* [Arbitrator](/cluster#arbitrator)：对于偶数个副本的情形，使用它可以防止split brain
+
+## [TDengine的运营和维护](/administrator)
+
+* [容量规划](/administrator#planning)：根据场景，估算硬件资源
+* [容错和灾备](/administrator#tolerance)：设置正确的WAL和数据副本数
+* [系统配置](/administrator#config)：端口，缓存大小，文件块大小和其他系统配置
+* [用户管理](/administrator#user)：添加、删除TDengine用户，修改用户密码
+* [数据导入](/administrator#import)：可按脚本文件导入，也可按数据文件导入
+* [数据导出](/administrator#export)：从shell按表导出，也可用taosdump工具做各种导出
+* [系统监控](/administrator#status)：检查系统现有的连接、查询、流式计算，日志和事件等
+* [文件目录结构](/administrator#directories)：TDengine数据文件、配置文件等所在目录
+* [参数限制与保留关键字](/administrator#keywords)：TDengine的参数限制与保留关键字列表
+
+## [TAOS SQL](/taos-sql)
+
+* [支持的数据类型](/taos-sql#data-type)：支持时间戳、整型、浮点型、布尔型、字符型等多种数据类型
+* [数据库管理](/taos-sql#management)：添加、删除、查看数据库
+* [表管理](/taos-sql#table)：添加、删除、查看、修改表
+* [超级表管理](/taos-sql#super-table)：添加、删除、查看、修改超级表
+* [标签管理](/taos-sql#tags)：增加、删除、修改标签
+* [数据写入](/taos-sql#insert)：支持单表单条、多条、多表多条写入，支持历史数据写入
+* [数据查询](/taos-sql#select)：支持时间段、值过滤、排序、查询结果手动分页等
+* [SQL函数](/taos-sql#functions)：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
+* [时间维度聚合](/taos-sql#aggregation)：将表中数据按照时间段进行切割后聚合，降维处理
+* [边界限制](/taos-sql#limitation)：库、表、SQL等边界限制条件
+* [错误码](/taos-sql/error-code)：TDengine 2.0 错误码以及对应的十进制码
+
+## TDengine的技术设计
+
+* [系统模块](/architecture/taosd)：taosd的功能和模块划分
+* [数据复制](/architecture/replica)：支持实时同步、异步复制，保证系统的High Availibility
+* [技术博客](https://www.taosdata.com/cn/blog/?categories=3)：更多的技术分析和架构设计文章
+
+## 常用工具
+
+* [TDengine样例导入工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
+* [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
+* [IDEA数据库管理工具可视化使用TDengine](https://www.taosdata.com/blog/2020/08/27/1767.html)
+
+## TDengine与其他数据库的对比测试
+
+* [用InfluxDB开源的性能测试工具对比InfluxDB和TDengine](https://www.taosdata.com/blog/2020/01/13/1105.html)
+* [TDengine与OpenTSDB对比测试](https://www.taosdata.com/blog/2019/08/21/621.html)
+* [TDengine与Cassandra对比测试](https://www.taosdata.com/blog/2019/08/14/573.html)
+* [TDengine与InfluxDB对比测试](https://www.taosdata.com/blog/2019/07/19/419.html)
+* [TDengine与InfluxDB、OpenTSDB、Cassandra、MySQL、ClickHouse等数据库的对比测试报告](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)
+
+## 物联网大数据
+
+* [物联网、工业互联网大数据的特点](https://www.taosdata.com/blog/2019/07/09/105.html)
+* [物联网大数据平台应具备的功能和特点](https://www.taosdata.com/blog/2019/07/29/542.html)
+* [通用大数据架构为什么不适合处理物联网数据？](https://www.taosdata.com/blog/2019/07/09/107.html)
+* [物联网、车联网、工业互联网大数据平台，为什么推荐使用TDengine？](https://www.taosdata.com/blog/2019/07/09/109.html)
+
+## 培训和FAQ
+
+* [FAQ：常见问题与答案](/faq)
+* [技术公开课：开源、高效的物联网大数据平台，TDengine内核技术剖析](https://www.taosdata.com/blog/2020/12/25/2126.html)
+* [TDengine视频教程-快速上手](https://www.taosdata.com/blog/2020/11/11/1941.html)
+* [TDengine视频教程-数据建模](https://www.taosdata.com/blog/2020/11/11/1945.html)
+* [TDengine视频教程-集群搭建](https://www.taosdata.com/blog/2020/11/11/1961.html)
+* [TDengine视频教程-Go Connector](https://www.taosdata.com/blog/2020/11/11/1951.html)
+* [TDengine视频教程-JDBC Connector](https://www.taosdata.com/blog/2020/11/11/1955.html)
+* [TDengine视频教程-NodeJS Connector](https://www.taosdata.com/blog/2020/11/11/1957.html)
+* [TDengine视频教程-Python Connector](https://www.taosdata.com/blog/2020/11/11/1963.html)
+* [TDengine视频教程-RESTful Connector](https://www.taosdata.com/blog/2020/11/11/1965.html)
+* [TDengine视频教程-“零”代码运维监控](https://www.taosdata.com/blog/2020/11/11/1959.html)
+* [应用案例：一些使用实例来解释如何使用TDengine](https://www.taosdata.com/cn/blog/?categories=4)
diff --git a/documentation20/webdocs/markdowndocs/Evaluation-ch.md b/documentation20/cn/01.evaluation/docs.md
similarity index 97%
rename from documentation20/webdocs/markdowndocs/Evaluation-ch.md
rename to documentation20/cn/01.evaluation/docs.md
index fa6cec6e488d144a7009dc52772987380d5065da..0ae2106ff2a63696dc8bbc51d25bbf5e811ef561 100644
--- a/documentation20/webdocs/markdowndocs/Evaluation-ch.md
+++ b/documentation20/cn/01.evaluation/docs.md
@@ -1,6 +1,6 @@
# TDengine 介绍
-## TDengine 简介
+## TDengine 简介
TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
@@ -15,10 +15,11 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
- 
+
图 1. TDengine技术生态图
-## TDengine 总体适用场景
+
+## TDengine 总体适用场景
作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
diff --git a/documentation20/webdocs/markdowndocs/Getting Started-ch.md b/documentation20/cn/02.getting-started/docs.md
similarity index 91%
rename from documentation20/webdocs/markdowndocs/Getting Started-ch.md
rename to documentation20/cn/02.getting-started/docs.md
index b8b298b9501a43396e134eb1efa9ba6e6a029b79..c9c82942f3bd47fa774636dd5cf7c5b33f879209 100644
--- a/documentation20/webdocs/markdowndocs/Getting Started-ch.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -1,10 +1,10 @@
# 立即开始
-## 快捷安装
+## 快捷安装
TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、mac OS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。
-### 通过源码安装
+### 通过源码安装
请参考我们的[TDengine github主页](https://github.com/taosdata/TDengine)下载源码并安装.
@@ -12,17 +12,15 @@ TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版
请参考[TDengine官方Docker镜像的发布、下载和使用](https://www.taosdata.com/blog/2020/05/13/1509.html)
-### 通过安装包安装
+### 通过安装包安装
TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。服务端安装包包含客户端和连接器，我们提供三种安装包，您可以根据需要选择：
-- TDengine-server-2.0.10.0-Linux-x64.rpm (4.2M)
-- TDengine-server-2.0.10.0-Linux-x64.deb (2.7M)
-- TDengine-server-2.0.10.0-Linux-x64.tar.gz (4.5M)
+安装包下载在[这里](https://www.taosdata.com/cn/getting-started/#通过安装包安装)。
-具体的安装过程，请参见TDengine多种安装包的安装和卸载以及视频教程。
+具体的安装过程，请参见[TDengine多种安装包的安装和卸载](https://www.taosdata.com/blog/2019/08/09/566.html)以及[视频教程](https://www.taosdata.com/blog/2020/11/11/1941.html)。
-## 轻松启动
+## 轻松启动
安装成功后，用户可使用`systemctl`命令来启动TDengine的服务进程。
@@ -52,8 +50,7 @@ $ systemctl status taosd
如果系统中不支持systemd，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
-
-## TDengine命令行程序
+## TDengine命令行程序
执行TDengine命令行程序，您只要在Linux终端执行`taos`即可。
@@ -61,7 +58,7 @@ $ systemctl status taosd
$ taos
```
-如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
+如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/documentation/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
```cmd
taos>
@@ -117,7 +114,8 @@ taos> source ;
- ctrl+c 中止正在进行中的查询
- 执行`RESET QUERY CACHE`清空本地缓存的表的schema
-## TDengine 极速体验
+
+## TDengine 极速体验
启动TDengine的服务，在Linux终端执行taosdemo
@@ -164,7 +162,6 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
**Note:** taosdemo命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help`详细列出。您可以设置不同参数进行体验。
-
## 客户端和报警模块
如果客户端和服务端运行在不同的电脑上，可以单独安装客户端。Linux和Windows安装包如下：
@@ -178,8 +175,7 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
- TDengine-alert-2.0.10.0-Linux-x64.tar.gz (8.1M)
-
-## 支持平台列表
+## 支持平台列表
### TDengine服务器支持的平台列表
@@ -220,5 +216,5 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
-请跳转到 [连接器 ](https://www.taosdata.com/cn/documentation/connector)查看更详细的信息。
+请跳转到 [连接器](https://www.taosdata.com/cn/documentation/connector)查看更详细的信息。
diff --git a/documentation20/webdocs/markdowndocs/taosd-ch.md b/documentation20/cn/03.architecture/01.taosd/docs.md
similarity index 97%
rename from documentation20/webdocs/markdowndocs/taosd-ch.md
rename to documentation20/cn/03.architecture/01.taosd/docs.md
index 08be0c163e7076b58f03ff8ea3165e902a80fe64..66d51ed2dc2ea1546ab167cad680c20b3fa9729c 100644
--- a/documentation20/webdocs/markdowndocs/taosd-ch.md
+++ b/documentation20/cn/03.architecture/01.taosd/docs.md
@@ -3,9 +3,10 @@
逻辑上，TDengine系统包含dnode, taosc和App，dnode是服务器侧执行代码taosd的一个运行实例，因此taosd是TDengine的核心，本文对taosd的设计做一简单的介绍，模块内的实现细节请见其他文档。
## 系统模块图
+
taosd包含rpc, dnode, vnode, tsdb, query, cq, sync, wal, mnode, http, monitor等模块，具体如下图：
- 
+
taosd的启动入口是dnode模块，dnode然后启动其他模块，包括可选配置的http, monitor模块。taosc或dnode之间交互的消息都是通过rpc模块进行，dnode模块根据接收到的消息类型，将消息分发到vnode或mnode的消息队列，或由dnode模块自己消费。dnode的工作线程(worker)消费消息队列里的消息，交给mnode或vnode进行处理。下面对各个模块做简要说明。
@@ -40,13 +41,14 @@ RPC模块还提供数据压缩功能，如果数据包的字节数超过系统
taosd的消息消费由dnode通过读写线程池进行控制，是系统的中枢。该模块内的结构体图如下：
- 
+
## VNODE模块
vnode是一独立的数据存储查询逻辑单元，但因为一个vnode只能容许一个DB，因此vnode内部没有account, DB, user等概念。为实现更好的模块化、封装以及未来的扩展，它有很多子模块，包括负责存储的TSDB，负责查询的Query, 负责数据复制的sync，负责数据库日志的的wal, 负责连续查询的cq(continuous query), 负责事件触发的流计算的event等模块，这些子模块只与vnode模块发生关系，与其他模块没有任何调用关系。模块图如下：
- 
+
+
vnode模块向下，与dnodeVRead，dnodeVWrite发生互动，向上，与子模块发生互动。它主要的功能有：
- 协调各个子模块的互动。各个子模块之间都不直接调用，都需要通过vnode模块进行；
@@ -68,30 +70,37 @@ mnode是整个系统的大脑，负责整个系统的资源调度，负责meta d
mnode里还负责account, user, DB, stable, table, vgroup, dnode的创建、删除与更新。mnode不仅把这些entity的meta data保存在内存，还做持久化存储。但为节省内存，各个表的标签值不保存在mnode（保存在vnode)，而且子表不维护自己的schema, 而是与stable共享。为减小mnode的查询压力，taosc会缓存table、stable的schema。对于查询类的操作，各个slave mnode也可以提供，以减轻master压力。
## TSDB模块
+
TSDB模块是VNODE中的负责快速高并发地存储和读取属于该VNODE的表的元数据及采集的时序数据的引擎。除此之外，TSDB还提供了表结构的修改、表标签值的修改等功能。TSDB提供API供VNODE和Query等模块调用。TSDB中存储了两类数据，1：元数据信息；2：时序数据
### 元数据信息
+
TSDB中存储的元数据包含属于其所在的VNODE中表的类型，schema的定义等。对于超级表和超级表下的子表而言，又包含了tag的schema定义以及子表的tag值等。对于元数据信息而言，TSDB就相当于一个全内存的KV型数据库，属于该VNODE的表对象全部在内存中，方便快速查询表的信息。除此之外，TSDB还对其中的子表，按照tag的第一列取值做了全内存的索引，大大加快了对于标签的过滤查询。TSDB中的元数据的最新状态在落盘时，会以追加（append-only）的形式，写入到meta文件中。meta文件只进行追加操作，即便是元数据的删除，也会以一条记录的形式写入到文件末尾。TSDB也提供了对于元数据的修改操作，如表schema的修改，tag schema的修改以及tag值的修改等。
### 时序数据
+
每个TSDB在创建时，都会事先分配一定量的内存缓冲区，且内存缓冲区的大小可配可修改。表采集的时序数据，在写入TSDB时，首先以追加的方式写入到分配的内存缓冲区中，同时建立基于时间戳的内存索引，方便快速查询。当内存缓冲区的数据积累到一定的程度时（达到内存缓冲区总大小的1/3），则会触发落盘操作，将缓冲区中的数据持久化到硬盘文件上。时序数据在内存缓冲区中是以行（row）的形式存储的。
而时序数据在写入到TSDB的数据文件时，是以列（column）的形式存储的。TSDB中的数据文件包含多个数据文件组，每个数据文件组中又包含.head、.data和.last三个文件，如（v2f1801.head、v2f1801.data、v2f1801.last）数据文件组。TSDB中的数据文件组是按照时间跨度进行分片的，默认是10天一个文件组，且可通过配置文件及建库选项进行配置。分片的数据文件组又按照编号递增排列，方便快速定位某一时间段的时序数据，高效定位数据文件组。时序数据在TSDB的数据文件中是以块的形式进行列式存储的，每个块中只包含一张表的数据，且数据在一个块中是按照时间顺序递增排列的。在一个数据文件组中，.head文件负责存储数据块的索引及统计信息，如每个块的位置，压缩算法，时间戳范围等。存储在.head文件中一张表的索引信息是按照数据块中存储的数据的时间递增排列的，方便进行折半查找等工作。.head和.last文件是存储真实数据块的文件，若数据块中的数据累计到一定程度，则会写入.data文件中，否则，会写入.last文件中，等待下次落盘时合并数据写入.data文件中，从而大大减少文件中块的个数，避免数据的过度碎片化。
## Query模块
+
该模块负责整体系统的查询处理。客户端调用该该模块进行SQL语法解析，并将查询或写入请求发送到vnode，同时负责针对超级表的查询进行二阶段的聚合操作。在Vnode端，该模块调用TSDB模块读取系统中存储的数据进行查询处理。Query模块还定义了系统能够支持的全部查询函数，查询函数的实现机制与查询框架无耦合，可以在不修改查询流程的情况下动态增加查询函数。详细的设计请参见《TDengine 2.0查询模块设计》。
## SYNC模块
+
该模块实现数据的多副本复制，包括vnode与mnode的数据复制，支持异步和同步两种复制方式，以满足meta data与时序数据不同复制的需求。因为它为mnode与vnode共享，系统为mnode副本预留了一个特殊的vgroup ID:1。因此vnode group的ID是从2开始的。
-每个vnode/mnode模块实例会有一对应的sync模块实例，他们是一一对应的。详细设计请见TDengine 2.0 数据复制模块设计
+每个vnode/mnode模块实例会有一对应的sync模块实例，他们是一一对应的。详细设计请见[TDengine 2.0 数据复制模块设计](https://www.taosdata.com/cn/documentation/architecture/replica/)
## WAL模块
+
该模块负责将新插入的数据写入write ahead log(WAL), 为vnode, mnode共享。以保证服务器crash或其他故障，能从WAL中恢复数据。
每个vnode/mnode模块实例会有一对应的wal模块实例，是完全一一对应的。WAL的落盘操作由两个参数walLevel, fsync控制。看具体场景，如果要100%保证数据不会丢失，需要将walLevel配置为2，fsync设置为0，每条数据插入请求，都会实时落盘后，才会给应用确认
## HTTP模块
+
该模块负责处理系统对外的RESTful接口，可以通过配置，由dnode启动或停止。
该模块将接收到的RESTful请求，做了各种合法性检查后，将其变成标准的SQL语句，通过taosc的异步接口，将请求发往整个系统中的任一dnode。收到处理后的结果后，再翻译成HTTP协议，返回给应用。
@@ -99,6 +108,7 @@ TSDB中存储的元数据包含属于其所在的VNODE中表的类型，schema
如果HTTP模块启动，就意味着启动了一个taosc的实例。任一一个dnode都可以启动该模块，以实现对RESTful请求的分布式处理。
## Monitor模块
+
该模块负责检测一个dnode的运行状态，可以通过配置，由dnode启动或停止。原则上，每个dnode都应该启动一个monitor实例。
Monitor采集TDengine里的关键操作，比如创建、删除、更新账号、表、库等，而且周期性的收集CPU、内存、网络等资源的使用情况（采集周期由系统配置参数monitorInterval控制）。获得这些数据后，monitor模块将采集的数据写入系统的日志库(DB名字由系统配置参数monitorDbName控制）。
diff --git a/documentation20/webdocs/markdowndocs/replica-ch.md b/documentation20/cn/03.architecture/02.replica/docs.md
similarity index 95%
rename from documentation20/webdocs/markdowndocs/replica-ch.md
rename to documentation20/cn/03.architecture/02.replica/docs.md
index 4d714fb5502534521e47d761e24af67b31248f51..8e1b1e3ab1513fbeaa5b9b805263485a13483b9b 100644
--- a/documentation20/webdocs/markdowndocs/replica-ch.md
+++ b/documentation20/cn/03.architecture/02.replica/docs.md
@@ -10,13 +10,13 @@ TDengine面向的是物联网场景，需要支持数据的实时复制，来最
数据复制是与数据存储（写入、读取）密切相关的，但两者又是相对独立，可以完全脱耦的。在TDengine系统中，有两种不同类型的数据，一种是时序数据，由TSDB模块负责；一种是元数据(Meta Data), 由MNODE负责。这两种性质不同的数据都需要同步功能。数据复制模块通过不同的实例启动配置参数，为这两种类型数据都提供同步功能。
-在阅读本文之前，请先阅读《TDengine 2.0 整体架构》，了解TDengine的集群设计和基本概念
+在阅读本文之前，请先阅读《[TDengine 2.0 整体架构](https://www.taosdata.com/cn/documentation/architecture/)》，了解TDengine的集群设计和基本概念
特别注明：本文中提到数据更新操作包括数据的增加、删除与修改。
## 基本概念和定义
-TDengine里存在vnode, mnode, vnode用来存储时序数据，mnode用来存储元数据。但从同步数据复制的模块来看，两者没有本质的区别，因此本文里的虚拟节点不仅包括vnode, 也包括mnode, vgoup也指mnode group, 除非特别注明。
+TDengine里存在vnode, mnode, vnode用来存储时序数据，mnode用来存储元数据。但从同步数据复制的模块来看，两者没有本质的区别，因此本文里的虚拟节点不仅包括vnode, 也包括mnode, vgroup也指mnode group, 除非特别注明。
**版本(version)**：
@@ -90,7 +90,7 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
具体的流程图如下：
- 
+
选择Master的具体规则如下：
@@ -105,7 +105,7 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
如果vnode A是master, vnode B是slave, vnode A能接受客户端的写请求，而vnode B不能。当vnode A收到写的请求后，遵循下面的流程：
- 
+
1. 应用对写请求做基本的合法性检查，通过，则给改请求包打上一个版本号(version, 单调递增）
2. 应用将打上版本号的写请求封装一个WAL Head, 写入WAL(Write Ahead Log)
@@ -128,19 +128,19 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
2. 任何一个数据文件(file)有名字、大小，还有一个magic number。只有文件名、大小与magic number一致时，两个文件才判断是一样的，无需同步。Magic number可以是checksum, 也可以是简单的文件大小。怎么计算magic，换句话说，如何检测数据文件是否有效，完全由应用决定。
3. 文件名的处理有点复杂，因为每台服务器的路径可能不一致。比如node A的TDengine的数据文件存放在 /etc/taos目录下，而node B的数据存放在 /home/jhtao目录下。因此同步模块需要应用在启动一个同步实例时提供一个path，这样两台服务器的绝对路径可以不一样，但仍然可以做对比，做同步。
4. 当sync模块调用回调函数getFileInfo获得数据文件信息时，有如下的规则
- 1. index 为0，表示获取最老的文件，同时修改index返回给sync模块。如果index不为0，表示获取指定位置的文件。
- 2. 如果name为空，表示sync想获取位于index位置的文件信息，包括magic, size。Master节点会这么调用
- 3. 如果name不为空，表示sync想获取指定文件名和index的信息，slave节点会这么调用
- 4. 如果某个index的文件不存在，magic返回0，表示文件已经是最后一个。因此整个系统里，文件的index必须是连续的一段整数。
+ * index 为0，表示获取最老的文件，同时修改index返回给sync模块。如果index不为0，表示获取指定位置的文件。
+ * 如果name为空，表示sync想获取位于index位置的文件信息，包括magic, size。Master节点会这么调用
+ * 如果name不为空，表示sync想获取指定文件名和index的信息，slave节点会这么调用
+ * 如果某个index的文件不存在，magic返回0，表示文件已经是最后一个。因此整个系统里，文件的index必须是连续的一段整数。
5. 当sync模块调用回调函数getWalInfo获得wal信息时，有如下规则
- 1. index为0，表示获得最老的WAL文件, 返回时，index更新为具体的数字
- 2. 如果返回0，表示这是最新的一个WAL文件，如果返回值是1，表示后面还有更新的WAL文件
- 3. 返回的文件名为空，那表示没有WAL文件
+ * index为0，表示获得最老的WAL文件, 返回时，index更新为具体的数字
+ * 如果返回0，表示这是最新的一个WAL文件，如果返回值是1，表示后面还有更新的WAL文件
+ * 返回的文件名为空，那表示没有WAL文件
6. 无论是getFileInfo, 还是getWalInfo, 只要获取出错（不是文件不存在），返回-1即可，系统会报错，停止同步
整个数据恢复流程分为两大步骤，第一步，先恢复archived data(file), 然后恢复wal。具体流程如下：
- 
+
1. 通过已经建立的TCP连接，发送sync req给master节点
2. master收到sync req后，以client的身份，向vnode B主动建立一新的专用于同步的TCP连接（syncFd)
diff --git a/documentation20/webdocs/markdowndocs/architecture-ch.md b/documentation20/cn/03.architecture/docs.md
similarity index 95%
rename from documentation20/webdocs/markdowndocs/architecture-ch.md
rename to documentation20/cn/03.architecture/docs.md
index 8921633c8d31f0fc2c2ab3f00d36e8e57d5dbb9a..6f9f1699d4e9bab944388e91aff3b89b1421563a 100644
--- a/documentation20/webdocs/markdowndocs/architecture-ch.md
+++ b/documentation20/cn/03.architecture/docs.md
@@ -1,7 +1,9 @@
# 数据模型和整体架构
-## 数据模型
+## 数据模型
+
### 物联网典型场景
+
在典型的物联网、车联网、运维监测场景中，往往有多种不同类型的数据采集设备，采集一个到多个不同的物理量。而同一种采集设备类型，往往又有多个具体的采集设备分布在不同的地点。大数据处理系统就是要将各种采集的数据汇总，然后进行计算和分析。对于同一类设备，其采集的数据都是很规则的。以智能电表为例，假设每个智能电表采集电流、电压、相位三个量，其采集的数据类似如下的表格：
@@ -103,6 +105,7 @@
每一条记录都有设备ID，时间戳，采集的物理量(如上图中的电流、电压、相位），还有与每个设备相关的静态标签（如上述表一中的位置Location和分组groupId）。每个设备是受外界的触发，或按照设定的周期采集数据。采集的数据点是时序的，是一个数据流。
### 数据特征
+
除时序特征外，仔细研究发现，物联网、车联网、运维监测类数据还具有很多其他明显的特征：
1. 数据高度结构化；
@@ -119,9 +122,11 @@
充分利用上述特征，TDengine 采取了经特殊优化的存储和计算设计来处理时序数据，它将系统处理能力显著提高，同时大幅降低了系统运维的复杂度。
### 关系型数据库模型
+
因为采集的数据一般是结构化数据，同时为降低学习门槛，TDengine采用传统的关系型数据库模型管理数据。因此用户需要先创建库，然后创建表，之后才能插入或查询数据。TDengine采用的是结构化存储，而不是NoSQL的key-value存储。
### 一个数据采集点一张表
+
为充分利用其数据的时序性和其他数据特点，TDengine要求**对每个数据采集点单独建表**（比如有一千万个智能电表，就需创建一千万张表，上述表格中的d1001, d1002, d1003, d1004都需单独建表），用来存储这个采集点所采集的时序数据。这种设计有几大优点：
1. 能保证一个采集点的数据在存储介质上是以块为单位连续存储的。如果读取一个时间段的数据，它能大幅减少随机读取操作，成数量级的提升读取和查询速度。
@@ -133,6 +138,7 @@
TDengine 建议用数据采集点的名字(如上表中的D1001)来做表名。每个数据采集点可能同时采集多个物理量(如上表中的curent, voltage, phase)，每个物理量对应一张表中的一列，数据类型可以是整型、浮点型、字符串等。除此之外，表的第一列必须是时间戳，即数据类型为 timestamp。对采集的数据，TDengine将自动按照时间戳建立索引，但对采集的物理量不建任何索引。数据用列式存储方式保存。
### 超级表：同一类型数据采集点的集合
+
由于一个数据采集点一张表，导致表的数量巨增，难以管理，而且应用经常需要做采集点之间的聚合操作，聚合的操作也变得复杂起来。为解决这个问题，TDengine引入超级表(Super Table，简称为STable)的概念。
超级表是指某一特定类型的数据采集点的集合。同一类型的数据采集点，其表的结构是完全一样的，但每个表（数据采集点）的静态属性（标签）是不一样的。描述一个超级表（某一特定类型的数据采集点的结合），除需要定义采集量的表结构之外，还需要定义其标签的schema，标签的数据类型可以是整数、浮点数、字符串，标签可以有多个，可以事后增加、删除或修改。 如果整个系统有N个不同类型的数据采集点，就需要建立N个超级表。
@@ -141,16 +147,20 @@ TDengine 建议用数据采集点的名字(如上表中的D1001)来做表名。
当对多个具有相同数据类型的数据采集点进行聚合操作时，TDengine将先把满足标签过滤条件的表从超级表的中查找出来，然后再扫描这些表的时序数据，进行聚合操作，这样能将需要扫描的数据集大幅减少，从而大幅提高聚合计算的性能。
-## 集群与基本逻辑单元
+## 集群与基本逻辑单元
+
TDengine 的设计是基于单个硬件、软件系统不可靠，基于任何单台计算机都无法提供足够计算能力和存储能力处理海量数据的假设进行设计的。因此 TDengine 从研发的第一天起，就按照分布式高可靠架构进行设计，是支持水平扩展的，这样任何单台或多台服务器发生硬件故障或软件错误都不影响系统的可用性和可靠性。同时，通过节点虚拟化并辅以自动化负载均衡技术，TDengine 能最高效率地利用异构集群中的计算和存储资源降低硬件投资。
### 主要逻辑单元
+
TDengine 分布式架构的逻辑结构图如下：
- 
+
+
图 1 TDengine架构示意图
+
一个完整的 TDengine 系统是运行在一到多个物理节点上的，逻辑上，它包含数据节点(dnode)、TDengine应用驱动(taosc)以及应用(app)。系统中存在一到多个数据节点，这些数据节点组成一个集群(cluster)。应用通过taosc的API与TDengine集群进行互动。下面对每个逻辑单元进行简要介绍。
-**物理节点(pnode):** pnode是一独立运行、拥有自己的计算、存储和网络能力的计算机，可以是安装有OS的物理机、虚拟机或Docker容器。物理节点由其配置的 FQDN(Fully Qualified Domain Name)来标识。TDengine完全依赖FQDN来进行网络通讯，如果不了解FQDN，请看博文《一篇文章说清楚TDengine的FQDN》。
+**物理节点(pnode):** pnode是一独立运行、拥有自己的计算、存储和网络能力的计算机，可以是安装有OS的物理机、虚拟机或Docker容器。物理节点由其配置的 FQDN(Fully Qualified Domain Name)来标识。TDengine完全依赖FQDN来进行网络通讯，如果不了解FQDN，请看博文[《一篇文章说清楚TDengine的FQDN》](https://www.taosdata.com/blog/2020/09/11/1824.html)。
**数据节点(dnode):** dnode 是 TDengine 服务器侧执行代码 taosd 在物理节点上的一个运行实例，一个工作的系统必须有至少一个数据节点。dnode包含零到多个逻辑的虚拟节点(VNODE)，零或者至多一个逻辑的管理节点(mnode)。dnode在系统中的唯一标识由实例的End Point (EP )决定。EP是dnode所在物理节点的FQDN (Fully Qualified Domain Name)和系统所配置的网络端口号(Port)的组合。通过配置不同的端口，一个物理节点(一台物理机、虚拟机或容器）可以运行多个实例，或有多个数据节点。
@@ -163,6 +173,7 @@ TDengine 分布式架构的逻辑结构图如下：
**TAOSC:** taosc是TDengine给应用提供的驱动程序(driver)，负责处理应用与集群的接口交互，提供C/C++语言原生接口，内嵌于JDBC、C#、Python、Go、Node.js语言连接库里。应用都是通过taosc而不是直接连接集群中的数据节点与整个集群进行交互的。这个模块负责获取并缓存元数据；将插入、查询等请求转发到正确的数据节点；在把结果返回给应用时，还需要负责最后一级的聚合、排序、过滤等操作。对于JDBC, C/C++/C#/Python/Go/Node.js接口而言，这个模块是在应用所处的物理节点上运行。同时，为支持全分布式的RESTful接口，taosc在TDengine集群的每个dnode上都有一运行实例。
### 节点之间的通讯
+
**通讯方式：**TDengine系统的各个数据节点之间，以及应用驱动与各数据节点之间的通讯是通过TCP/UDP进行的。因为考虑到物联网场景，数据写入的包一般不大，因此TDengine 除采用TCP做传输之外，还采用UDP方式，因为UDP 更加高效，而且不受连接数的限制。TDengine实现了自己的超时、重传、确认等机制，以确保UDP的可靠传输。对于数据量不到15K的数据包，采取UDP的方式进行传输，超过15K的，或者是查询类的操作，自动采取TCP的方式进行传输。同时，TDengine根据配置和数据包，会自动对数据进行压缩/解压缩，数字签名/认证等处理。对于数据节点之间的数据复制，只采用TCP方式进行数据传输。
**FQDN配置**：一个数据节点有一个或多个FQDN，可以在系统配置文件taos.cfg通过参数“fqdn"进行指定，如果没有指定，系统将自动获取计算机的hostname作为其FQDN。如果节点没有配置FQDN，可以直接将该节点的配置参数fqdn设置为它的IP地址。但不建议使用IP，因为IP地址可变，一旦变化，将让集群无法正常工作。一个数据节点的EP(End Point)由FQDN + Port组成。采用FQDN，需要保证DNS服务正常工作，或者在节点以及应用所在的节点配置好hosts文件。
@@ -180,9 +191,12 @@ TDengine 分布式架构的逻辑结构图如下：
**重定向**：无论是dnode还是taosc，最先都是要发起与mnode的连接，但mnode是系统自动创建并维护的，因此对于用户来说，并不知道哪个dnode在运行mnode。TDengine只要求向系统中任何一个工作的dnode发起连接即可。因为任何一个正在运行的dnode，都维护有目前运行的mnode EP List。当收到一个来自新启动的dnode或taosc的连接请求，如果自己不是mnode，则将mnode EP List回复给对方，taosc或新启动的dnode收到这个list, 就重新尝试建立连接。当mnode EP List发生改变，通过节点之间的消息交互，各个数据节点就很快获取最新列表，并通知taosc。
### 一个典型的消息流程
+
为解释vnode, mnode, taosc和应用之间的关系以及各自扮演的角色，下面对写入数据这个典型操作的流程进行剖析。
- 
+
+
图 2 TDengine典型的操作流程
+
1. 应用通过JDBC、ODBC或其他API接口发起插入数据的请求。
2. taosc会检查缓存，看是否保存有该表的meta data。如果有，直接到第4步。如果没有，taosc将向mnode发出get meta-data请求。
3. mnode将该表的meta-data返回给taosc。Meta-data包含有该表的schema, 而且还有该表所属的vgroup信息（vnode ID以及所在的dnode的End Point，如果副本数为N，就有N组End Point)。如果taosc迟迟得不到mnode回应，而且存在多个mnode, taosc将向下一个mnode发出请求。
@@ -198,14 +212,15 @@ TDengine 分布式架构的逻辑结构图如下：
通过taosc缓存机制，只有在第一次对一张表操作时，才需要访问mnode,因此mnode不会成为系统瓶颈。但因为schema有可能变化，而且vgroup有可能发生改变（比如负载均衡发生），因此taosc会定时和mnode交互，自动更新缓存。
-## 存储模型与数据分区、分片
+## 存储模型与数据分区、分片
### 存储模型
+
TDengine存储的数据包括采集的时序数据以及库、表相关的元数据、标签数据等，这些数据具体分为三部分：
-- 时序数据：存放于vnode里，由data、head和last三个文件组成，数据量大，查询量取决于应用场景。容许乱序写入，但暂时不支持删除和更新操作。通过采用一个采集点一张表的模型，一个时间段的数据是连续存储，对单张表的写入是简单的追加操作，一次读，可以读到多条记录，这样保证对单个采集点的插入和查询操作，性能达到最优。
+- 时序数据：存放于vnode里，由data、head和last三个文件组成，数据量大，查询量取决于应用场景。容许乱序写入，但暂时不支持删除操作，并且仅在update参数设置为1时允许更新操作。通过采用一个采集点一张表的模型，一个时间段的数据是连续存储，对单张表的写入是简单的追加操作，一次读，可以读到多条记录，这样保证对单个采集点的插入和查询操作，性能达到最优。
- 标签数据：存放于vnode里的meta文件，支持增删改查四个标准操作。数据量不大，有N张表，就有N条记录，因此可以全内存存储。如果标签过滤操作很多，查询将十分频繁，因此TDengine支持多核多线程并发查询。只要计算资源足够，即使有数千万张表，过滤结果能毫秒级返回。
-- 其他元数据：存放于mnode里，包含系统节点、用户、DB、Table Schema等等，支持增删改查四个标准操作。这部分数据的量不大，可以全内存保存，而且由于客户端有缓存，查询量也不大。因此目前的设计虽是集中式存储管理，但不会构成性能瓶颈。
+- 元数据：存放于mnode里，包含系统节点、用户、DB、Table Schema等信息，支持增删改查四个标准操作。这部分数据的量不大，可以全内存保存，而且由于客户端有缓存，查询量也不大。因此目前的设计虽是集中式存储管理，但不会构成性能瓶颈。
与典型的NoSQL存储模型相比，TDengine将标签数据与时序数据完全分离存储，它具有两大优势：
@@ -213,6 +228,7 @@ TDengine存储的数据包括采集的时序数据以及库、表相关的元数
- 能够实现极为高效的多表之间的聚合查询：做多表之间聚合查询时，先把符合标签过滤条件的表查找出来，然后再查找这些表相应的数据块，这样大幅减少要扫描的数据集，从而大幅提高查询效率。而且标签数据采用全内存的结构进行管理和维护，千万级别规模的标签数据查询可以在毫秒级别返回。
### 数据分片
+
对于海量的数据管理，为实现水平扩展，一般都需要采取分片(Sharding)分区(Partitioning)策略。TDengine是通过vnode来实现数据分片的，通过一个时间段一个数据文件来实现时序数据分区的。
vnode(虚拟数据节点)负责为采集的时序数据提供写入、查询和计算功能。为便于负载均衡、数据恢复、支持异构环境，TDengine将一个数据节点根据其计算和存储资源切分为多个vnode。这些vnode的管理是TDengine自动完成的，对应用完全透明。
@@ -224,11 +240,13 @@ vnode(虚拟数据节点)负责为采集的时序数据提供写入、查询和
每张表的meda data（包含schema, 标签等）也存放于vnode里，而不是集中存放于mnode，实际上这是对Meta数据的分片，这样便于高效并行的进行标签过滤操作。
### 数据分区
+
TDengine除vnode分片之外，还对时序数据按照时间段进行分区。每个数据文件只包含一个时间段的时序数据，时间段的长度由DB的配置参数days决定。这种按时间段分区的方法还便于高效实现数据的保留策略，只要数据文件超过规定的天数（系统配置参数keep)，将被自动删除。而且不同的时间段可以存放于不同的路径和存储介质，以便于大数据的冷热管理，实现多级存储。
总的来说，**TDengine是通过vnode以及时间两个维度，对大数据进行切分**，便于并行高效的管理，实现水平扩展。
### 负载均衡
+
每个dnode都定时向 mnode(虚拟管理节点)报告其状态（包括硬盘空间、内存大小、CPU、网络、虚拟节点个数等），因此mnode了解整个集群的状态。基于整体状态，当mnode发现某个dnode负载过重，它会将dnode上的一个或多个vnode挪到其他dnode。在挪动过程中，对外服务继续进行，数据插入、查询和计算操作都不受影响。
如果mnode一段时间没有收到dnode的状态报告，mnode会认为这个dnode已经离线。如果离线时间超过一定时长（时长由配置参数offlineThreshold决定），该dnode将被mnode强制剔除出集群。该dnode上的vnodes如果副本数大于一，系统将自动在其他dnode上创建新的副本，以保证数据的副本数。如果该dnode上还有mnode, 而且mnode的副本数大于一，系统也将自动在其他dnode上创建新的mnode, 以保证mnode的副本数。
@@ -238,13 +256,17 @@ TDengine除vnode分片之外，还对时序数据按照时间段进行分区。
负载均衡过程无需任何人工干预，应用也无需重启，将自动连接新的节点，完全透明。
**提示：负载均衡由参数balance控制，决定开启/关闭自动负载均衡。**
-## 数据写入与复制流程
+## 数据写入与复制流程
+
如果一个数据库有N个副本，那一个虚拟节点组就有N个虚拟节点，但是只有一个是Master，其他都是slave。当应用将新的记录写入系统时，只有Master vnode能接受写的请求。如果slave vnode收到写的请求，系统将通知taosc需要重新定向。
+
### Master vnode写入流程
+
Master Vnode遵循下面的写入流程：
- 
+
图 3 TDengine Master写入流程
+
1. Master vnode收到应用的数据插入请求，验证OK，进入下一步；
2. 如果系统配置参数walLevel大于0，vnode将把该请求的原始数据包写入数据库日志文件WAL。如果walLevel设置为2，而且fsync设置为0，TDengine还将WAL数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失；
3. 如果有多个副本，vnode将把数据包转发给同一虚拟节点组内slave vnodes, 该转发包带有数据的版本号(version)；
@@ -253,10 +275,12 @@ Master Vnode遵循下面的写入流程：
6. 如果第2，3，4步中任何一步失败，将直接返回错误给应用。
### Slave vnode写入流程
+
对于slave vnode, 写入流程是：
- 
+
图 4 TDengine Slave写入流程
+
1. Slave vnode收到Master vnode转发了的数据插入请求。
2. 如果系统配置参数walLevel大于0，vnode将把该请求的原始数据包写入数据库日志文件WAL。如果walLevel设置为2，而且fsync设置为0，TDengine还将WAL数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失；
3. 写入内存，更新内存中的skip list。
@@ -264,6 +288,7 @@ Master Vnode遵循下面的写入流程：
与Master vnode相比，slave vnode不存在转发环节，也不存在回复确认环节，少了两步。但写内存与WAL是完全一样的。
### 异地容灾、IDC迁移
+
从上述Master和Slave流程可以看出，TDengine采用的是异步复制的方式进行数据同步。这种方式能够大幅提高写入性能，网络延时对写入速度不会有大的影响。通过配置每个物理节点的IDC和机架号，可以保证对于一个虚拟节点组，虚拟节点由来自不同IDC、不同机架的物理节点组成，从而实现异地容灾。因此TDengine原生支持异地容灾，无需再使用其他工具。
另外一方面，TDengine支持动态修改副本数，一旦副本数增加，新加入的虚拟节点将立即进入数据同步流程，同步结束后，新加入的虚拟节点即可提供服务。而在同步过程中，master以及其他已经同步的虚拟节点都可以对外提供服务。利用这一特性，TDengine可以实现无服务中断的IDC机房迁移。只需要将新IDC的物理节点加入现有集群，等数据同步完成后，再将老的IDC的物理节点从集群中剔除即可。
@@ -280,6 +305,7 @@ Master Vnode遵循下面的写入流程：
**提示：该功能暂未提供**
### 主从选择
+
Vnode会保持一个数据版本号(Version)，对内存数据进行持久化存储时，对该版本号也进行持久化存储。每个数据更新操作，无论是采集的时序数据还是元数据，这个版本号将增一。
一个vnode启动时，角色(master、slave) 是不定的，数据是处于未同步状态，它需要与虚拟节点组内其他节点建立TCP连接，并互相交换status，其中包括version和自己的角色。通过status的交换，系统进入选主流程，规则如下：
@@ -289,17 +315,20 @@ Vnode会保持一个数据版本号(Version)，对内存数据进行持久化存
3. 在线的虚拟节点数过半，而且有虚拟节点是slave的话，该虚拟节点自动成为master
4. 对于2和3，如果多个虚拟节点满足成为master的要求，那么虚拟节点组的节点列表里，最前面的选为master
-更多的关于数据复制的流程，请见TDengine 2.0数据复制模块设计。
+更多的关于数据复制的流程，请见[TDengine 2.0数据复制模块设计](https://www.taosdata.com/cn/documentation/architecture/replica/)。
### 同步复制
+
对于数据一致性要求更高的场景，异步数据复制无法满足要求，因为有极小的概率丢失数据，因此TDengine提供同步复制的机制供用户选择。在创建数据库时，除指定副本数replica之外，用户还需要指定新的参数quorum。如果quorum大于一，它表示每次Master转发给副本时，需要等待quorum-1个回复确认，才能通知应用，数据在slave已经写入成功。如果在一定的时间内，得不到quorum-1个回复确认，master vnode将返回错误给应用。
采用同步复制，系统的性能会有所下降，而且latency会增加。因为元数据要强一致，mnode之间的数据同步缺省就是采用的同步复制。
注：vnode之间的同步复制仅仅企业版支持
-## 缓存与持久化
+## 缓存与持久化
+
### 缓存
+
TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Used，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心的是刚产生的数据，即当前状态。TDengine充分利用这一特性，将最近到达的（当前状态）数据保存在缓存中。
TDengine通过查询函数向用户提供毫秒级的数据获取能力。直接将最近到达的数据保存在缓存中，可以更加快速地响应用户针对最近一条或一批数据的查询分析，整体上提供更快的数据库查询响应能力。从这个意义上来说，**可通过设置合适的配置参数将TDengine作为数据缓存来使用，而不需要再部署Redis或其他额外的缓存系统**，可有效地简化系统架构，降低运维的成本。需要注意的是，TDengine重启以后系统的缓存将被清空，之前缓存的数据均会被批量写入磁盘，缓存的数据将不会像专门的Key-value缓存系统再将之前缓存的数据重新加载到缓存中。
@@ -307,6 +336,7 @@ TDengine通过查询函数向用户提供毫秒级的数据获取能力。直接
每个vnode有自己独立的内存，而且由多个固定大小的内存块组成，不同vnode之间完全隔离。数据写入时，类似于日志的写法，数据被顺序追加写入内存，但每个vnode维护有自己的skip list，便于迅速查找。当三分之一以上的内存块写满时，启动落盘操作，而且后续写的操作在新的内存块进行。这样，一个vnode里有三分之一内存块是保留有最近的数据的，以达到缓存、快速查找的目的。一个vnode的内存块的个数由配置参数blocks决定，内存块的大小由配置参数cache决定。
### 持久化存储
+
TDengine采用数据驱动的方式让缓存中的数据写入硬盘进行持久化存储。当vnode中缓存的数据达到一定规模时，为了不阻塞后续数据的写入，TDengine也会拉起落盘线程将缓存的数据写入持久化存储。TDengine在数据落盘时会打开新的数据库日志文件，在落盘成功后则会删除老的数据库日志文件，避免日志文件无限制的增长。
为充分利用时序数据特点，TDengine将一个vnode保存在持久化存储的数据切分成多个文件，每个文件只保存固定天数的数据，这个天数由系统配置参数days决定。切分成多个文件后，给定查询的起止日期，无需任何索引，就可以立即定位需要打开哪些数据文件，大大加快读取速度。
@@ -322,6 +352,7 @@ TDengine采用数据驱动的方式让缓存中的数据写入硬盘进行持久
数据写入磁盘时，根据系统配置参数comp决定是否压缩数据。TDengine提供了三种压缩选项：无压缩、一阶段压缩和两阶段压缩，分别对应comp值为0、1和2的情况。一阶段压缩根据数据的类型进行了相应的压缩，压缩算法包括delta-delta编码、simple 8B方法、zig-zag编码、LZ4等算法。二阶段压缩在一阶段压缩的基础上又用通用压缩算法进行了压缩，压缩率更高。
### 多级存储
+
在默认配置下，TDengine会将所有数据保存在/var/lib/taos目录下，而且每个vnode的数据文件保存在该目录下的不同目录。为扩大存储空间，尽量减少文件读取的瓶颈，提高数据吞吐率 TDengine可通过配置系统参数dataDir让多个挂载的硬盘被系统同时使用。除此之外，TDengine也提供了数据分级存储的功能，即根据数据文件的新老程度存储在不同的存储介质上。比如最新的数据存储在SSD上，超过一周的数据存储在本地硬盘上，超过4周的数据存储在网络存储设备上，这样来降低存储成本，而又保证高效的访问数据。数据在不同存储介质上的移动是由系统自动完成的，对应用是完全透明的。数据的分级存储也是通过系统参数dataDir来配置。
dataDir的配置格式如下：
@@ -345,10 +376,12 @@ dataDir /mnt/disk6/taos 2
注：多级存储功能仅企业版支持
-## 数据查询
+## 数据查询
+
TDengine提供了多种多样针对表和超级表的查询处理功能，除了常规的聚合查询之外，还提供针对时序数据的窗口查询、统计聚合等功能。TDengine的查询处理需要客户端、vnode, mnode节点协同完成。
### 单表查询
+
SQL语句的解析和校验工作在客户端完成。解析SQL语句并生成抽象语法树(Abstract Syntax Tree, AST)，然后对其进行校验和检查。以及向管理节点(mnode)请求查询中指定表的元数据信息(table metadata)。
根据元数据信息中的End Point信息，将查询请求序列化后发送到该表所在的数据节点（dnode）。dnode接收到查询请求后，识别出该查询请求指向的虚拟节点（vnode），将消息转发到vnode的查询执行队列。vnode的查询执行线程建立基础的查询执行环境，并立即返回该查询请求，同时开始执行该查询。
@@ -374,18 +407,21 @@ select count(*) from d1001 interval(1h) fill(prev);
针对d1001设备采集数据统计每小时记录数，如果某一个小时不存在数据，则返回之前一个小时的统计数据。TDengine提供前向插值(prev)、线性插值(linear)、NULL值填充(NULL)、特定值填充(value)。
### 多表聚合查询
+
TDengine对每个数据采集点单独建表，但在实际应用中经常需要对不同的采集点数据进行聚合。为高效的进行聚合操作，TDengine引入超级表（STable）的概念。超级表用来代表一特定类型的数据采集点，它是包含多张表的表集合，集合里每张表的模式（schema）完全一致，但每张表都带有自己的静态标签，标签可以多个，可以随时增加、删除和修改。 应用可通过指定标签的过滤条件，对一个STable下的全部或部分表进行聚合或统计操作，这样大大简化应用的开发。其具体流程如下图所示：
- 
+
图 5 多表聚合查询原理图
-1：应用将一个查询条件发往系统；
-2: taosc将超级表的名字发往 Meta Node（管理节点)；
-3：管理节点将超级表所拥有的 vnode 列表发回 taosc；
-4：taosc将计算的请求连同标签过滤条件发往这些vnode对应的多个数据节点；
-5：每个vnode先在内存里查找出自己节点里符合标签过滤条件的表的集合，然后扫描存储的时序数据，完成相应的聚合计算，将结果返回给taosc；
-6：taosc将多个数据节点返回的结果做最后的聚合，将其返回给应用。
+
+1. 应用将一个查询条件发往系统；
+2. taosc将超级表的名字发往 Meta Node（管理节点)；
+3. 管理节点将超级表所拥有的 vnode 列表发回 taosc；
+4. taosc将计算的请求连同标签过滤条件发往这些vnode对应的多个数据节点；
+5. 每个vnode先在内存里查找出自己节点里符合标签过滤条件的表的集合，然后扫描存储的时序数据，完成相应的聚合计算，将结果返回给taosc；
+6. taosc将多个数据节点返回的结果做最后的聚合，将其返回给应用。
由于TDengine在vnode内将标签数据与时序数据分离存储，通过在内存里过滤标签数据，先找到需要参与聚合操作的表的集合，将需要扫描的数据集大幅减少，大幅提升聚合计算速度。同时，由于数据分布在多个vnode/dnode，聚合计算操作在多个vnode里并发进行，又进一步提升了聚合的速度。 对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样，细节请看 TAOS SQL。
### 预计算
+
为有效提升查询处理的性能，针对物联网数据的不可更改的特点，在数据块头部记录该数据块中存储数据的统计信息：包括最大值、最小值、和。我们称之为预计算单元。如果查询处理涉及整个数据块的全部数据，直接使用预计算结果，完全不需要读取数据块的内容。由于预计算数据量远小于磁盘上存储的数据块数据的大小，对于磁盘IO为瓶颈的查询处理，使用预计算结果可以极大地减小读取IO压力，加速查询处理的流程。预计算机制与Postgre SQL的索引BRIN（block range index）有异曲同工之妙。
diff --git a/documentation20/webdocs/markdowndocs/Model-ch.md b/documentation20/cn/04.model/docs.md
similarity index 82%
rename from documentation20/webdocs/markdowndocs/Model-ch.md
rename to documentation20/cn/04.model/docs.md
index ea1be899a85fe6bb31ab03674ab496d7b301432f..1a25e4407d0ed77c71040f676656fdc1451e2f81 100644
--- a/documentation20/webdocs/markdowndocs/Model-ch.md
+++ b/documentation20/cn/04.model/docs.md
@@ -4,16 +4,16 @@
TDengine采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库的设计，超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
-关于数据建模请参考视频教程。
+关于数据建模请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1945.html)。
-## 创建库
+## 创建库
不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为让各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
```mysql
CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 4 UPDATE 1;
```
-上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，内存块数为4，允许更新数据。详细的语法及参数请见TAOS SQL
+上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，内存块数为4，允许更新数据。详细的语法及参数请见 [TAOS SQL 的数据管理](https://www.taosdata.com/cn/documentation/taos-sql#management) 章节。
创建库之后，需要使用SQL命令USE将当前库切换过来，例如：
@@ -28,23 +28,25 @@ USE power;
- 任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
- 处于两个不同库的表是不能进行JOIN操作的。
-## 创建超级表
+## 创建超级表
+
一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用TDengine, 需要对每个类型的数据采集点创建一超级表。以表一中的智能电表为例，可以使用如下的SQL命令创建超级表：
```mysql
-CREATE TABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);
+CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);
```
-与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义。第一列必须为时间戳（示例中为ts)，其他列为采集的物理量（示例中为current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 TAOS SQL 一节。
+与创建普通表一样，创建表时，需要提供表名（示例中为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里可以有一到多个超级表。
-## 创建表
+## 创建表
+
TDengine对每个数据采集点需要独立建表。与标准的关系型数据一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以表一中的智能电表为例，可以使用如下的SQL命令建表：
-```cmd
+```mysql
CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
```
-其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 TAOS SQL。
+其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](https://www.taosdata.com/cn/documentation/taos-sql#table) 章节。
**注意：**目前 TDengine 没有从技术层面限制使用一个 database （dbA）的超级表作为模板建立另一个 database （dbB）的子表，后续会禁止这种用法，不建议使用这种方法建表。
@@ -52,12 +54,15 @@ TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列
**自动建表**：在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
-```cmd
+```mysql
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建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得简单。
diff --git a/documentation20/webdocs/markdowndocs/insert-ch.md b/documentation20/cn/05.insert/docs.md
similarity index 72%
rename from documentation20/webdocs/markdowndocs/insert-ch.md
rename to documentation20/cn/05.insert/docs.md
index 7d380ac952dce5f57ff259159c33dd9e9b53edf3..ce2d65e7d2259c6dac9efc67a61f7c009dd96984 100644
--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/cn/05.insert/docs.md
@@ -2,7 +2,7 @@
TDengine支持多种接口写入数据，包括SQL, Prometheus, Telegraf, EMQ MQTT Broker, HiveMQ Broker, CSV文件等，后续还将提供Kafka, OPC等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。
-## SQL写入
+## SQL写入
应用通过C/C++, JDBC, GO, 或Python Connector 执行SQL insert语句来插入数据，用户还可以通过TAOS Shell，手动输入SQL insert语句插入数据。比如下面这条insert 就将一条记录写入到表d1001中：
```mysql
@@ -18,7 +18,7 @@ TDengine也支持一次向多个表写入数据，比如下面这条命令就向
INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
```
-详细的SQL INSERT语法规则请见TAOS SQL
+详细的SQL INSERT语法规则请见 [TAOS SQL 的数据写入](https://www.taosdata.com/cn/documentation/taos-sql#insert) 章节。
**Tips:**
@@ -27,11 +27,13 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
- 对同一张表，如果新插入记录的时间戳已经存在，默认（没有使用 UPDATE 1 创建数据库）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
- 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还老的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days配置为2，那么无法写入比当前时间还晚2天的数据。
-## Prometheus直接写入
-Prometheus作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具Bailongma，只需在Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文用Docker容器快速搭建一个Devops监控Demo即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
+## Prometheus直接写入
+
+[Prometheus](https://www.prometheus.io/)作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
### 从源代码编译blm_prometheus
-用户需要从github下载Bailongma的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
+
+用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
- Linux操作系统的服务器
- 安装好Golang, 1.10版本以上
- 对应的TDengine版本。因为用到了TDengine的客户端动态链接库，因此需要安装好和服务端相同版本的TDengine程序；比如服务端版本是TDengine 2.0.0, 则在bailongma所在的linux服务器（可以与TDengine在同一台服务器，或者不同服务器）
@@ -45,10 +47,12 @@ go build
一切正常的情况下，就会在对应的目录下生成一个blm_prometheus的可执行程序。
### 安装Prometheus
-通过Prometheus的官网下载安装。下载地址
+
+通过Prometheus的官网下载安装。[下载地址](https://prometheus.io/download/)
### 配置Prometheus
-参考Prometheus的配置文档，在Prometheus的配置文件中的部分，增加以下配置
+
+参考Prometheus的[配置文档](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)，在Prometheus的配置文件中的部分，增加以下配置
- url: bailongma API服务提供的URL, 参考下面的blm_prometheus启动示例章节
@@ -112,11 +116,13 @@ use prometheus;
select * from apiserver_request_latencies_bucket;
```
-## Telegraf直接写入
-是一流行的IT运维数据采集开源工具，TDengine提供一个小工具Bailongma，只需在Telegraf做简单配置，无需任何代码，就可将Telegraf采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文用Docker容器快速搭建一个Devops监控Demo即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
+## Telegraf直接写入
+
+[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中的示例，可以参考。
### 从源代码编译blm_telegraf
-用户需要从github下载Bailongma的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
+
+用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件：
- Linux操作系统的服务器
- 安装好Golang, 1.10版本以上
@@ -132,9 +138,11 @@ go build
一切正常的情况下，就会在对应的目录下生成一个blm_telegraf的可执行程序。
### 安装Telegraf
-目前TDengine支持Telegraf 1.7.4以上的版本。用户可以根据当前的操作系统，到Telegraf官网下载安装包，并执行安装。下载地址如下：https://portal.influxdata.com/downloads
+
+目前TDengine支持Telegraf 1.7.4以上的版本。用户可以根据当前的操作系统，到Telegraf官网下载安装包，并执行安装。下载地址如下：https://portal.influxdata.com/downloads
### 配置Telegraf
+
修改Telegraf配置文件/etc/telegraf/telegraf.conf中与TDengine有关的配置项。
在output plugins部分，增加[[outputs.http]]配置项：
@@ -148,7 +156,7 @@ go build
- hostname: 区分不同采集设备的机器名称，需确保其唯一性
- metric_batch_size: 100，允许Telegraf每批次写入记录最大数量，增大其数量可以降低Telegraf的请求发送频率。
-关于如何使用Telegraf采集数据以及更多有关使用Telegraf的信息，请参考Telegraf官方的文档。
+关于如何使用Telegraf采集数据以及更多有关使用Telegraf的信息，请参考Telegraf官方的[文档](https://docs.influxdata.com/telegraf/v1.11/)。
### 启动blm_telegraf程序
blm_telegraf程序有以下选项，在启动blm_telegraf程序时可以通过设定这些选项来设定blm_telegraf的配置。
@@ -174,6 +182,7 @@ blm_telegraf对telegraf提供服务的端口号。
```
### 启动示例
+
通过以下命令启动一个blm_telegraf的API服务
```bash
./blm_telegraf -host 127.0.0.1 -port 8089
@@ -186,6 +195,7 @@ url = "http://10.1.2.3:8089/telegraf"
```
### 查询telegraf写入数据
+
telegraf产生的数据格式如下：
```json
{
@@ -220,10 +230,10 @@ select * from cpu;
MQTT是一流行的物联网数据传输协议，TDengine 可以很方便的接入 MQTT Broker 接受的数据并写入到 TDengine。
-## EMQ Broker 直接写入
+## EMQ Broker 直接写入
-EMQ是一开源的MQTT Broker软件，无需任何代码，只需要在EMQ Dashboard里使用“规则”做简单配置，即可将MQTT的数据直接写入TDengine。EMQ X 支持通过 发送到 Web 服务 的方式保存数据到 TDengine，也在企业版上提供原生的 TDengine 驱动实现直接保存。详细使用方法请参考EMQ 官方文档。
+[EMQ](https://github.com/emqx/emqx)是一开源的MQTT Broker软件，无需任何代码，只需要在EMQ Dashboard里使用“规则”做简单配置，即可将MQTT的数据直接写入TDengine。EMQ X 支持通过 发送到 Web 服务 的方式保存数据到 TDengine，也在企业版上提供原生的 TDengine 驱动实现直接保存。详细使用方法请参考[EMQ 官方文档](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
-## HiveMQ Broker 直接写入
+## HiveMQ Broker 直接写入
-HiveMQ 是一个提供免费个人版和企业版的 MQTT 代理，主要用于企业和新兴的机器到机器M2M通讯和内部传输，满足可伸缩性、易管理和安全特性。HiveMQ 提供了开源的插件开发包。可以通过 HiveMQ extension - TDengine 保存数据到 TDengine。详细使用方法请参考 HiveMQ extension - TDengine 说明文档。
+[HiveMQ](https://www.hivemq.com/) 是一个提供免费个人版和企业版的 MQTT 代理，主要用于企业和新兴的机器到机器M2M通讯和内部传输，满足可伸缩性、易管理和安全特性。HiveMQ 提供了开源的插件开发包。可以通过 HiveMQ extension - TDengine 保存数据到 TDengine。详细使用方法请参考 [HiveMQ extension - TDengine 说明文档](https://github.com/huskar-t/hivemq-tdengine-extension/blob/b62a26ecc164a310104df57691691b237e091c89/README.md)。
diff --git a/documentation20/webdocs/markdowndocs/Queries-ch.md b/documentation20/cn/06.queries/docs.md
similarity index 90%
rename from documentation20/webdocs/markdowndocs/Queries-ch.md
rename to documentation20/cn/06.queries/docs.md
index 839809ccba1914a9d5cfa9005be9f32e94f19924..a161778a72728ca05a75538c8b04ca0277e01bb2 100644
--- a/documentation20/webdocs/markdowndocs/Queries-ch.md
+++ b/documentation20/cn/06.queries/docs.md
@@ -1,10 +1,7 @@
-
-
-
# 高效查询数据
-## 主要查询功能
+## 主要查询功能
TDengine 采用 SQL 作为查询语言。应用程序可以通过 C/C++, Java, Go, Python 连接器发送 SQL 语句，用户可以通过 TDengine 提供的命令行（Command Line Interface, CLI）工具 TAOS Shell 手动执行 SQL 即席查询（Ad-Hoc Query）。TDengine 支持如下查询功能：
@@ -26,9 +23,10 @@ Query OK, 2 row(s) in set (0.001100s)
```
为满足物联网场景的需求，TDengine支持几个特殊的函数，比如twa(时间加权平均)，spread (最大值与最小值的差)，last_row(最后一条记录)等，更多与物联网场景相关的函数将添加进来。TDengine还支持连续查询。
-具体的查询语法请看TAOS SQL 。
+具体的查询语法请看 [TAOS SQL 的数据查询](https://www.taosdata.com/cn/documentation/taos-sql#select) 章节。
+
+## 多表聚合查询
-## 多表聚合查询
物联网场景中，往往同一个类型的数据采集点有多个。TDengine采用超级表(STable)的概念来描述某一个类型的数据采集点，一张普通的表来描述一个具体的数据采集点。同时TDengine使用标签来描述数据采集点的静态属性，一个具体的数据采集点有具体的标签值。通过指定标签的过滤条件，TDengine提供了一高效的方法将超级表(某一类型的数据采集点)所属的子表进行聚合查询。对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样。
**示例1**：在TAOS Shell，查找北京所有智能电表采集的电压平均值，并按照location分组
@@ -51,9 +49,9 @@ taos> SELECT count(*), max(current) FROM meters where groupId = 2 and ts > now -
Query OK, 1 row(s) in set (0.002136s)
```
-TDengine仅容许对属于同一个超级表的表之间进行聚合查询，不同超级表之间的聚合查询不支持。在TAOS SQL 一章，查询类操作都会注明是否支持超级表。
+TDengine仅容许对属于同一个超级表的表之间进行聚合查询，不同超级表之间的聚合查询不支持。在 [TAOS SQL 的数据查询](https://www.taosdata.com/cn/documentation/taos-sql#select) 一章，查询类操作都会注明是否支持超级表。
-## 降采样查询、插值
+## 降采样查询、插值
物联网场景里，经常需要通过降采样（down sampling）将采集的数据按时间段进行聚合。TDengine 提供了一个简便的关键词 interval 让按照时间窗口的查询操作变得极为简单。比如，将智能电表 d1001 采集的电流值每10秒钟求和
```mysql
@@ -91,5 +89,5 @@ Query OK, 5 row(s) in set (0.001521s)
物联网场景里，每个数据采集点采集数据的时间是难同步的，但很多分析算法(比如FFT)需要把采集的数据严格按照时间等间隔的对齐，在很多系统里，需要应用自己写程序来处理，但使用TDengine的降采样操作就轻松解决。如果一个时间间隔里，没有采集的数据，TDengine还提供插值计算的功能。
-语法规则细节请见TAOS SQL 。
+语法规则细节请见 [TAOS SQL 的时间维度聚合](https://www.taosdata.com/cn/documentation/taos-sql#aggregation) 章节。
diff --git a/documentation20/webdocs/markdowndocs/advanced features-ch.md b/documentation20/cn/07.advanced-features/docs.md
similarity index 97%
rename from documentation20/webdocs/markdowndocs/advanced features-ch.md
rename to documentation20/cn/07.advanced-features/docs.md
index 0ca8428ecee2c5ef162810737f77cb9cf4b9412b..bdf93fdc3d74184bd7a6fd6f4eefaf3db6853c22 100644
--- a/documentation20/webdocs/markdowndocs/advanced features-ch.md
+++ b/documentation20/cn/07.advanced-features/docs.md
@@ -1,6 +1,6 @@
# 高级功能
-## 连续查询(Continuous Query)
+## 连续查询(Continuous Query)
连续查询是TDengine定期自动执行的查询，采用滑动窗口的方式进行计算，是一种简化的时间驱动的流式计算。
针对库中的表或超级表，TDengine可提供定期自动执行的连续查询，
@@ -17,10 +17,8 @@ TDengine提供的连续查询与普通流计算中的时间窗口计算具有以
- 不同于流计算的实时反馈计算结果，连续查询只在时间窗口关闭以后才开始计算。
例如时间周期是1天，那么当天的结果只会在23:59:59以后才会生成。
-
- 如果有历史记录写入到已经计算完成的时间区间，连续查询并不会重新进行计算，
也不会重新将结果推送给用户。对于写回TDengine的模式，也不会更新已经存在的计算结果。
-
- 使用连续查询推送结果的模式，服务端并不缓存客户端计算状态，也不提供Exactly-Once的语意保证。
如果用户的应用端崩溃，再次拉起的连续查询将只会从再次拉起的时间开始重新计算最近的一个完整的时间窗口。
如果使用写回模式，TDengine可确保数据写回的有效性和连续性。
@@ -95,7 +93,7 @@ create table avg_vol as select avg(voltage) from meters where ts > now and ts <=
后续版本会提供更细粒度和便捷的连续查询管理命令。
-## 数据订阅(Publisher/Subscriber)
+## 数据订阅(Publisher/Subscriber)
基于数据天然的时间序列特性，TDengine的数据写入（insert）与消息系统的数据发布（pub）逻辑上一致，
均可视为系统中插入一条带时间戳的新记录。
@@ -118,7 +116,7 @@ taos_consume
taos_unsubscribe
```
-这些API的文档请见 [C/C++ Connector](https://www.taosdata.com/cn/documentation20/connector/)，
+这些API的文档请见 [C/C++ Connector](https://www.taosdata.com/cn/documentation/connector/)，
下面仍以智能电表场景为例介绍一下它们的具体用法（超级表和子表结构请参考上一节“连续查询”），
完整的示例代码可以在 [这里](https://github.com/taosdata/TDengine/blob/master/tests/examples/c/subscribe.c) 找到。
@@ -296,7 +294,7 @@ $ taos
### Java 使用数据订阅功能
-订阅功能也提供了 Java 开发接口，相关说明请见 [Java Connector](https://www.taosdata.com/cn/documentation20/connector/)。需要注意的是，目前 Java 接口没有提供异步订阅模式，但用户程序可以通过创建 `TimerTask` 等方式达到同样的效果。
+订阅功能也提供了 Java 开发接口，相关说明请见 [Java Connector](https://www.taosdata.com/cn/documentation/connector/)。需要注意的是，目前 Java 接口没有提供异步订阅模式，但用户程序可以通过创建 `TimerTask` 等方式达到同样的效果。
下面以一个示例程序介绍其具体使用方法。它所完成的功能与前面介绍的 C 语言示例基本相同，也是订阅数据库中所有电流超过 10A 的记录。
@@ -406,7 +404,7 @@ ts: 1597466400000 current: 12.4 voltage: 220 phase: 1 location: Beijing.Chaoyang
```
-## 缓存(Cache)
+## 缓存(Cache)
TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Use，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。
@@ -425,7 +423,7 @@ select last_row(voltage) from meters where location='Beijing.Chaoyang';
该SQL语句将获取所有位于北京朝阳区的电表最后记录的电压值。
-## 报警监测(Alert)
+## 报警监测(Alert)
在 TDengine 的应用场景中，报警监测是一个常见需求，从概念上说，它要求程序从最近一段时间的数据中筛选出符合一定条件的数据，并基于这些数据根据定义好的公式计算出一个结果，当这个结果符合某个条件且持续一定时间后，以某种形式通知用户。
diff --git a/documentation20/webdocs/markdowndocs/connector-java-ch.md b/documentation20/cn/08.connector/01.java/docs.md
similarity index 97%
rename from documentation20/webdocs/markdowndocs/connector-java-ch.md
rename to documentation20/cn/08.connector/01.java/docs.md
index 62c1f11baba7b113749e99537585dc910cfdef15..4141004c4e027a23b9f98c206beb983720a9893c 100644
--- a/documentation20/webdocs/markdowndocs/connector-java-ch.md
+++ b/documentation20/cn/08.connector/01.java/docs.md
@@ -4,7 +4,7 @@ TDengine 提供了遵循 JDBC 标准（3.0）API 规范的 `taos-jdbcdriver` 实
`taos-jdbcdriver` 的实现包括 2 种形式： JDBC-JNI 和 JDBC-RESTful（taos-jdbcdriver-2.0.18 开始支持 JDBC-RESTful）。 JDBC-JNI 通过调用客户端 libtaos.so（或 taos.dll ）的本地方法实现， JDBC-RESTful 则在内部封装了 RESTful 接口实现。
-
+
上图显示了 3 种 Java 应用使用连接器访问 TDengine 的方式：
@@ -119,7 +119,7 @@ Connection conn = DriverManager.getConnection(jdbcUrl);
> 在 windows 环境开发时需要安装 TDengine 对应的 [windows 客户端][14]，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端][15] 连接远程 TDengine Server。
-JDBC-JNI 的使用请参见视频教程。
+JDBC-JNI 的使用请参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1955.html)。
TDengine 的 JDBC URL 规范格式为：
`jdbc:[TAOS|TAOS-RS]://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
@@ -170,6 +170,7 @@ properties 中的配置参数如下：
如下所示：
1. 在 Java 应用中不指定 hostname 和 port
+
```java
public Connection getConn() throws Exception{
Class.forName("com.taosdata.jdbc.TSDBDriver");
@@ -182,7 +183,9 @@ public Connection getConn() throws Exception{
return conn;
}
```
+
2. 在配置文件中指定 firstEp 和 secondEp
+
```
# first fully qualified domain name (FQDN) for TDengine system
firstEp cluster_node1:6030
@@ -191,7 +194,7 @@ firstEp cluster_node1:6030
secondEp cluster_node2:6030
# default system charset
-# charset UTF-8
+# charset UTF-8
# system locale
# locale en_US.UTF-8
@@ -322,6 +325,7 @@ conn.close();
**HikariCP**
* 引入相应 HikariCP maven 依赖：
+
```xml
com.zaxxer
@@ -331,6 +335,7 @@ conn.close();
```
* 使用示例如下：
+
```java
public static void main(String[] args) throws SQLException {
HikariConfig config = new HikariConfig();
@@ -374,6 +379,7 @@ conn.close();
```
* 使用示例如下：
+
```java
public static void main(String[] args) throws Exception {
@@ -479,7 +485,7 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
[10]: https://maven.aliyun.com/mvn/search
[11]: https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/SpringJdbcTemplate
[12]: https://github.com/taosdata/TDengine/tree/develop/tests/examples/JDBC/springbootdemo
-[13]: https://www.taosdata.com/cn/documentation20/administrator/#%E5%AE%A2%E6%88%B7%E7%AB%AF%E9%85%8D%E7%BD%AE
+[13]: https://www.taosdata.com/cn/documentation/administrator/#client
[14]: https://www.taosdata.com/cn/all-downloads/#TDengine-Windows-Client
-[15]: https://www.taosdata.com/cn/getting-started/#%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B
+[15]: https://www.taosdata.com/cn/getting-started/#%E5%AE%A2%E6%88%B7%E7%AB%AF
diff --git a/documentation20/webdocs/markdowndocs/connector-ch.md b/documentation20/cn/08.connector/docs.md
similarity index 89%
rename from documentation20/webdocs/markdowndocs/connector-ch.md
rename to documentation20/cn/08.connector/docs.md
index 6736eea7c75ec12f017aa272385d4301c7875317..f3c2363d6c712c0323bcfeeb1c3a01d5df32ca63 100644
--- a/documentation20/webdocs/markdowndocs/connector-ch.md
+++ b/documentation20/cn/08.connector/docs.md
@@ -2,7 +2,7 @@
TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用。
-
+
目前TDengine的连接器可支持的平台广泛，包括：X64/X86/ARM64/ARM32/MIPS/Alpha等硬件平台，以及Linux/Win64/Win32等开发环境。对照矩阵如下：
@@ -24,8 +24,9 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
* 在没有安装TDengine服务端软件的系统中使用连接器（除RESTful外）访问 TDengine 数据库，需要安装相应版本的客户端安装包来使应用驱动（Linux系统中文件名为libtaos.so，Windows系统中为taos.dll）被安装在系统中，否则会产生无法找到相应库文件的错误。
* 所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
* 升级到TDengine到2.0.8.0版本的用户，必须更新JDBC连接TDengine必须升级taos-jdbcdriver到2.0.12及以上。
+* 无论选用何种编程语言的连接器，2.0 及以上版本的 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池，以避免连接内的“USE statement”状态量在线程之间相互干扰（但连接的查询和写入操作都是线程安全的）。
-## 安装连接器驱动步骤
+## 安装连接器驱动步骤
服务器应该已经安装TDengine服务端安装包。连接器驱动安装步骤如下：
@@ -136,7 +137,7 @@ taos>
taos>
```
-## C/C++ Connector
+## C/C++ Connector
**C/C++连接器支持的系统有**：
@@ -156,7 +157,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
* 在编译时需要链接TDengine动态库。Linux 为 *libtaos.so* ，安装后，位于 _/usr/local/taos/driver_。Windows为 taos.dll，安装后位于 *C:\TDengine*。
* 如未特别说明，当API的返回值是整数时，_0_ 代表成功，其它是代表失败原因的错误码，当返回值是指针时， _NULL_ 表示失败。
-使用C/C++连接器的示例代码请参见 https://github.com/taosdata/TDengine/tree/develop/tests/examples/c。
+使用C/C++连接器的示例代码请参见 https://github.com/taosdata/TDengine/tree/develop/tests/examples/c 。
### 基础API
@@ -238,13 +239,13 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
获取查询结果集每列数据的属性（数据类型、名字、字节数），与taos_num_fileds配合使用，可用来解析`taos_fetch_row`返回的一个元组(一行)的数据。 `TAOS_FIELD` 的结构如下：
- ```c
- typedef struct taosField {
- char name[65]; // 列名
- uint8_t type; // 数据类型
- int16_t bytes; // 字节数
- } TAOS_FIELD;
- ```
+```c
+typedef struct taosField {
+ char name[65]; // 列名
+ uint8_t type; // 数据类型
+ int16_t bytes; // 字节数
+} TAOS_FIELD;
+```
- `void taos_stop_query(TAOS_RES *res)`
@@ -266,7 +267,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
### 异步查询API
-同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2\~4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。
+同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2～4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。
异步API都需要应用提供相应的回调函数，回调函数参数设置如下：前两个参数都是一致的，第三个参数依不同的API而定。第一个参数param是应用调用异步API时提供给系统的，用于回调时，应用能够找回具体操作的上下文，依具体实现而定。第二个参数是SQL操作的结果集，如果为空，比如insert操作，表示没有记录返回，如果不为空，比如select操作，表示有记录返回。
@@ -306,17 +307,17 @@ TDengine的异步API均采用非阻塞调用模式。应用程序可以用多线
进行参数绑定，bind指向一个数组，需保证此数组的元素数量和顺序与sql语句中的参数完全一致。TAOS_BIND 的使用方法与 MySQL中的 MYSQL_BIND 一致，具体定义如下：
- ```c
- typedef struct TAOS_BIND {
- int buffer_type;
- void * buffer;
- unsigned long buffer_length; // 未实际使用
- unsigned long *length;
- int * is_null;
- int is_unsigned; // 未实际使用
- int * error; // 未实际使用
- } TAOS_BIND;
- ```
+```c
+typedef struct TAOS_BIND {
+ int buffer_type;
+ void * buffer;
+ unsigned long buffer_length; // 未实际使用
+ unsigned long *length;
+ int * is_null;
+ int is_unsigned; // 未实际使用
+ int * error; // 未实际使用
+} TAOS_BIND;
+```
- `int taos_stmt_add_batch(TAOS_STMT *stmt)`
@@ -385,12 +386,12 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
取消订阅。 如参数 `keepProgress` 不为0，API会保留订阅的进度信息，后续调用 `taos_subscribe` 时可以基于此进度继续；否则将删除进度信息，后续只能重新开始读取数据。
-## Python Connector
+## Python Connector
-Python连接器的使用参见视频教程
+Python连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1963.html)
### 安装准备
-* 应用驱动安装请参考安装连接器驱动步骤。
+* 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
* 已安装python 2.7 or >= 3.4
* 已安装pip 或 pip3
@@ -431,6 +432,7 @@ python -m pip install python3\
import taos
```
* 获取连接并获取游标对象
+
```python
conn = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos")
c1 = conn.cursor()
@@ -438,6 +440,7 @@ c1 = conn.cursor()
* host 是TDengine 服务端所有IP, config 为客户端配置文件所在目录
* 写入数据
+
```python
import datetime
@@ -459,6 +462,7 @@ affected_rows = c1.execute(' '.join(sqlcmd))
```
* 查询数据
+
```python
c1.execute('select * from tb')
# 拉取查询结果
@@ -476,6 +480,7 @@ for data in c1:
```
* 创建订阅
+
```python
# 创建一个主题为 'test' 消费周期为1000毫秒的订阅
# 第一个参数为 True 表示重新开始订阅，如为 False 且之前创建过主题为 'test' 的订阅，则表示继续消费此订阅的数据，而不是重新开始消费所有数据
@@ -483,6 +488,7 @@ sub = conn.subscribe(True, "test", "select * from tb;", 1000)
```
* 消费订阅的数据
+
```python
data = sub.consume()
for d in data:
@@ -490,15 +496,18 @@ for d in data:
```
* 取消订阅
+
```python
sub.close()
```
* 关闭连接
+
```python
c1.close()
conn.close()
```
+
#### 帮助信息
用户可通过python的帮助信息直接查看模块的使用信息，或者参考tests/examples/python中的示例程序。以下为部分常用类和方法：
@@ -518,6 +527,7 @@ conn.close()
用于生成taos.TDengineConnection的实例。
### Python客户端使用示例代码
+
在tests/examples/python中，我们提供了一个示例Python程序read_example.py，可以参考这个程序来设计用户自己的写入、查询程序。在安装了对应的客户端后，通过import taos引入taos类。主要步骤如下
- 通过taos.connect获取TDengineConnection对象，这个对象可以一个程序只申请一个，在多线程中共享。
@@ -527,9 +537,9 @@ conn.close()
- 如果执行的是查询语句，则execute执行成功后，需要通过fetchall方法去拉取结果集。
具体方法可以参考示例代码。
-## RESTful Connector
+## RESTful Connector
-为支持各种不同类型平台的开发，TDengine提供符合REST设计标准的API，即RESTful API。为最大程度降低学习成本，不同于其他数据库RESTful API的设计方法，TDengine直接通过HTTP POST 请求BODY中包含的SQL语句来操作数据库，仅需要一个URL。RESTful连接器的使用参见视频教程。
+为支持各种不同类型平台的开发，TDengine提供符合REST设计标准的API，即RESTful API。为最大程度降低学习成本，不同于其他数据库RESTful API的设计方法，TDengine直接通过HTTP POST 请求BODY中包含的SQL语句来操作数据库，仅需要一个URL。RESTful连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。
### HTTP请求格式
@@ -713,21 +723,21 @@ HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间
### 重要配置项
-下面仅列出一些与RESTFul接口有关的配置参数，其他系统参数请看配置文件里的说明。注意：配置修改后，需要重启taosd服务才能生效
+下面仅列出一些与RESTful接口有关的配置参数，其他系统参数请看配置文件里的说明。注意：配置修改后，需要重启taosd服务才能生效
-- httpPort: 对外提供RESTFul服务的端口号，默认绑定到6041
+- httpPort: 对外提供RESTful服务的端口号，默认绑定到6041
- httpMaxThreads: 启动的线程数量，默认为2
- restfulRowLimit: 返回结果集（JSON格式）的最大条数，默认值为10240
- httpEnableCompress: 是否支持压缩，默认不支持，目前TDengine仅支持gzip压缩格式
- httpDebugFlag: 日志开关，131：仅错误和报警信息，135：调试信息，143：非常详细的调试信息，默认131
-## CSharp Connector
+## CSharp Connector
C#连接器支持的系统有：Linux 64/Windows x64/Windows x86
### 安装准备
-* 应用驱动安装请参考安装连接器驱动步骤。
+* 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
* .NET接口文件TDengineDrivercs.cs和参考程序示例TDengineTest.cs均位于Windows客户端install_directory/examples/C#目录下。
* 在Windows系统上，C#应用程序可以使用TDengine的原生C接口来执行所有数据库操作，后续版本将提供ORM（dapper）框架驱动。
@@ -766,15 +776,15 @@ https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos
https://www.taosdata.com/blog/2020/11/02/1901.html
```
-## Go Connector
+## Go Connector
### 安装准备
-* 应用驱动安装请参考安装连接器驱动步骤。
+* 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
TDengine提供了GO驱动程序`taosSql`。 `taosSql`实现了GO语言的内置接口`database/sql/driver`。用户只需按如下方式引入包就可以在应用程序中访问TDengine, 详见`https://github.com/taosdata/driver-go/blob/develop/taosSql/driver_test.go`。
-使用 Go 连接器的示例代码请参考 https://github.com/taosdata/TDengine/tree/develop/tests/examples/go 以及视频教程。
+使用 Go 连接器的示例代码请参考 https://github.com/taosdata/TDengine/tree/develop/tests/examples/go 以及[视频教程](https://www.taosdata.com/blog/2020/11/11/1951.html)。
```Go
import (
@@ -821,7 +831,7 @@ go env -w GOPROXY=https://goproxy.io,direct
sql.Open内置的方法，Close closes the statement.
-## Node.js Connector
+## Node.js Connector
Node.js连接器支持的系统有：
@@ -830,47 +840,47 @@ Node.js连接器支持的系统有：
| **OS类型** | Linux | Win64 | Win32 | Linux | Linux |
| **支持与否** | **支持** | **支持** | **支持** | **支持** | **支持** |
-Node.js连接器的使用参见视频教程
+Node.js连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1957.html)
### 安装准备
-* 应用驱动安装请参考安装连接器驱动步骤。
+* 应用驱动安装请参考[安装连接器驱动步骤](https://www.taosdata.com/cn/documentation/connector#driver)。
### 安装Node.js连接器
-用户可以通过npm来进行安装，也可以通过源代码*src/connector/nodejs/* 来进行安装。具体安装步骤如下：
+用户可以通过[npm](https://www.npmjs.com/)来进行安装，也可以通过源代码*src/connector/nodejs/* 来进行安装。具体安装步骤如下：
-首先，通过npm安装node.js 连接器.
+首先，通过[npm](https://www.npmjs.com/)安装node.js 连接器.
```bash
npm install td2.0-connector
```
我们建议用户使用npm 安装node.js连接器。如果您没有安装npm, 可以将*src/connector/nodejs/*拷贝到您的nodejs 项目目录下
-我们使用node-gyp和TDengine服务端进行交互。安装node.js 连接器之前，还需安装以下软件：
+我们使用[node-gyp](https://github.com/nodejs/node-gyp)和TDengine服务端进行交互。安装node.js 连接器之前，还需安装以下软件：
### Linux
- `python` (建议`v2.7` , `v3.x.x` 目前还不支持)
- `node` 2.0.6支持v12.x和v10.x，2.0.5及更早版本支持v10.x版本，其他版本可能存在包兼容性的问题。
- `make`
-- c语言编译器比如GCC
+- c语言编译器比如[GCC](https://gcc.gnu.org)
### Windows
#### 安装方法1
-使用微软的windows-build-tools在`cmd` 命令行界面执行`npm install --global --production windows-build-tools` 即可安装所有的必备工具
+使用微软的[windows-build-tools](https://github.com/felixrieseberg/windows-build-tools)在`cmd` 命令行界面执行`npm install --global --production windows-build-tools` 即可安装所有的必备工具
#### 安装方法2
手动安装以下工具:
-- 安装Visual Studio相关：Visual Studio 2017 Community
-- 安装 Python 2.7(`v3.x.x` 暂不支持) 并执行 `npm config set python python2.7`
+- 安装Visual Studio相关：[Visual Studio Build 工具](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools) 或者 [Visual Studio 2017 Community](https://visualstudio.microsoft.com/pl/thank-you-downloading-visual-studio/?sku=Community)
+- 安装 [Python](https://www.python.org/downloads/) 2.7(`v3.x.x` 暂不支持) 并执行 `npm config set python python2.7`
- 进入`cmd`命令行界面, `npm config set msvs_version 2017`
-如果以上步骤不能成功执行, 可以参考微软的node.js用户手册Microsoft's Node.js Guidelines for Windows
+如果以上步骤不能成功执行, 可以参考微软的node.js用户手册[Microsoft's Node.js Guidelines for Windows](https://github.com/Microsoft/nodejs-guidelines/blob/master/windows-environment.md#compiling-native-addon-modules)
如果在Windows 10 ARM 上使用ARM64 Node.js, 还需添加 "Visual C++ compilers and libraries for ARM64" 和 "Visual C++ ATL for ARM64".
@@ -887,7 +897,7 @@ Node-example-raw.js
验证方法：
-1. 新建安装验证目录，例如：\~/tdengine-test，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。
+1. 新建安装验证目录，例如：`~/tdengine-test`，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。
2. 在命令中执行以下命令：
@@ -901,8 +911,7 @@ node nodejsChecker.js host=localhost
### Node.js连接器的使用
-(http://docs.taosdata.com/node)
-以下是node.js 连接器的一些基本使用方法，详细的使用方法可参考该文档
+以下是node.js 连接器的一些基本使用方法，详细的使用方法可参考[TDengine Node.js connector](http://docs.taosdata.com/node)
#### 建立连接
@@ -973,6 +982,7 @@ promise.then(function(result) {
})
```
#### 异步函数
+
异步查询数据库的操作和上面类似，只需要在`cursor.execute`, `TaosQuery.execute`等函数后面加上`_a`。
```javascript
var promise1 = cursor.query('select count(*), avg(v1), avg(v2) from meter1;').execute_a()
@@ -986,6 +996,7 @@ promise2.then(function(result) {
```
### 示例
-这里提供了一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例
-这里同样是一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用`cursor`.
+[node-example.js](https://github.com/taosdata/TDengine/tree/master/tests/examples/nodejs/node-example.js)提供了一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例
+
+[node-example-raw.js](https://github.com/taosdata/TDengine/tree/master/tests/examples/nodejs/node-example-raw.js)同样是一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用`cursor`.
diff --git a/documentation20/webdocs/markdowndocs/Connections with other Tools-ch.md b/documentation20/cn/09.connections/docs.md
similarity index 79%
rename from documentation20/webdocs/markdowndocs/Connections with other Tools-ch.md
rename to documentation20/cn/09.connections/docs.md
index 4e55f3c5e8f12f3277898b1f825dca5e22b2e6d1..6a74ee382f9addea255ac6d705e8c9eac82da133 100644
--- a/documentation20/webdocs/markdowndocs/Connections with other Tools-ch.md
+++ b/documentation20/cn/09.connections/docs.md
@@ -1,7 +1,7 @@
# 与其他工具的连接
-## Grafana
+## Grafana
TDengine能够与开源数据可视化系统[Grafana](https://www.grafana.com/)快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。
@@ -21,15 +21,15 @@ TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafanaplugin
用户可以直接通过 localhost:3000 的网址，登录 Grafana 服务器(用户名/密码:admin/admin)，通过左侧 `Configuration -> Data Sources` 可以添加数据源，如下图所示：
-
+
点击 `Add data source` 可进入新增数据源页面，在查询框中输入 TDengine 可选择添加，如下图所示：
-
+
进入数据源配置页面，按照默认提示修改相应配置即可：
-
+
* Host： TDengine 集群的中任意一台服务器的 IP 地址与 TDengine RESTful 接口的端口号(6041)，默认 http://localhost:6041
* User：TDengine 用户名。
@@ -37,13 +37,13 @@ TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafanaplugin
点击 `Save & Test` 进行测试，成功会有如下提示：
-
+
#### 创建 Dashboard
回到主界面创建 Dashboard，点击 Add Query 进入面板查询页面：
-
+
如上图所示，在 Query 中选中 `TDengine` 数据源，在下方查询框可输入相应 sql 进行查询，具体说明如下：
@@ -54,7 +54,7 @@ TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafanaplugin
按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：
-
+
> 关于如何使用Grafana创建相应的监测界面以及更多有关使用Grafana的信息，请参考Grafana官方的[文档](https://grafana.com/docs/)。
@@ -64,14 +64,14 @@ TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafanaplugin
点击左侧 `Import` 按钮，并上传 `tdengine-grafana.json` 文件：
-
+
导入完成之后可看到如下效果：
-
+
-## Matlab
+## Matlab
MatLab可以通过安装包内提供的JDBC Driver直接连接到TDengine获取数据到本地工作空间。
@@ -82,12 +82,15 @@ MatLab的适配有下面几个步骤，下面以Windows10上适配MatLab2017a为
- 将TDengine安装包内的驱动程序JDBCDriver-1.0.0-dist.jar拷贝到${matlab_root}\MATLAB\R2017a\java\jar\toolbox
- 将TDengine安装包内的taos.lib文件拷贝至${matlab_ root _dir}\MATLAB\R2017a\lib\win64
- 将新添加的驱动jar包加入MatLab的classpath。在${matlab_ root _dir}\MATLAB\R2017a\toolbox\local\classpath.txt文件中添加下面一行
-
- `$matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar`
-
+
+```
+$matlabroot/java/jar/toolbox/JDBCDriver-1.0.0-dist.jar
+```
- 在${user_home}\AppData\Roaming\MathWorks\MATLAB\R2017a\下添加一个文件javalibrarypath.txt, 并在该文件中添加taos.dll的路径，比如您的taos.dll是在安装时拷贝到了C:\Windows\System32下，那么就应该在javalibrarypath.txt中添加如下一行：
-
- `C:\Windows\System32`
+
+```
+C:\Windows\System32
+```
### 在MatLab中连接TDengine获取数据
@@ -95,23 +98,25 @@ MatLab的适配有下面几个步骤，下面以Windows10上适配MatLab2017a为
- 创建一个连接：
- `conn = database(‘db’, ‘root’, ‘taosdata’, ‘com.taosdata.jdbc.TSDBDriver’, ‘jdbc:TSDB://127.0.0.1:0/’)`
-
+```matlab
+conn = database(‘db’, ‘root’, ‘taosdata’, ‘com.taosdata.jdbc.TSDBDriver’, ‘jdbc:TSDB://127.0.0.1:0/’)
+```
- 执行一次查询：
- `sql0 = [‘select * from tb’]`
-
- `data = select(conn, sql0);`
-
+```matlab
+sql0 = [‘select * from tb’]
+data = select(conn, sql0);
+```
- 插入一条记录:
- `sql1 = [‘insert into tb values (now, 1)’]`
-
- `exec(conn, sql1)`
+```matlab
+sql1 = [‘insert into tb values (now, 1)’]
+exec(conn, sql1)
+```
更多例子细节请参考安装包内examples\Matlab\TDengineDemo.m文件。
-## R
+## R
R语言支持通过JDBC接口来连接TDengine数据库。首先需要安装R语言的JDBC包。启动R语言环境，然后执行以下命令安装R语言的JDBC支持库：
@@ -147,3 +152,10 @@ TDengine客户端暂不支持如下函数：
- dbListTables(conn)：显示连接中的所有表
+## DataX
+
+[DataX](https://github.com/alibaba/DataX) 是阿里巴巴集团开源的一款通用离线数据采集/同步工具，能够简单、高效地接入 TDengine 进行数据写入和读取。
+
+* 数据读取集成的方法请参见 [TSDBReader 插件文档](https://github.com/alibaba/DataX/blob/master/tsdbreader/doc/tsdbreader.md)
+* 数据写入集成的方法请参见 [TSDBWriter 插件文档](https://github.com/alibaba/DataX/blob/master/tsdbwriter/doc/tsdbhttpwriter.md)
+
diff --git a/documentation20/webdocs/markdowndocs/cluster-ch.md b/documentation20/cn/10.cluster/docs.md
similarity index 92%
rename from documentation20/webdocs/markdowndocs/cluster-ch.md
rename to documentation20/cn/10.cluster/docs.md
index f6019b1a5aabdaea095eafc1919c46432ec88c77..15ac449c1aeb576ab9dd3401a717a4364fa4c0b6 100644
--- a/documentation20/webdocs/markdowndocs/cluster-ch.md
+++ b/documentation20/cn/10.cluster/docs.md
@@ -1,19 +1,19 @@
# TDengine 集群安装、管理
-多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看TDengine 2.0整体架构一章。而且在安装集群之前，先请按照[《立即开始》](https://www.taosdata.com/cn/getting-started20/)一章安装并体验单节点功能。
+多个TDengine服务器，也就是多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看TDengine 2.0整体架构一章。而且在安装集群之前，先请按照[《立即开始》](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地址。
TDengine的集群管理极其简单，除添加和删除节点需要人工干预之外，其他全部是自动完成，最大程度的降低了运维的工作量。本章对集群管理的操作做详细的描述。
-关于集群搭建请参考视频教程。
+关于集群搭建请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1961.html)。
-## 准备工作
+## 准备工作
**第零步**：规划集群所有物理节点的FQDN，将规划好的FQDN分别添加到每个物理节点的/etc/hostname；修改每个物理节点的/etc/hosts，将所有集群物理节点的IP与FQDN的对应添加好。【如部署了DNS，请联系网络管理员在DNS上做好相关配置】
-**第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据，具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html )
-**注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/）；
+**第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据，具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html )
+**注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/）；
**注意2：**客户端也需要配置，确保它可以正确解析每个节点的FQDN配置，不管是通过DNS服务，还是 Host 文件。
**第二步**：建议关闭所有物理节点的防火墙，至少保证端口：6030 - 6042的TCP和UDP端口都是开放的。**强烈建议**先关闭防火墙，集群搭建完毕之后，再来配置端口；
@@ -59,15 +59,15 @@ arbitrator ha.taosdata.com:6042
| 8 | charset | 字符集编码 |
| 9 | balance | 是否启动负载均衡 |
| 10 | maxTablesPerVnode | 每个vnode中能够创建的最大表个数 |
-| 11 | maxVgroupsPerDb | 每个DB中 能够使用的最大vnode个数 |
+| 11 | maxVgroupsPerDb | 每个DB中能够使用的最大vgroup个数 |
-## 启动第一个数据节点
+## 启动第一个数据节点
-按照[《立即开始》](https://www.taosdata.com/cn/getting-started20/)里的指示，启动第一个数据节点，例如h1.taosdata.com，然后执行taos, 启动taos shell，从shell里执行命令"show dnodes;"，如下所示：
+按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)里的指示，启动第一个数据节点，例如h1.taosdata.com，然后执行taos, 启动taos shell，从shell里执行命令"show dnodes;"，如下所示：
- ```
+```
Welcome to the TDengine shell from Linux, Client Version:2.0.0.0
Copyright (c) 2017 by TAOS Data, Inc. All rights reserved.
@@ -78,15 +78,15 @@ taos> show dnodes;
Query OK, 1 row(s) in set (0.006385s)
taos>
- ```
+```
上述命令里，可以看到这个刚启动的这个数据节点的End Point是：h1.taos.com:6030，就是这个新集群的firstEP。
-## 启动后续数据节点
+## 启动后续数据节点
将后续的数据节点添加到现有集群，具体有以下几步：
-1. 按照["立即开始“](https://www.taosdata.com/cn/getting-started/)一章的方法在每个物理节点启动taosd；
+1. 按照[《立即开始》](https://www.taosdata.com/cn/documentation/getting-started/)一章的方法在每个物理节点启动taosd；
2. 在第一个数据节点，使用CLI程序taos, 登录进TDengine系统, 执行命令:
@@ -115,7 +115,7 @@ taos>
- firstEp这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的mnode的End Point列表，不再依赖这个参数。
- 两个没有配置firstEp参数的数据节点dnode启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。**无法将两个独立的集群合并成为新的集群**。
-## 数据节点管理
+## 数据节点管理
上面已经介绍如何从零开始搭建集群。集群组建完后，还可以随时添加新的数据节点进行扩容，或删除数据节点，并检查集群当前状态。
@@ -169,7 +169,7 @@ SHOW DNODES;
SHOW VGROUPS;
```
-## vnode的高可用性
+## vnode的高可用性
TDengine通过多副本的机制来提供系统的高可用性，包括vnode和mnode的高可用性。
@@ -185,7 +185,7 @@ CREATE DATABASE demo replica 3;
因为vnode的引入，无法简单的给出结论：“集群中过半数据节点dnode工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为3，只有三个dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个数据节点不工作，那整个集群就无法正常工作了。
-## Mnode的高可用性
+## Mnode的高可用性
TDengine集群是由mnode (taosd的一个模块，管理节点) 负责管理的，为保证mnode的高可用，可以配置多个mnode副本，副本数由系统配置参数numOfMnodes决定，有效范围为1-3。为保证元数据的强一致性，mnode副本之间是通过同步的方式进行数据复制的。
@@ -202,7 +202,7 @@ SHOW MNODES;
**注意：**一个TDengine高可用系统，无论是vnode还是mnode, 都必须配置多个副本。
-## 负载均衡
+## 负载均衡
有三种情况，将触发负载均衡，而且都无需人工干预。
@@ -214,7 +214,7 @@ SHOW MNODES;
**【提示】负载均衡由参数balance控制，它决定是否启动自动负载均衡。**
-## 数据节点离线处理
+## 数据节点离线处理
如果一个数据节点离线，TDengine集群将自动检测到。有如下两种情况：
@@ -223,7 +223,7 @@ SHOW MNODES;
**注意：**如果一个虚拟节点组（包括mnode组）里所归属的每个数据节点都处于离线或unsynced状态，必须等该虚拟节点组里的所有数据节点都上线、都能交换状态信息后，才能选出Master，该虚拟节点组才能对外提供服务。比如整个集群有3个数据节点，副本数为3，如果3个数据节点都宕机，然后2个数据节点重启，是无法工作的，只有等3个数据节点都重启成功，才能对外服务。
-## Arbitrator的使用
+## Arbitrator的使用
如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了Arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含Arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到Arbitrator，那么节点B就能正常工作。
diff --git a/documentation20/webdocs/markdowndocs/administrator-ch.md b/documentation20/cn/11.administrator/docs.md
similarity index 91%
rename from documentation20/webdocs/markdowndocs/administrator-ch.md
rename to documentation20/cn/11.administrator/docs.md
index 7c8344d9ca5cb2c9738c9b308406a6c96f871db1..86ad8e5bb91e8883b4be4a2bec7b5fb7dcb4c483 100644
--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -1,12 +1,12 @@
# TDengine的运营与维护
-## 容量规划
+## 容量规划
使用TDengine来搭建一个物联网大数据平台，计算资源、存储资源需要根据业务场景进行规划。下面分别讨论系统运行所需要的内存、CPU以及硬盘空间。
### 内存需求
-每个DB可以创建固定数目的vnode，默认与CPU核数相同，可通过maxVgroupsPerDb配置；每个vnode会占用固定大小的内存（大小与数据库的配置参数blocks和cache有关)；每个Table会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个DB需要的系统内存可通过如下公式计算：
+每个DB可以创建固定数目的vgroup，默认与CPU核数相同，可通过maxVgroupsPerDb配置；vgroup中的每个副本会是一个vnode；每个vnode会占用固定大小的内存（大小与数据库的配置参数blocks和cache有关)；每个Table会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个DB需要的系统内存可通过如下公式计算：
```
Memory Size = maxVgroupsPerDb * (blocks * cache + 10Mb) + numOfTables * (tagSizePerTable + 0.5Kb)
@@ -47,9 +47,9 @@ Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
因为TDengine具有很好的水平扩展能力，根据总量，再根据单个物理机或虚拟机的资源，就可以轻松决定需要购置多少台物理机或虚拟机了。
-**立即计算CPU、内存、存储，请参见：资源估算方法**
+**立即计算CPU、内存、存储，请参见：[资源估算方法](https://www.taosdata.com/config/config.html)**
-## 容错和灾备
+## 容错和灾备
### 容错
@@ -76,7 +76,7 @@ TDengine集群的节点数必须大于等于副本数，否则创建表时将报
当TDengine集群中的节点部署在不同的物理机上，并设置多个副本数时，就实现了系统的高可靠性，无需再使用其他软件或工具。TDengine企业版还可以将副本部署在不同机房，从而实现异地容灾。
-## 服务端配置
+## 服务端配置
TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修改配置参数，以满足不同场景的需求。配置文件的缺省位置在/etc/taos目录，可以通过taosd命令行执行参数-c指定配置文件目录。比如taosd -c /home/user来指定配置文件位于/home/user这个目录。
@@ -102,7 +102,7 @@ taosd -C
- maxSQLLength：单条SQL语句允许最长限制。默认值：65380字节。
- telemetryReporting: 是否允许 TDengine 采集和上报基本使用信息，0表示不允许，1表示允许。 默认值：1。
- stream: 是否启用连续查询（流计算功能），0表示不允许，1表示允许。 默认值：1。
-- queryBufferSize: 为所有并发查询占用保留的内存大小。计算规则可以根据实际应用可能的最大并发数和表的数字相乘，再乘 170 。单位为字节。
+- queryBufferSize: 为所有并发查询占用保留的内存大小。计算规则可以根据实际应用可能的最大并发数和表的数字相乘，再乘 170 。单位为 MB（2.0.15 以前的版本中，此参数的单位是字节）。
- ratioOfQueryCores: 设置查询线程的最大数量。最小值0 表示只有1个查询线程；最大值2表示最大建立2倍CPU核数的查询线程。默认为1，表示最大和CPU核数相等的查询线程。该值可以为小数，即0.5表示最大建立CPU核数一半的查询线程。
**注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030到6042共13个端口，而且必须TCP和UDP都打开。
@@ -111,15 +111,16 @@ taosd -C
- days：一个数据文件存储数据的时间跨度，单位为天，默认值：10。
- keep：数据库中数据保留的天数，单位为天，默认值：3650。
-- minRows: 文件块中记录的最小条数，单位为条，默认值：100。
-- maxRows: 文件块中记录的最大条数，单位为条，默认值：4096。
-- comp: 文件压缩标志位，0：关闭，1:一阶段压缩，2:两阶段压缩。默认值：2。
-- walLevel：WAL级别。1：写wal, 但不执行fsync; 2：写wal, 而且执行fsync。默认值：1。
+- minRows：文件块中记录的最小条数，单位为条，默认值：100。
+- maxRows：文件块中记录的最大条数，单位为条，默认值：4096。
+- comp：文件压缩标志位，0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。
+- walLevel：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。
- fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。
-- cache: 内存块的大小，单位为兆字节（MB），默认值：16。
-- blocks: 每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。
+- cache：内存块的大小，单位为兆字节（MB），默认值：16。
+- blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。
- replica：副本个数，取值范围：1-3。单位为个，默认值：1
- precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms
+- cacheLast：是否在内存中缓存子表 last_row，0：关闭；1：开启。默认值：0。（从 2.0.11 版本开始支持此参数）
对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：
@@ -137,7 +138,7 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
- offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*10（即10天）。
- statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
- maxTablesPerVnode: 每个vnode中能够创建的最大表个数。默认值：1000000。
-- maxVgroupsPerDb: 每个数据库中能够使用的最大vnode个数。
+- maxVgroupsPerDb: 每个数据库中能够使用的最大vgroup个数。
- arbitrator: 系统中裁决器的end point，缺省为空。
- timezone、locale、charset 的配置见客户端配置。
@@ -157,9 +158,9 @@ ALTER DNODE
alter dnode 1 debugFlag 135;
```
-## 客户端配置
+## 客户端配置
-TDengine系统的前台交互客户端应用程序为taos，以及应用驱动，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。更多taos的使用方法请见Shell命令行程序。本节主要说明 taos 客户端应用在配置文件 taos.cfg 文件中使用到的参数。
+TDengine系统的前台交互客户端应用程序为taos，以及应用驱动，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。更多taos的使用方法请见帮助信息 `taos --help`。本节主要说明 taos 客户端应用在配置文件 taos.cfg 文件中使用到的参数。
**2.0.10.0 之后版本支持命令行以下参数显示当前客户端参数的配置**
@@ -247,7 +248,7 @@ taos -C 或 taos --dump-config
Shell中binary 和 nchar字段的显示宽度上限，超过此限制的部分将被隐藏。默认值：30。可在 shell 中通过命令 set max_binary_display_width nn 动态修改此选项。
-## 用户管理
+## 用户管理
系统管理员可以在CLI界面里添加、删除用户，也可以修改密码。CLI里SQL语法如下：
@@ -285,7 +286,7 @@ SHOW USERS;
**注意：**SQL 语法中，< >表示需要用户输入的部分，但请不要输入< >本身
-## 数据导入
+## 数据导入
TDengine提供多种方便的数据导入功能，一种按脚本文件导入，一种按数据文件导入，一种是taosdump工具导入本身导出的文件。
@@ -337,9 +338,9 @@ Query OK, 9 row(s) affected (0.004763s)
**taosdump工具导入**
-TDengine提供了方便的数据库导入导出工具taosdump。用户可以将taosdump从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见博客：TDengine DUMP工具使用指南
+TDengine提供了方便的数据库导入导出工具taosdump。用户可以将taosdump从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见博客：[TDengine DUMP工具使用指南](https://www.taosdata.com/blog/2020/03/09/1334.html)
-## 数据导出
+## 数据导出
为方便数据导出，TDengine提供了两种导出方式，分别是按表导出和用taosdump导出。
@@ -355,9 +356,9 @@ select * from >> data.csv;
**用taosdump导出数据**
-TDengine提供了方便的数据库导出工具taosdump。用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表,所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参见博客：TDengine DUMP工具使用指南
+TDengine提供了方便的数据库导出工具taosdump。用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表,所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参见博客：[TDengine DUMP工具使用指南](https://www.taosdata.com/blog/2020/03/09/1334.html)
-## 系统连接、任务查询管理
+## 系统连接、任务查询管理
系统管理员可以从CLI查询系统的连接、正在进行的查询、流式计算，并且可以关闭连接、停止正在进行的查询和流式计算。CLI里SQL语法如下：
@@ -403,7 +404,7 @@ TDengine启动后，会自动创建一个监测数据库log，并自动将服务
这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项enableMonitor将其关闭或打开。
-## 文件目录结构
+## 文件目录结构
安装TDengine后，默认会在操作系统中生成下列目录或文件：
@@ -429,7 +430,7 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录。
-## TDengine参数限制与保留关键字
+## TDengine参数限制与保留关键字
- 数据库名：不能包含“.”以及特殊字符，不能超过32个字符
- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符
diff --git a/documentation20/webdocs/markdowndocs/Taos Error Code-ch.md b/documentation20/cn/12.taos-sql/01.error-code/docs.md
similarity index 100%
rename from documentation20/webdocs/markdowndocs/Taos Error Code-ch.md
rename to documentation20/cn/12.taos-sql/01.error-code/docs.md
diff --git a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md b/documentation20/cn/12.taos-sql/docs.md
similarity index 88%
rename from documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
rename to documentation20/cn/12.taos-sql/docs.md
index 75c3fb897e4dfa405301b75bf3be24d2c7e17ff8..33321348bb69d93b7449b8469f74d76b6223cf08 100644
--- a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -25,7 +25,7 @@ taos> DESCRIBE meters;
```
数据集包含4个智能电表的数据，按照TDengine的建模规则，对应4个子表，其名称分别是 d1001, d1002, d1003, d1004。
-## 支持的数据类型
+## 支持的数据类型
使用TDengine，最重要的是时间戳。创建并插入记录、查询历史记录的时候，均需要指定时间戳。时间戳有如下规则：
@@ -42,19 +42,21 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
| | 类型 | Bytes | 说明 |
| ---- | :-------: | ------ | ------------------------------------------------------------ |
| 1 | TIMESTAMP | 8 | 时间戳。缺省精度毫秒，可支持微秒。从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始，计时不能早于该时间。 |
-| 2 | INT | 4 | 整型，范围 [-2^31+1, 2^31-1], -2^31用作Null |
-| 3 | BIGINT | 8 | 长整型，范围 [-2^63+1, 2^63-1], -2^63用于NULL |
-| 4 | FLOAT | 4 | 浮点型，有效位数6-7，范围 [-3.4E38, 3.4E38] |
-| 5 | DOUBLE | 8 | 双精度浮点型，有效位数15-16，范围 [-1.7E308, 1.7E308] |
-| 6 | BINARY | 自定义 | 用于记录字符串，理论上，最长可以有16374字节，但由于每行数据最多16K字节，实际上限一般小于理论值。 binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 |
-| 7 | SMALLINT | 2 | 短整型， 范围 [-32767, 32767], -32768用于NULL |
-| 8 | TINYINT | 1 | 单字节整型，范围 [-127, 127], -128用于NULL |
-| 9 | BOOL | 1 | 布尔型，{true, false} |
-| 10 | NCHAR | 自定义 | 用于记录非ASCII字符串，如中文字符。每个nchar字符占用4bytes的存储空间。字符串两端使用单引号引用，字符串内的单引号需用转义字符 **\’**。nchar使用时须指定字符串大小，类型为nchar(10)的列表示此列的字符串最多存储10个nchar字符，会固定占用40bytes的空间。如用户字符串长度超出声明长度，则将会报错。 |
-
-**Tips**: TDengine对SQL语句中的英文字符不区分大小写，自动转化为小写执行。因此用户大小写敏感的字符串及密码，需要使用单引号将字符串引起来。
-
-## 数据库管理
+| 2 | INT | 4 | 整型，范围 [-2^31+1, 2^31-1], -2^31 用作 NULL |
+| 3 | BIGINT | 8 | 长整型，范围 [-2^63+1, 2^63-1], -2^63 用于 NULL |
+| 4 | FLOAT | 4 | 浮点型，有效位数 6-7，范围 [-3.4E38, 3.4E38] |
+| 5 | DOUBLE | 8 | 双精度浮点型，有效位数 15-16，范围 [-1.7E308, 1.7E308] |
+| 6 | BINARY | 自定义 | 用于记录 ASCII 型字符串。理论上，最长可以有 16374 字节，但由于每行数据最多 16K 字节，实际上限一般小于理论值。 binary 仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如 binary(20) 定义了最长为 20 个字符的字符串，每个字符占 1 byte 的存储空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\’`。 |
+| 7 | SMALLINT | 2 | 短整型， 范围 [-32767, 32767], -32768 用于 NULL |
+| 8 | TINYINT | 1 | 单字节整型，范围 [-127, 127], -128 用于 NULL |
+| 9 | BOOL | 1 | 布尔型，{true, false} |
+| 10 | NCHAR | 自定义 | 用于记录非 ASCII 型字符串，如中文字符。每个 nchar 字符占用 4 bytes 的存储空间。字符串两端使用单引号引用，字符串内的单引号需用转义字符 `\’`。nchar 使用时须指定字符串大小，类型为 nchar(10) 的列表示此列的字符串最多存储 10 个 nchar 字符，会固定占用 40 bytes 的空间。如果用户字符串长度超出声明长度，将会报错。 |
+
+**Tips**:
+1. TDengine 对 SQL 语句中的英文字符不区分大小写，自动转化为小写执行。因此用户大小写敏感的字符串及密码，需要使用单引号将字符串引起来。
+2. 应避免使用 BINARY 类型来保存非 ASCII 型的字符串，会很容易导致数据乱码等错误。正确的做法是使用 NCHAR 类型来保存中文字符。
+
+## 数据库管理
- **创建数据库**
@@ -96,27 +98,32 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
```mysql
ALTER DATABASE db_name COMP 2;
```
- COMP参数是指修改数据库文件压缩标志位，取值范围为[0, 2]. 0表示不压缩，1表示一阶段压缩，2表示两阶段压缩。
+ COMP 参数是指修改数据库文件压缩标志位，缺省值为 2，取值范围为 [0, 2]。0 表示不压缩，1 表示一阶段压缩，2 表示两阶段压缩。
```mysql
ALTER DATABASE db_name REPLICA 2;
```
- REPLICA参数是指修改数据库副本数，取值范围[1, 3]。在集群中使用，副本数必须小于或等于dnode的数目。
+ REPLICA 参数是指修改数据库副本数，取值范围 [1, 3]。在集群中使用，副本数必须小于或等于 DNODE 的数目。
```mysql
ALTER DATABASE db_name KEEP 365;
```
- KEEP参数是指修改数据文件保存的天数，缺省值为3650，取值范围[days, 365000]，必须大于或等于days参数值。
+ KEEP 参数是指修改数据文件保存的天数，缺省值为 3650，取值范围 [days, 365000]，必须大于或等于 days 参数值。
```mysql
ALTER DATABASE db_name QUORUM 2;
```
- QUORUM参数是指数据写入成功所需要的确认数。取值范围[1, 3]。对于异步复制，quorum设为1，具有master角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于2。原则上，Quorum >=1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。
+ QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 3]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。
```mysql
ALTER DATABASE db_name BLOCKS 100;
```
- BLOCKS参数是每个VNODE (TSDB) 中有多少cache大小的内存块，因此一个VNODE的用的内存大小粗略为（cache * blocks）。取值范围[3, 1000]。
+ BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块，因此一个 VNODE 的用的内存大小粗略为（cache * blocks）。取值范围 [3, 1000]。
+
+ ```mysql
+ ALTER DATABASE db_name CACHELAST 0;
+ ```
+ CACHELAST 参数控制是否在内存中缓存数据子表的 last_row。缺省值为 0，取值范围 [0, 1]。其中 0 表示不启用、1 表示启用。（从 2.0.11 版本开始支持）
**Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。
@@ -126,7 +133,8 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
SHOW DATABASES;
```
-## 表管理
+## 表管理
+
- **创建数据表**
```mysql
@@ -151,6 +159,14 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
```
以指定的超级表为模板，指定 tags 的值来创建数据表。
+- **以超级表为模板创建数据表，并指定具体的 tags 列**
+
+ ```mysql
+ CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...);
+ ```
+ 以指定的超级表为模板，指定一部分 tags 列的值来创建数据表。（没被指定的 tags 列会设为空值。）
+ 说明：从 2.0.17 版本开始支持这种方式。在之前的版本中，不允许指定 tags 列，而必须显式给出所有 tags 列的取值。
+
- **批量创建数据表**
```mysql
@@ -212,7 +228,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
```
如果表是通过[超级表](../super-table/)创建，更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表，可以直接修改表结构
-## 超级表STable管理
+## 超级表STable管理
注意：在 2.0.15 以前的版本中，并不支持 STABLE 保留字，而是写作 TABLE。也即，在本节后文的指令说明中，CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
@@ -265,7 +281,8 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
ALTER STABLE stb_name DROP COLUMN field_name;
```
-## 超级表 STable 中 TAG 管理
+## 超级表 STable 中 TAG 管理
+
- **添加标签**
```mysql
@@ -294,7 +311,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
```
说明：除了更新标签的值的操作是针对子表进行，其他所有的标签操作（添加标签、删除标签等）均只能作用于 STable，不能对单个子表操作。对 STable 添加标签以后，依托于该 STable 建立的所有表将自动增加了一个标签，所有新增标签的默认值都是 NULL。
-## 数据写入
+## 数据写入
- **插入一条记录**
```mysql
@@ -304,7 +321,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
- **插入一条记录，数据对应到指定的列**
```mysql
- INSERT INTO tb_name (field1_name, ...) VALUES (field1_value, ...)
+ INSERT INTO tb_name (field1_name, ...) VALUES (field1_value1, ...);
```
向表tb_name中插入一条记录，数据对应到指定的列。SQL语句中没有出现的列，数据库将自动填充为NULL。主键（时间戳）不能为NULL。
@@ -334,29 +351,21 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
```
同时向表tb1_name和tb2_name中按列分别插入多条记录
- 注意：
- 1) 如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳；
- 2) 允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
+ 注意：允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
-**历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
-
-## 数据查询
+- **插入记录时自动建表**
+ ```mysql
+ INSERT INTO tb_name USING stb_name TAGS (tag_value1, ...) VALUES (field_value1, ...);
+ ```
+ 如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 tags 取值。
-### 查询语法：
+- **插入记录时自动建表，并指定具体的 tags 列**
+ ```mysql
+ INSERT INTO tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...) VALUES (field_value1, ...);
+ ```
+ 在自动建表时，可以只是指定部分 tags 列的取值，未被指定的 tags 列将取为空值。
-```mysql
-SELECT select_expr [, select_expr ...]
- FROM {tb_name_list}
- [WHERE where_condition]
- [INTERVAL (interval_val [, interval_offset])]
- [FILL fill_val]
- [SLIDING fill_val]
- [GROUP BY col_list]
- [ORDER BY col_list { DESC | ASC }]
- [SLIMIT limit_val [, SOFFSET offset_val]]
- [LIMIT limit_val [, OFFSET offset_val]]
- [>> export_file]
-```
+**历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
说明：针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分SQL仍会执行。下面的sql中，insert语句是无效的，但是d1001仍会被创建。
@@ -384,10 +393,30 @@ taos> SHOW TABLES;
Query OK, 1 row(s) in set (0.001091s)
```
+## 数据查询
+
+### 查询语法：
+
+```mysql
+SELECT select_expr [, select_expr ...]
+ FROM {tb_name_list}
+ [WHERE where_condition]
+ [INTERVAL (interval_val [, interval_offset])]
+ [FILL fill_val]
+ [SLIDING fill_val]
+ [GROUP BY col_list]
+ [ORDER BY col_list { DESC | ASC }]
+ [SLIMIT limit_val [, SOFFSET offset_val]]
+ [LIMIT limit_val [, OFFSET offset_val]]
+ [>> export_file];
+```
+
#### SELECT子句
+
一个选择子句可以是联合查询（UNION）和另一个查询的子查询（SUBQUERY）。
##### 通配符
+
通配符 * 可以用于代指全部列。对于普通表，结果中只有普通列。
```mysql
taos> SELECT * FROM d1001;
@@ -496,6 +525,7 @@ Query OK, 3 row(s) in set (0.001191s)
但是针对```first(*)```、```last(*)```、```last_row(*)```不支持针对单列的重命名。
#### 隐式结果列
+
```Select_exprs```可以是表所属列的列名，也可以是基于列的函数表达式或计算式，数量的上限256个。当用户使用了```interval```或```group by tags```的子句以后，在最后返回结果中会强制返回时间戳列（第一列）和group by子句中的标签列。后续的版本中可以支持关闭group by子句中隐式列的输出，列输出完全由select子句控制。
#### 表（超级表）列表
@@ -510,6 +540,7 @@ SELECT * FROM d1001;
```
#### 特殊功能
+
部分特殊的查询功能可以不使用FROM子句执行。获取当前所在的数据库 database()
```mysql
taos> SELECT DATABASE();
@@ -554,12 +585,14 @@ taos> SELECT SERVER_STATUS() AS status;
1 |
Query OK, 1 row(s) in set (0.000081s)
```
+
#### TAOS SQL中特殊关键词
> TBNAME： 在超级表查询中可视为一个特殊的标签，代表查询涉及的子表名
\_c0: 表示表（超级表）的第一列
#### 小技巧
+
获取一个超级表所有的子表名及相关的标签信息：
```mysql
SELECT TBNAME, location FROM meters;
@@ -640,7 +673,7 @@ Query OK, 1 row(s) in set (0.001091s)
SELECT COUNT(*) FROM tb1 WHERE ts >= NOW - 10m AND col2 > 3.14 >> /home/testoutpu.csv;
```
-## SQL 函数
+## SQL 函数
### 聚合函数
@@ -1119,7 +1152,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
Query OK, 3 row(s) in set (0.001046s)
```
-## 时间维度聚合
+## 时间维度聚合
+
TDengine支持按时间段进行聚合，可以将表中数据按照时间段进行切割后聚合生成结果，比如温度传感器每秒采集一次数据，但需查询每隔10分钟的温度平均值。这个聚合适合于降维(down sample)操作, 语法如下：
```mysql
@@ -1138,10 +1172,10 @@ SELECT function_list FROM stb_name
- 聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a），并且支持偏移（偏移必须小于间隔）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。
- WHERE语句可以指定查询的起止时间和其他过滤条件
- FILL语句指定某一时间区间数据缺失的情况下的填充模式。填充模式包括以下几种：
- 1. 不进行填充：NONE(默认填充模式)。
- 2. VALUE填充：固定值填充，此时需要指定填充的数值。例如：fill(value, 1.23)。
- 3. NULL填充：使用NULL填充数据。例如：fill(null)。
- 4. PREV填充：使用前一个非NULL值填充数据。例如：fill(prev)。
+ * 不进行填充：NONE(默认填充模式)。
+ * VALUE填充：固定值填充，此时需要指定填充的数值。例如：fill(value, 1.23)。
+ * NULL填充：使用NULL填充数据。例如：fill(null)。
+ * PREV填充：使用前一个非NULL值填充数据。例如：fill(prev)。
说明：
1. 使用FILL语句的时候可能生成大量的填充输出，务必指定查询的时间区间。针对每次查询，系统可返回不超过1千万条具有插值的结果。
@@ -1164,7 +1198,8 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P
FILL(PREV);
```
-## TAOS SQL 边界限制
+## TAOS SQL 边界限制
+
- 数据库名最大长度为32
- 表名最大长度为192，每行数据最大长度16k个字符
- 列名最大长度为64，最多允许1024列，最少需要2列，第一列必须是时间戳
diff --git a/documentation20/webdocs/markdowndocs/faq-ch.md b/documentation20/cn/13.faq/docs.md
similarity index 81%
rename from documentation20/webdocs/markdowndocs/faq-ch.md
rename to documentation20/cn/13.faq/docs.md
index cd6f0ae08caf19340b6cef9a9428abcb66c97dc6..4e72cbb21af95af034002fade0ce1b50cd8ccbc4 100644
--- a/documentation20/webdocs/markdowndocs/faq-ch.md
+++ b/documentation20/cn/13.faq/docs.md
@@ -6,7 +6,7 @@
1. /var/log/taos （如果没有修改过默认路径）
2. /etc/taos
-附上必要的问题描述，包括使用的 TDengine 版本信息、平台环境信息、发生该问题的执行操作、出现问题的表征及大概的时间，在 GitHub提交Issue。
+附上必要的问题描述，包括使用的 TDengine 版本信息、平台环境信息、发生该问题的执行操作、出现问题的表征及大概的时间，在 [GitHub](https://github.com/taosdata/TDengine) 提交Issue。
为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
```
@@ -25,13 +25,16 @@
5. 如果数据需要迁移数据或者数据文件损坏，请联系涛思数据官方技术支持团队，进行协助解决
## 2. Windows平台下JDBCDriver找不到动态链接库，怎么办？
-请看为此问题撰写的技术博客
+
+请看为此问题撰写的[技术博客](https://www.taosdata.com/blog/2019/12/03/jdbcdriver找不到动态链接库/)
## 3. 创建数据表时提示more dnodes are needed
-请看为此问题撰写的技术博客
+
+请看为此问题撰写的[技术博客](https://www.taosdata.com/blog/2019/12/03/创建数据表时提示more-dnodes-are-needed/)
## 4. 如何让TDengine crash时生成core文件？
-请看为此问题撰写的技术博客
+
+请看为此问题撰写的[技术博客](https://www.taosdata.com/blog/2019/12/06/tdengine-crash时生成core文件的方法/)
## 5. 遇到错误"Unable to establish connection", 我怎么办？
@@ -46,7 +49,7 @@
3. 在服务器，执行 `systemctl status taosd` 检查*taosd*运行状态。如果没有运行，启动*taosd*
-4. 确认客户端连接时指定了正确的服务器FQDN (Fully Qualified Domain Name(可在服务器上执行Linux命令hostname -f获得)）,FQDN配置参考：一篇文章说清楚TDengine的FQDN。
+4. 确认客户端连接时指定了正确的服务器FQDN (Fully Qualified Domain Name(可在服务器上执行Linux命令hostname -f获得)）,FQDN配置参考：[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)。
5. ping服务器FQDN，如果没有反应，请检查你的网络，DNS设置，或客户端所在计算机的系统hosts文件
@@ -65,12 +68,12 @@
* Windows 系统请使用 PowerShell 命令 Net-TestConnection -ComputerName {fqdn} -Port {port} 检测服务段端口是否访问
-10. 也可以使用taos程序内嵌的网络连通检测功能，来验证服务器和客户端之间指定的端口连接是否通畅（包括TCP和UDP）：TDengine 内嵌网络检测工具使用指南。
+10. 也可以使用taos程序内嵌的网络连通检测功能，来验证服务器和客户端之间指定的端口连接是否通畅（包括TCP和UDP）：[TDengine 内嵌网络检测工具使用指南](https://www.taosdata.com/blog/2020/09/08/1816.html)。
## 6. 遇到错误“Unexpected generic error in RPC”或者"TDengine Error: Unable to resolve FQDN"， 我怎么办？
产生这个错误，是由于客户端或数据节点无法解析FQDN(Fully Qualified Domain Name)导致。对于TAOS Shell或客户端应用，请做如下检查：
-1. 请检查连接的服务器的FQDN是否正确,FQDN配置参考：一篇文章说清楚TDengine的FQDN。
+1. 请检查连接的服务器的FQDN是否正确,FQDN配置参考：[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)。
2. 如果网络配置有DNS server, 请检查是否正常工作
3. 如果网络没有配置DNS server, 请检查客户端所在机器的hosts文件，查看该FQDN是否配置，并是否有正确的IP地址。
4. 如果网络配置OK，从客户端所在机器，你需要能Ping该连接的FQDN，否则客户端是无法连接服务器的
@@ -106,10 +109,9 @@ Properties properties = new Properties();
properties.setProperty(TSDBDriver.LOCALE_KEY, "UTF-8");
Connection = DriverManager.getConnection(url, properties);
```
-## 12.TDengine GO windows驱动的如何编译？
-请看为此问题撰写的技术博客
-## 13.JDBC报错： the excuted SQL is not a DML or a DDL？
+## 12.JDBC报错： the excuted SQL is not a DML or a DDL？
+
请更新至最新的JDBC驱动
```JAVA
@@ -118,15 +120,16 @@ Connection = DriverManager.getConnection(url, properties);
2.0.4
```
-## 14. taos connect failed, reason: invalid timestamp
+
+## 13. taos connect failed, reason: invalid timestamp
常见原因是服务器和客户端时间没有校准，可以通过和时间服务器同步的方式（Linux 下使用 ntpdate 命令，Windows 在系统时间设置中选择自动同步）校准。
-## 15. 表名显示不全
+## 14. 表名显示不全
由于 taos shell 在终端中显示宽度有限，有可能比较长的表名显示不全，如果按照显示的不全的表名进行相关操作会发生 Table does not exist 错误。解决方法可以是通过修改 taos.cfg 文件中的设置项 maxBinaryDisplayWidth， 或者直接输入命令 set max_binary_display_width 100。或者在命令结尾使用 \G 参数来调整结果的显示方式。
-## 16. 如何进行数据迁移？
+## 15. 如何进行数据迁移？
TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A移动机器B时，注意如下两件事：
@@ -134,3 +137,20 @@ TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A
- 2.0.7.0 及以后的版本，到/var/lib/taos/dnode下，修复dnodeEps.json的dnodeId对应的FQDN，重启。确保机器内所有机器的此文件是完全相同的。
- 1.x 和 2.x 版本的存储结构不兼容，需要使用迁移工具或者自己开发应用导出导入数据。
+## 16. 如何在命令行程序 taos 中临时调整日志级别
+
+为了调试方便，从 2.0.16 版本开始，命令行程序 taos 新增了与日志记录相关的两条指令：
+
+```mysql
+ALTER LOCAL flag_name flag_value;
+```
+
+其含义是，在当前的命令行程序下，修改一个特定模块的日志记录级别（只对当前命令行程序有效，如果 taos 命令行程序重启，则需要重新设置）：
+- flag_name 的取值可以是：debugFlag，cDebugFlag，tmrDebugFlag，uDebugFlag，rpcDebugFlag
+- flag_value 的取值可以是：131（输出错误和警告日志），135（ 输出错误、警告和调试日志），143（ 输出错误、警告、调试和跟踪日志）
+
+```mysql
+ALTER LOCAL RESETLOG;
+```
+
+其含义是，清空本机所有由客户端生成的日志文件。
diff --git a/documentation20/webdocs/assets/dnode.png b/documentation20/cn/images/architecture/dnode.png
similarity index 100%
rename from documentation20/webdocs/assets/dnode.png
rename to documentation20/cn/images/architecture/dnode.png
diff --git a/documentation20/webdocs/assets/message.png b/documentation20/cn/images/architecture/message.png
similarity index 100%
rename from documentation20/webdocs/assets/message.png
rename to documentation20/cn/images/architecture/message.png
diff --git a/documentation20/webdocs/assets/modules.png b/documentation20/cn/images/architecture/modules.png
similarity index 100%
rename from documentation20/webdocs/assets/modules.png
rename to documentation20/cn/images/architecture/modules.png
diff --git a/documentation20/cn/images/architecture/multi_tables.png b/documentation20/cn/images/architecture/multi_tables.png
new file mode 100644
index 0000000000000000000000000000000000000000..0cefaab6a9a4cdd671c671f7c6186dea41415ff0
Binary files /dev/null and b/documentation20/cn/images/architecture/multi_tables.png differ
diff --git a/documentation20/cn/images/architecture/replica-forward.png b/documentation20/cn/images/architecture/replica-forward.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf616e030b130603eceb5dccfd30b4a1dfa68ea5
Binary files /dev/null and b/documentation20/cn/images/architecture/replica-forward.png differ
diff --git a/documentation20/webdocs/assets/replica-master.png b/documentation20/cn/images/architecture/replica-master.png
similarity index 100%
rename from documentation20/webdocs/assets/replica-master.png
rename to documentation20/cn/images/architecture/replica-master.png
diff --git a/documentation20/cn/images/architecture/replica-restore.png b/documentation20/cn/images/architecture/replica-restore.png
new file mode 100644
index 0000000000000000000000000000000000000000..1558e5ed0108d23efdc6b5d9ea0e44a1dff45d28
Binary files /dev/null and b/documentation20/cn/images/architecture/replica-restore.png differ
diff --git a/documentation20/cn/images/architecture/structure.png b/documentation20/cn/images/architecture/structure.png
new file mode 100644
index 0000000000000000000000000000000000000000..4fc8f47ab0a30d95b85ba1d85105726ed981e56e
Binary files /dev/null and b/documentation20/cn/images/architecture/structure.png differ
diff --git a/documentation20/webdocs/assets/vnode.png b/documentation20/cn/images/architecture/vnode.png
similarity index 100%
rename from documentation20/webdocs/assets/vnode.png
rename to documentation20/cn/images/architecture/vnode.png
diff --git a/documentation20/webdocs/assets/write_master.png b/documentation20/cn/images/architecture/write_master.png
similarity index 100%
rename from documentation20/webdocs/assets/write_master.png
rename to documentation20/cn/images/architecture/write_master.png
diff --git a/documentation20/webdocs/assets/write_slave.png b/documentation20/cn/images/architecture/write_slave.png
similarity index 100%
rename from documentation20/webdocs/assets/write_slave.png
rename to documentation20/cn/images/architecture/write_slave.png
diff --git a/documentation20/cn/images/connections/add_datasource1.jpg b/documentation20/cn/images/connections/add_datasource1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1f0f5110f312c57f3ec1788bbc02f04fac6ac142
Binary files /dev/null and b/documentation20/cn/images/connections/add_datasource1.jpg differ
diff --git a/documentation20/cn/images/connections/add_datasource2.jpg b/documentation20/cn/images/connections/add_datasource2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fa7a83e00e96fae649910dff4edf5f5bdadd7850
Binary files /dev/null and b/documentation20/cn/images/connections/add_datasource2.jpg differ
diff --git a/documentation20/cn/images/connections/add_datasource3.jpg b/documentation20/cn/images/connections/add_datasource3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fc850ad08ff1174de972906842e0d5ee64e6e5cb
Binary files /dev/null and b/documentation20/cn/images/connections/add_datasource3.jpg differ
diff --git a/documentation20/cn/images/connections/add_datasource4.jpg b/documentation20/cn/images/connections/add_datasource4.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3ba73e50d455111f8621f4165746078554c2d790
Binary files /dev/null and b/documentation20/cn/images/connections/add_datasource4.jpg differ
diff --git a/documentation20/cn/images/connections/create_dashboard1.jpg b/documentation20/cn/images/connections/create_dashboard1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3b83c3a1714e9e7540e0b06239ef7c1c4f63fe2c
Binary files /dev/null and b/documentation20/cn/images/connections/create_dashboard1.jpg differ
diff --git a/documentation20/cn/images/connections/create_dashboard2.jpg b/documentation20/cn/images/connections/create_dashboard2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fe5d768ac55254251e0290bf257178f5ff28f5a5
Binary files /dev/null and b/documentation20/cn/images/connections/create_dashboard2.jpg differ
diff --git a/documentation20/cn/images/connections/import_dashboard1.jpg b/documentation20/cn/images/connections/import_dashboard1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9d2ce7ed65eb0c2c729de50283b30491793493dc
Binary files /dev/null and b/documentation20/cn/images/connections/import_dashboard1.jpg differ
diff --git a/documentation20/cn/images/connections/import_dashboard2.jpg b/documentation20/cn/images/connections/import_dashboard2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..94b09f0ee39552bb84f7ba1f65815ce2c9548b2d
Binary files /dev/null and b/documentation20/cn/images/connections/import_dashboard2.jpg differ
diff --git a/documentation20/webdocs/assets/connector.png b/documentation20/cn/images/connector.png
similarity index 100%
rename from documentation20/webdocs/assets/connector.png
rename to documentation20/cn/images/connector.png
diff --git a/documentation20/webdocs/assets/EcoSystem.png b/documentation20/cn/images/eco_system.png
similarity index 100%
rename from documentation20/webdocs/assets/EcoSystem.png
rename to documentation20/cn/images/eco_system.png
diff --git a/documentation20/webdocs/assets/tdengine-jdbc-connector.png b/documentation20/cn/images/tdengine-jdbc-connector.png
similarity index 100%
rename from documentation20/webdocs/assets/tdengine-jdbc-connector.png
rename to documentation20/cn/images/tdengine-jdbc-connector.png
diff --git a/documentation20/webdocs/assets/replica-forward.jpg b/documentation20/webdocs/assets/replica-forward.jpg
deleted file mode 100644
index 00b8c357b9ca2f067127c7dfae37b386b268f8dd..0000000000000000000000000000000000000000
Binary files a/documentation20/webdocs/assets/replica-forward.jpg and /dev/null differ
diff --git a/documentation20/webdocs/assets/replica-restore.jpg b/documentation20/webdocs/assets/replica-restore.jpg
deleted file mode 100644
index 6da1bed4cc90b8a119b2fddf5f66ef3ab1b0a2fd..0000000000000000000000000000000000000000
Binary files a/documentation20/webdocs/assets/replica-restore.jpg and /dev/null differ
diff --git a/documentation20/webdocs/markdowndocs/Documentation-ch.md b/documentation20/webdocs/markdowndocs/Documentation-ch.md
deleted file mode 100644
index 20f9bcb7307c68f1330519d8f6ed249419bf46db..0000000000000000000000000000000000000000
--- a/documentation20/webdocs/markdowndocs/Documentation-ch.md
+++ /dev/null
@@ -1,145 +0,0 @@
-# TDengine文档
-
-TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是[数据模型](https://www.taosdata.com/cn/documentation20/data-model-and-architecture)与[数据建模](https://www.taosdata.com/cn/documentation20/model)一节。除本文档之外，欢迎[下载产品白皮书](https://www.taosdata.com/downloads/TDengine White Paper.pdf)。如需查阅TDengine 1.6 文档，请点击[这里](https://www.taosdata.com/cn/documentation16/)访问。
-
-## TDengine介绍
-
-- TDengine 简介及特色
-- TDengine 适用场景
-
-## [立即开始](https://www.taosdata.com/cn/getting-started)
-
-- [快捷安装](https://www.taosdata.com/cn/documentation20/getting-started/#快捷安装)：可通过源码、安装包或docker安装，三秒钟搞定
-- [轻松启动](https://www.taosdata.com/cn/documentation20/getting-started/#轻松启动)：使用systemctl 启停TDengine
-- [命令行程序TAOS](https://www.taosdata.com/cn/documentation20/getting-started/#TDengine命令行程序)：访问TDengine的简便方式
-- [极速体验](https://www.taosdata.com/cn/documentation20/getting-started/#TDengine-极速体验)：运行示例程序，快速体验高效的数据插入、查询
-
-## [数据模型和整体架构](https://www.taosdata.com/cn/documentation20/architecture)
-
-- [数据模型](https://www.taosdata.com/cn/documentation20/architecture/#数据模型)：关系型数据库模型，但要求每个采集点单独建表
-- [集群与基本逻辑单元](https://www.taosdata.com/cn/documentation20/architecture/#集群与基本逻辑单元)：吸取NoSQL优点，支持水平扩展，支持高可靠
-- [存储模型与数据分区、分片](https://www.taosdata.com/cn/documentation20/architecture/#存储模型与数据分区、分片)：标签数据与时序数据完全分离，按vnode和时间两个维度对数据切分
-- [数据写入与复制流程](https://www.taosdata.com/cn/documentation20/architecture/#数据写入与复制流程)：先写入WAL、之后写入缓存，再给应用确认，支持多副本
-- [缓存与持久化](https://www.taosdata.com/cn/documentation20/architecture/#缓存与持久化)：最新数据缓存在内存中，但落盘时采用列式存储、超高压缩比
-- [数据查询](https://www.taosdata.com/cn/documentation20/architecture/#数据查询)：支持各种函数、时间轴聚合、插值、多表聚合
-
-## [数据建模](https://www.taosdata.com/cn/documentation20/model)
-
-- [创建库](https://www.taosdata.com/cn/documentation20/model/#创建库)：为具有相似数据特征的数据采集点创建一个库
-- [创建超级表](https://www.taosdata.com/cn/documentation20/model/#创建超级表)：为同一类型的数据采集点创建一个超级表
-- [创建表](https://www.taosdata.com/cn/documentation20/model/#创建表)：使用超级表做模板，为每一个具体的数据采集点单独建表
-
-## [高效写入数据](https://www.taosdata.com/cn/documentation20/insert)
-
-- [SQL写入](https://www.taosdata.com/cn/documentation20/insert/#SQL写入)：使用SQL insert命令向一张或多张表写入单条或多条记录
-- [Telegraf写入](https://www.taosdata.com/cn/documentation20/insert/#Telegraf直接写入)：配置Telegraf, 不用任何代码，将采集数据直接写入
-- [Prometheus写入](https://www.taosdata.com/cn/documentation20/insert/#Prometheus直接写入)：配置Prometheus, 不用任何代码，将数据直接写入
-- [EMQ X Broker](https://www.taosdata.com/cn/documentation20/insert/#EMQ-X-Broker直接写入)：配置EMQ X，不用任何代码，就可将 MQTT 数据直接写入
-- [HiveMQ Broker](https://www.taosdata.com/cn/documentation20/insert/#HiveMQ-Broker直接写入)：通过 HiveMQ Extension，不用任何代码，就可将 MQTT 数据直接写入
-
-## [高效查询数据](https://www.taosdata.com/cn/documentation20/queries)
-
-- [主要查询功能](https://www.taosdata.com/cn/documentation20/queries/#主要查询功能)：支持各种标准函数，设置过滤条件，时间段查询
-- [多表聚合查询](https://www.taosdata.com/cn/documentation20/queries/#多表聚合查询)：使用超级表，设置标签过滤条件，进行高效聚合查询
-- [降采样查询值](https://www.taosdata.com/cn/documentation20/queries/#降采样查询、插值)：按时间段分段聚合，支持插值
-
-## [高级功能](https://www.taosdata.com/cn/documentation20/advanced-features)
-
-- [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation20/advanced-features/#连续查询(Continuous-Query))：基于滑动窗口，定时自动的对数据流进行查询计算
-- [数据订阅(Publisher/Subscriber)](https://www.taosdata.com/cn/documentation20/advanced-features/#数据订阅(Publisher/Subscriber))：象典型的消息队列，应用可订阅接收到的最新数据
-- [缓存(Cache)](https://www.taosdata.com/cn/documentation20/advanced-features/#缓存(Cache))：每个设备最新的数据都会缓存在内存中，可快速获取
-- [报警监测](https://www.taosdata.com/cn/documentation20/advanced-features/#报警监测(Alert))：根据配置规则，自动监测超限行为数据，并主动推送
-
-## [连接器](https://www.taosdata.com/cn/documentation20/connector)
-
-- [C/C++ Connector](https://www.taosdata.com/cn/documentation20/connector/#C/C++-Connector)：通过libtaos客户端的库，连接TDengine服务器的主要方法
-- [Java Connector(JDBC)](https://www.taosdata.com/cn/documentation20/connector-java)：通过标准的JDBC API，给Java应用提供到TDengine的连接
-- [Python Connector](https://www.taosdata.com/cn/documentation20/connector/#Python-Connector)：给Python应用提供一个连接TDengine服务器的驱动
-- [RESTful Connector](https://www.taosdata.com/cn/documentation20/connector/#RESTful-Connector)：提供一最简单的连接TDengine服务器的方式
-- [Go Connector](https://www.taosdata.com/cn/documentation20/connector/#Go-Connector)：给Go应用提供一个连接TDengine服务器的驱动
-- [Node.js Connector](https://www.taosdata.com/cn/documentation20/connector/#Node.js-Connector)：给node应用提供一个链接TDengine服务器的驱动
-
-## [与其他工具的连接](https://www.taosdata.com/cn/documentation20/connections-with-other-tools)
-
-- [Grafana](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#Grafana)：获取并可视化保存在TDengine的数据
-- [Matlab](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#Matlab)：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
-- [R](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#R)：通过配置R的JDBC数据源访问保存在TDengine的数据
-
-## [TDengine集群的安装、管理](https://www.taosdata.com/cn/documentation20/cluster)
-
-- [安装](https://www.taosdata.com/cn/documentation20/cluster/#创建第一个节点)：与单节点的安装一样，但要设好配置文件里的参数first
-- [节点管理](https://www.taosdata.com/cn/documentation20/cluster/#节点管理)：增加、删除、查看集群的节点
-- [mnode的管理](https://www.taosdata.com/cn/documentation20/cluster/#Mnode的高可用)：系统自动创建、无需任何人工干预
-- [负载均衡](https://www.taosdata.com/cn/documentation20/cluster/#负载均衡)：一旦节点个数或负载有变化，自动进行
-- [节点离线处理](https://www.taosdata.com/cn/documentation20/cluster/#节点离线处理)：节点离线超过一定时长，将从集群中剔除
-- [Arbitrator](https://www.taosdata.com/cn/documentation20/cluster/#Arbitrator的使用)：对于偶数个副本的情形，使用它可以防止split brain
-
-## [TDengine的运营和维护](https://www.taosdata.com/cn/documentation20/administrator)
-
-- [容量规划](https://www.taosdata.com/cn/documentation20/administrator/#容量规划)：根据场景，估算硬件资源
-- [容错和灾备](https://www.taosdata.com/cn/documentation20/administrator/#容错和灾备)：设置正确的WAL和数据副本数
-- [系统配置](https://www.taosdata.com/cn/documentation20/administrator/#服务端配置)：端口，缓存大小，文件块大小和其他系统配置
-- [用户管理](https://www.taosdata.com/cn/documentation20/administrator/#用户管理)：添加、删除TDengine用户，修改用户密码
-- [数据导入](https://www.taosdata.com/cn/documentation20/administrator/#数据导入)：可按脚本文件导入，也可按数据文件导入
-- [数据导出](https://www.taosdata.com/cn/documentation20/administrator/#数据导出)：从shell按表导出，也可用taosdump工具做各种导出
-- [系统监控](https://www.taosdata.com/cn/documentation20/administrator/#系统监控)：检查系统现有的连接、查询、流式计算，日志和事件等
-- [文件目录结构](https://www.taosdata.com/cn/documentation20/administrator/#文件目录结构)：TDengine数据文件、配置文件等所在目录
-- [参数限制和保留关键字](https://www.taosdata.com/cn/documentation20/administrator/#参数限制和保留关键字)：TDengine的参数限制和保留关键字列表
-
-## [TAOS SQL](https://www.taosdata.com/cn/documentation20/taos-sql)
-
-- [支持的数据类型](https://www.taosdata.com/cn/documentation20/taos-sql/#支持的数据类型)：支持时间戳、整型、浮点型、布尔型、字符型等多种数据类型
-- [数据库管理](https://www.taosdata.com/cn/documentation20/taos-sql/#数据库管理)：添加、删除、查看数据库
-- [表管理](https://www.taosdata.com/cn/documentation20/taos-sql/#表管理)：添加、删除、查看、修改表
-- [超级表管理](https://www.taosdata.com/cn/documentation20/taos-sql/#超级表STable管理)：添加、删除、查看、修改超级表
-- [标签管理](https://www.taosdata.com/cn/documentation20/taos-sql/#超级表-STable-中-TAG-管理)：增加、删除、修改标签
-- [数据写入](https://www.taosdata.com/cn/documentation20/taos-sql/#数据写入)：支持单表单条、多条、多表多条写入，支持历史数据写入
-- [数据查询](https://www.taosdata.com/cn/documentation20/taos-sql/#数据查询)：支持时间段、值过滤、排序、查询结果手动分页等
-- [SQL函数](https://www.taosdata.com/cn/documentation20/taos-sql/#SQL函数)：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
-- [时间维度聚合](https://www.taosdata.com/cn/documentation20/taos-sql/#时间维度聚合)：将表中数据按照时间段进行切割后聚合，降维处理
-- [边界线制](https://www.taosdata.com/cn/documentation20/taos-sql/#TAOS-SQL-边界限制)：TAOS SQL的边界限制
-- [错误码](https://www.taosdata.com/cn/documentation20/Taos-Error-Code)：TDengine 2.0 错误码以及对应的十进制码
-
-## TDengine的技术设计
-
-- 系统模块：taosd的功能和模块划分
-- 数据复制：支持实时同步、异步复制，保证系统的High Availibility
-- [技术博客](https://www.taosdata.com/cn/blog/?categories=3)：更多的技术分析和架构设计文章
-
-## 常用工具
-
-- [TDengine样例导入工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
-- [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
-
-## TDengine与其他数据库的对比测试
-
-- [用InfluxDB开源的性能测试工具对比InfluxDB和TDengine](https://www.taosdata.com/blog/2020/01/13/1105.html)
-- [TDengine与OpenTSDB对比测试](https://www.taosdata.com/blog/2019/08/21/621.html)
-- [TDengine与Cassandra对比测试](https://www.taosdata.com/blog/2019/08/14/573.html)
-- [TDengine与InfluxDB对比测试](https://www.taosdata.com/blog/2019/07/19/419.html)
-- [TDengine与InfluxDB、OpenTSDB、Cassandra、MySQL、ClickHouse等数据库的对比测试报告](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)
-
-##物联网大数据
-
-- [物联网、工业互联网大数据的特点](https://www.taosdata.com/blog/2019/07/09/105.html)
-- [物联网大数据平台应具备的功能和特点](https://www.taosdata.com/blog/2019/07/29/542.html)
-- [通用大数据架构为什么不适合处理物联网数据？](https://www.taosdata.com/blog/2019/07/09/107.html)
-- [物联网、车联网、工业互联网大数据平台，为什么推荐使用TDengine？](https://www.taosdata.com/blog/2019/07/09/109.html)
-
-## [培训和FAQ](https://www.taosdata.com/cn/faq)
-
-
-
diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg
index 5ac0e39dcc134260945d5328ac8035559574f277..a1178e2eefd6c4e6a4433a451d2e4e865a39cfe6 100644
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -34,7 +34,7 @@
# 1.0: all CPU cores are available for query processing [default].
# 0.5: only half of the CPU cores are available for query.
# 0.0: only one core available.
-# tsRatioOfQueryCores 1.0
+# ratioOfQueryCores 1.0
# the last_row/first/last aggregator will not change the original column name in the result fields
# keepColumnName 0
diff --git a/packaging/deb/DEBIAN/prerm b/packaging/deb/DEBIAN/prerm
index 3d57ece2adf4e8efd3338f52787d5d9424016e78..d24502a1cb8e69ddaf3989a89e51cc07dfb55f00 100644
--- a/packaging/deb/DEBIAN/prerm
+++ b/packaging/deb/DEBIAN/prerm
@@ -26,7 +26,6 @@ else
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosd || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${cfg_link_dir}/* || :
${csudo} rm -f ${inc_link_dir}/taos.h || :
diff --git a/packaging/deb/makedeb.sh b/packaging/deb/makedeb.sh
index 850c636940a34e5a2b58c227e1fd105fb57fa285..36870b2ebe49d45390d7b5ce18f6984b9e8e2ac2 100755
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -51,7 +51,6 @@ cp ${compile_dir}/../packaging/tools/startPre.sh ${pkg_dir}${install_home_pat
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/taosdemox ${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
cp ${compile_dir}/build/bin/taos ${pkg_dir}${install_home_path}/bin
diff --git a/packaging/docker/dockerManifest.sh b/packaging/docker/dockerManifest.sh
index ca2c3c66c9875a697b372f73448aa53deb887f68..b52580cfa6bdc13fcc7b716a85029fd1c679a6b6 100755
--- a/packaging/docker/dockerManifest.sh
+++ b/packaging/docker/dockerManifest.sh
@@ -35,10 +35,11 @@ done
echo "verNumber=${verNumber}"
-docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber}
+#docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber}
+docker manifest create -a tdengine/tdengine tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
docker login -u tdengine -p ${passWord} #replace the docker registry username and password
-docker manifest push tdengine/tdengine:${verNumber}
+docker manifest push tdengine/tdengine
# how set latest version ???
diff --git a/packaging/rpm/tdengine.spec b/packaging/rpm/tdengine.spec
index d20a6c91cdd78a8c54b89b14d7b77807ebef4877..92c917cb3d6d4cd5f41441c9ca75a742aa3641b6 100644
--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@@ -9,6 +9,7 @@ Summary: tdengine from taosdata
Group: Application/Database
License: AGPL
URL: www.taosdata.com
+AutoReqProv: no
#BuildRoot: %_topdir/BUILDROOT
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
@@ -61,7 +62,6 @@ cp %{_compiledir}/../packaging/tools/taosd-dump-cfg.gdb %{buildroot}%{homepat
cp %{_compiledir}/build/bin/taos %{buildroot}%{homepath}/bin
cp %{_compiledir}/build/bin/taosd %{buildroot}%{homepath}/bin
cp %{_compiledir}/build/bin/taosdemo %{buildroot}%{homepath}/bin
-cp %{_compiledir}/build/bin/taosdemox %{buildroot}%{homepath}/bin
cp %{_compiledir}/build/bin/taosdump %{buildroot}%{homepath}/bin
cp %{_compiledir}/build/lib/${libfile} %{buildroot}%{homepath}/driver
cp %{_compiledir}/../src/inc/taos.h %{buildroot}%{homepath}/include
@@ -139,7 +139,6 @@ if [ $1 -eq 0 ];then
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosd || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${cfg_link_dir}/* || :
${csudo} rm -f ${inc_link_dir}/taos.h || :
diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh
index 9cec9963af6f8abdcaedeeb4e7d40f9244508be2..dca3dd2ff623672eb85b3de72bcc34e0ea5e3d8a 100755
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -147,8 +147,8 @@ done
#echo "verType=${verType} interactiveFqdn=${interactiveFqdn}"
-function kill_taosd() {
- pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
+function kill_process() {
+ pid=$(ps -ef | grep "$1" | grep -v "grep" | awk '{print $2}')
if [ -n "$pid" ]; then
${csudo} kill -9 $pid || :
fi
@@ -168,7 +168,10 @@ function install_main_path() {
if [ "$verMode" == "cluster" ]; then
${csudo} mkdir -p ${nginx_dir}
fi
- ${csudo} cp ${script_dir}/email ${install_main_dir}/ ||:
+
+ if [[ -e ${script_dir}/email ]]; then
+ ${csudo} cp ${script_dir}/email ${install_main_dir}/ ||:
+ fi
}
function install_bin() {
@@ -176,7 +179,6 @@ function install_bin() {
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosd || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${bin_link_dir}/rmtaos || :
${csudo} rm -f ${bin_link_dir}/tarbitrator || :
@@ -188,7 +190,6 @@ function install_bin() {
[ -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/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
- [ -x ${install_main_dir}/bin/taosdemox ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemox ${bin_link_dir}/taosdemox || :
[ -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 || :
[ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
@@ -680,7 +681,7 @@ function install_service() {
install_service_on_sysvinit
else
# must manual stop taosd
- kill_taosd
+ kill_process taosd
fi
}
@@ -749,9 +750,22 @@ function update_TDengine() {
elif ((${service_mod}==1)); then
${csudo} service taosd stop || :
else
- kill_taosd
+ kill_process taosd
+ fi
+ sleep 1
+ fi
+
+ if [ "$verMode" == "cluster" ]; then
+ if pidof nginx &> /dev/null; then
+ if ((${service_mod}==0)); then
+ ${csudo} systemctl stop nginxd || :
+ elif ((${service_mod}==1)); then
+ ${csudo} service nginxd stop || :
+ else
+ kill_process nginx
fi
sleep 1
+ fi
fi
install_main_path
diff --git a/packaging/tools/install_client.sh b/packaging/tools/install_client.sh
index d52428dc83805b6f03a36bb39edc774e79d04398..0a0a6633e376d084532abb5f490917abd1a173f2 100755
--- a/packaging/tools/install_client.sh
+++ b/packaging/tools/install_client.sh
@@ -86,7 +86,6 @@ function install_bin() {
${csudo} rm -f ${bin_link_dir}/taos || :
if [ "$osType" != "Darwin" ]; then
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
fi
${csudo} rm -f ${bin_link_dir}/rmtaos || :
@@ -98,7 +97,6 @@ function install_bin() {
[ -x ${install_main_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos || :
if [ "$osType" != "Darwin" ]; then
[ -x ${install_main_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
- [ -x ${install_main_dir}/bin/taosdemox ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemox ${bin_link_dir}/taosdemox || :
[ -x ${install_main_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
fi
[ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/rmtaos || :
diff --git a/packaging/tools/install_client_power.sh b/packaging/tools/install_client_power.sh
index 04fd23d5abb2874d0b3a68b937be529bd2c91a59..8d7463366ff46bcae2822ee3e76dbc9b588f2a89 100755
--- a/packaging/tools/install_client_power.sh
+++ b/packaging/tools/install_client_power.sh
@@ -86,7 +86,6 @@ function install_bin() {
${csudo} rm -f ${bin_link_dir}/power || :
if [ "$osType" != "Darwin" ]; then
${csudo} rm -f ${bin_link_dir}/powerdemo || :
- ${csudo} rm -f ${bin_link_dir}/powerdemox || :
${csudo} rm -f ${bin_link_dir}/powerdump || :
fi
${csudo} rm -f ${bin_link_dir}/rmpower || :
@@ -98,7 +97,6 @@ function install_bin() {
[ -x ${install_main_dir}/bin/power ] && ${csudo} ln -s ${install_main_dir}/bin/power ${bin_link_dir}/power || :
if [ "$osType" != "Darwin" ]; then
[ -x ${install_main_dir}/bin/powerdemo ] && ${csudo} ln -s ${install_main_dir}/bin/powerdemo ${bin_link_dir}/powerdemo || :
- [ -x ${install_main_dir}/bin/powerdemox ] && ${csudo} ln -s ${install_main_dir}/bin/powerdemox ${bin_link_dir}/powerdemox || :
[ -x ${install_main_dir}/bin/powerdump ] && ${csudo} ln -s ${install_main_dir}/bin/powerdump ${bin_link_dir}/powerdump || :
fi
[ -x ${install_main_dir}/bin/remove_client_power.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client_power.sh ${bin_link_dir}/rmpower || :
diff --git a/packaging/tools/install_power.sh b/packaging/tools/install_power.sh
index 89b5ce5b4f1f9edc91b7abbf459303cd8f632edf..ba6ace400935c10caadd9426c0701c16b4f86baa 100755
--- a/packaging/tools/install_power.sh
+++ b/packaging/tools/install_power.sh
@@ -146,8 +146,8 @@ done
#echo "verType=${verType} interactiveFqdn=${interactiveFqdn}"
-function kill_powerd() {
- pid=$(ps -ef | grep "powerd" | grep -v "grep" | awk '{print $2}')
+function kill_process() {
+ pid=$(ps -ef | grep "$1" | grep -v "grep" | awk '{print $2}')
if [ -n "$pid" ]; then
${csudo} kill -9 $pid || :
fi
@@ -174,7 +174,6 @@ function install_bin() {
${csudo} rm -f ${bin_link_dir}/power || :
${csudo} rm -f ${bin_link_dir}/powerd || :
${csudo} rm -f ${bin_link_dir}/powerdemo || :
- ${csudo} rm -f ${bin_link_dir}/powerdemox || :
${csudo} rm -f ${bin_link_dir}/rmpower || :
${csudo} rm -f ${bin_link_dir}/tarbitrator || :
${csudo} rm -f ${bin_link_dir}/set_core || :
@@ -185,7 +184,6 @@ function install_bin() {
[ -x ${install_main_dir}/bin/power ] && ${csudo} ln -s ${install_main_dir}/bin/power ${bin_link_dir}/power || :
[ -x ${install_main_dir}/bin/powerd ] && ${csudo} ln -s ${install_main_dir}/bin/powerd ${bin_link_dir}/powerd || :
[ -x ${install_main_dir}/bin/powerdemo ] && ${csudo} ln -s ${install_main_dir}/bin/powerdemo ${bin_link_dir}/powerdemo || :
- [ -x ${install_main_dir}/bin/powerdemox ] && ${csudo} ln -s ${install_main_dir}/bin/powerdemox ${bin_link_dir}/powerdemox || :
[ -x ${install_main_dir}/bin/remove_power.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_power.sh ${bin_link_dir}/rmpower || :
[ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
[ -x ${install_main_dir}/bin/tarbitrator ] && ${csudo} ln -s ${install_main_dir}/bin/tarbitrator ${bin_link_dir}/tarbitrator || :
@@ -652,7 +650,7 @@ function install_service() {
install_service_on_sysvinit
else
# must manual stop powerd
- kill_powerd
+ kill_process powerd
fi
}
@@ -721,9 +719,21 @@ function update_PowerDB() {
elif ((${service_mod}==1)); then
${csudo} service powerd stop || :
else
- kill_powerd
+ kill_process powerd
fi
sleep 1
+ fi
+ if [ "$verMode" == "cluster" ]; then
+ if pidof nginx &> /dev/null; then
+ if ((${service_mod}==0)); then
+ ${csudo} systemctl stop nginxd || :
+ elif ((${service_mod}==1)); then
+ ${csudo} service nginxd stop || :
+ else
+ kill_process nginx
+ fi
+ sleep 1
+ fi
fi
install_main_path
diff --git a/packaging/tools/makeclient.sh b/packaging/tools/makeclient.sh
index 52a4e059065ba666e9624800a24f267f74e454f9..30e9fa51a7d9c4a98d2c8f300287ebd242fecd74 100755
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@@ -45,7 +45,7 @@ if [ "$osType" != "Darwin" ]; then
strip ${build_dir}/bin/taos
bin_files="${build_dir}/bin/taos ${script_dir}/remove_client.sh"
else
- bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo ${build_dir}/bin/taosdemox\
+ bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo \
${script_dir}/remove_client.sh ${script_dir}/set_core.sh ${script_dir}/get_client.sh ${script_dir}/taosd-dump-cfg.gdb"
fi
lib_files="${build_dir}/lib/libtaos.so.${version}"
@@ -55,7 +55,11 @@ else
fi
header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
-cfg_dir="${top_dir}/packaging/cfg"
+if [ "$verMode" == "cluster" ]; then
+ cfg_dir="${top_dir}/../enterprise/packaging/cfg"
+else
+ cfg_dir="${top_dir}/packaging/cfg"
+fi
install_files="${script_dir}/install_client.sh"
diff --git a/packaging/tools/makeclient_power.sh b/packaging/tools/makeclient_power.sh
index 15f8994e945aac89fc30b1fe7eaaf3c72ea8c105..181536b7f19d252164201291d9c37cade6cf3490 100755
--- a/packaging/tools/makeclient_power.sh
+++ b/packaging/tools/makeclient_power.sh
@@ -54,7 +54,11 @@ else
fi
header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
-cfg_dir="${top_dir}/packaging/cfg"
+if [ "$verMode" == "cluster" ]; then
+ cfg_dir="${top_dir}/../enterprise/packaging/cfg"
+else
+ cfg_dir="${top_dir}/packaging/cfg"
+fi
install_files="${script_dir}/install_client_power.sh"
@@ -77,7 +81,6 @@ if [ "$osType" != "Darwin" ]; then
cp ${build_dir}/bin/taos ${install_dir}/bin/power
cp ${script_dir}/remove_power.sh ${install_dir}/bin
cp ${build_dir}/bin/taosdemo ${install_dir}/bin/powerdemo
- cp ${build_dir}/bin/taosdemox ${install_dir}/bin/powerdemox
cp ${build_dir}/bin/taosdump ${install_dir}/bin/powerdump
cp ${script_dir}/set_core.sh ${install_dir}/bin
cp ${script_dir}/get_client.sh ${install_dir}/bin
diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh
index 267338ed06d528be84d13f4a871865f76b940344..36b1fe5bd88950f69a56e84d98fba9c4dae0cf05 100755
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -36,13 +36,18 @@ if [ "$pagMode" == "lite" ]; then
strip ${build_dir}/bin/taos
bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${script_dir}/remove.sh"
else
- bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdump ${build_dir}/bin/taosdemo ${build_dir}/bin/taosdemox ${build_dir}/bin/tarbitrator\
+ 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"
fi
lib_files="${build_dir}/lib/libtaos.so.${version}"
header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
-cfg_dir="${top_dir}/packaging/cfg"
+if [ "$verMode" == "cluster" ]; then
+ cfg_dir="${top_dir}/../enterprise/packaging/cfg"
+else
+ cfg_dir="${top_dir}/packaging/cfg"
+fi
+
install_files="${script_dir}/install.sh"
nginx_dir="${code_dir}/../../enterprise/src/plugins/web"
diff --git a/packaging/tools/makepkg_power.sh b/packaging/tools/makepkg_power.sh
index 7227a08b7ab5e6fdfbdb4801fac3d174fe481f1e..554e7884b1c3db69acd3ba0e3234e468b1d31c79 100755
--- a/packaging/tools/makepkg_power.sh
+++ b/packaging/tools/makepkg_power.sh
@@ -42,7 +42,11 @@ fi
lib_files="${build_dir}/lib/libtaos.so.${version}"
header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
-cfg_dir="${top_dir}/packaging/cfg"
+if [ "$verMode" == "cluster" ]; then
+ cfg_dir="${top_dir}/../enterprise/packaging/cfg"
+else
+ cfg_dir="${top_dir}/packaging/cfg"
+fi
install_files="${script_dir}/install_power.sh"
nginx_dir="${code_dir}/../../enterprise/src/plugins/web"
@@ -78,7 +82,6 @@ else
cp ${build_dir}/bin/taosd ${install_dir}/bin/powerd
cp ${script_dir}/remove_power.sh ${install_dir}/bin
cp ${build_dir}/bin/taosdemo ${install_dir}/bin/powerdemo
- cp ${build_dir}/bin/taosdemox ${install_dir}/bin/powerdemox
cp ${build_dir}/bin/taosdump ${install_dir}/bin/powerdump
cp ${build_dir}/bin/tarbitrator ${install_dir}/bin
cp ${script_dir}/set_core.sh ${install_dir}/bin
diff --git a/packaging/tools/post.sh b/packaging/tools/post.sh
index c6ef73932d8dbaedbe82fdc69997ef092c9953e7..8665b3fec3a392b3dcae8c6a197625ba85ed953b 100755
--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@@ -96,7 +96,6 @@ function install_bin() {
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosd || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${bin_link_dir}/rmtaos || :
${csudo} rm -f ${bin_link_dir}/set_core || :
@@ -107,7 +106,6 @@ function install_bin() {
[ -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}/taosdemo ] && ${csudo} ln -s ${bin_dir}/taosdemo ${bin_link_dir}/taosdemo || :
- [ -x ${bin_dir}/taosdemox ] && ${csudo} ln -s ${bin_dir}/taosdemox ${bin_link_dir}/taosdemox || :
[ -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 || :
}
diff --git a/packaging/tools/remove.sh b/packaging/tools/remove.sh
index 8d96ef851c9812dcf7764dd1150350721bd2ec6e..2f2660d44635c86df3b51d2b86e37b3399869a88 100755
--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
@@ -72,7 +72,6 @@ function clean_bin() {
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosd || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${bin_link_dir}/rmtaos || :
${csudo} rm -f ${bin_link_dir}/tarbitrator || :
diff --git a/packaging/tools/remove_client.sh b/packaging/tools/remove_client.sh
index e84cdd2620f7e83ea12af7500c2385892d7072fa..7579162dc60e290754e71ed6a71c10cfaee5537b 100755
--- a/packaging/tools/remove_client.sh
+++ b/packaging/tools/remove_client.sh
@@ -38,7 +38,6 @@ function clean_bin() {
# Remove link
${csudo} rm -f ${bin_link_dir}/taos || :
${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdemox || :
${csudo} rm -f ${bin_link_dir}/taosdump || :
${csudo} rm -f ${bin_link_dir}/rmtaos || :
${csudo} rm -f ${bin_link_dir}/set_core || :
diff --git a/packaging/tools/remove_client_power.sh b/packaging/tools/remove_client_power.sh
index 1842e86a5b2c55b6c2aac02e6150bc9eaa5836a6..580c46e2077d7f21e06d4d4a8f69dcd5b6bbf51d 100755
--- a/packaging/tools/remove_client_power.sh
+++ b/packaging/tools/remove_client_power.sh
@@ -38,7 +38,6 @@ function clean_bin() {
# Remove link
${csudo} rm -f ${bin_link_dir}/power || :
${csudo} rm -f ${bin_link_dir}/powerdemo || :
- ${csudo} rm -f ${bin_link_dir}/powerdemox || :
${csudo} rm -f ${bin_link_dir}/powerdump || :
${csudo} rm -f ${bin_link_dir}/rmpower || :
${csudo} rm -f ${bin_link_dir}/set_core || :
diff --git a/packaging/tools/remove_power.sh b/packaging/tools/remove_power.sh
index 59073105de9828bc1255d269bdc773d613500e5a..816869cf444d8001e0c0aae30840d2c40a9e6af4 100755
--- a/packaging/tools/remove_power.sh
+++ b/packaging/tools/remove_power.sh
@@ -72,7 +72,6 @@ function clean_bin() {
${csudo} rm -f ${bin_link_dir}/power || :
${csudo} rm -f ${bin_link_dir}/powerd || :
${csudo} rm -f ${bin_link_dir}/powerdemo || :
- ${csudo} rm -f ${bin_link_dir}/powerdemox || :
${csudo} rm -f ${bin_link_dir}/powerdump || :
${csudo} rm -f ${bin_link_dir}/rmpower || :
${csudo} rm -f ${bin_link_dir}/tarbitrator || :
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index 102fea6b9e3f8892d8e8af26c6ee54bdaa948fb8..7b6bfee42bd1a533798365edecacdff528420d73 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
name: tdengine
base: core18
-version: '2.0.14.0'
+version: '2.0.16.0'
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.0.14.0
+ - usr/lib/libtaos.so.2.0.16.0
- usr/lib/libtaos.so.1
- usr/lib/libtaos.so
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d67aba4b66be6ec2f13e994248c8214178b55663..b0f2cc0a48f906b40d7be5185ae5f081c2ed4418 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
# Base compile
diff --git a/src/balance/CMakeLists.txt b/src/balance/CMakeLists.txt
index bcb37690876462c227b43343d9bd3228d4405963..967635e52ce20761dbd674a380563deeeb9af189 100644
--- a/src/balance/CMakeLists.txt
+++ b/src/balance/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc)
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
index 660ad564a5cb611da4411b5f23eb494f6255c7af..fb43751b9e8fd715d538abb1198e1bdfd0a2e9ae 100644
--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
INCLUDE_DIRECTORIES(inc)
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 8e5f621b37d77d41e44ff2cb329e6d6d03d62340..7d5b76cc2b3be68ae751e61b4b6c9870120c7d66 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -273,14 +273,15 @@ void tscQueueAsyncError(void(*fp), void *param, int32_t code) {
taosScheduleTask(tscQhandle, &schedMsg);
}
-void tscAsyncResultOnError(SSqlObj *pSql) {
+static void tscAsyncResultCallback(SSchedMsg *pMsg) {
+ SSqlObj* pSql = pMsg->ahandle;
if (pSql == NULL || pSql->signature != pSql) {
tscDebug("%p SqlObj is freed, not add into queue async res", pSql);
return;
}
assert(pSql->res.code != TSDB_CODE_SUCCESS);
- tscError("%p invoke user specified function due to error occured, code:%s", pSql, tstrerror(pSql->res.code));
+ tscError("%p invoke user specified function due to error occurred, code:%s", pSql, tstrerror(pSql->res.code));
SSqlRes *pRes = &pSql->res;
if (pSql->fp == NULL || pSql->fetchFp == NULL){
@@ -291,6 +292,16 @@ void tscAsyncResultOnError(SSqlObj *pSql) {
(*pSql->fp)(pSql->param, pSql, pRes->code);
}
+void tscAsyncResultOnError(SSqlObj* pSql) {
+ SSchedMsg schedMsg = {0};
+ schedMsg.fp = tscAsyncResultCallback;
+ schedMsg.ahandle = pSql;
+ schedMsg.thandle = (void *)1;
+ schedMsg.msg = 0;
+ taosScheduleTask(tscQhandle, &schedMsg);
+}
+
+
int tscSendMsgToServer(SSqlObj *pSql);
void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
@@ -322,7 +333,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
code = tscGetTableMeta(pSql, pTableMetaInfo);
assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
- if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+ if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
taosReleaseRef(tscObjRef, pSql->self);
return;
}
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index da350197d408bf8e2b3c7aaf9f5ebf17894c86a5..23fb0ab67cded77ff737fac4246343486e80eb95 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -86,7 +86,6 @@ static void tscInitSqlContext(SSqlCmd *pCmd, SLocalMerger *pReducer, tOrderDescr
pCtx->outputBytes = pExpr->resBytes;
pCtx->outputType = pExpr->resType;
- pCtx->startOffset = 0;
pCtx->size = 1;
pCtx->hasNull = true;
pCtx->currentStage = MERGE_STAGE;
diff --git a/src/client/src/tscProfile.c b/src/client/src/tscProfile.c
index f813ff85d99e6642827a49defe6b96f29720fc57..9203dcfbbab8d4b512b490bf13ab91fe1b475c22 100644
--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -233,6 +233,7 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
// We extract the lock to tscBuildHeartBeatMsg function.
+ int64_t now = taosGetTimestampMs();
SSqlObj *pSql = pObj->sqlList;
while (pSql) {
/*
@@ -247,7 +248,8 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
tstrncpy(pQdesc->sql, pSql->sqlstr, sizeof(pQdesc->sql));
pQdesc->stime = htobe64(pSql->stime);
pQdesc->queryId = htonl(pSql->queryId);
- pQdesc->useconds = htobe64(pSql->res.useconds);
+ //pQdesc->useconds = htobe64(pSql->res.useconds);
+ pQdesc->useconds = htobe64(now - pSql->stime);
pQdesc->qHandle = htobe64(pSql->res.qhandle);
pHeartbeat->numOfQueries++;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3b248a6281f7049076705be624139d2f8e34bbd9..8c72eefc159fd7b95d16cd6563e0610bfdf55de6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -2981,7 +2981,6 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd)
STableMeta* pTableMeta = NULL;
SSchema* pSchema = NULL;
-// SSchema s = tGetTbnameColumnSchema();
int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;
@@ -4748,7 +4747,7 @@ static void setDefaultOrderInfo(SQueryInfo* pQueryInfo) {
int32_t parseOrderbyClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema* pSchema) {
const char* msg0 = "only support order by primary timestamp";
const char* msg1 = "invalid column name";
- const char* msg2 = "only support order by primary timestamp or first tag in groupby clause allowed";
+ const char* msg2 = "order by primary timestamp or first tag in groupby clause allowed";
const char* msg3 = "invalid column in order by clause, only primary timestamp or first tag in groupby clause allowed";
setDefaultOrderInfo(pQueryInfo);
@@ -6376,16 +6375,14 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
// get table meta from mnode
code = tNameExtractFullName(&pStableMetaInfo->name, pCreateTableInfo->tagdata.name);
- SArray* pList = pCreateTableInfo->pTagVals;
+ SArray* pValList = pCreateTableInfo->pTagVals;
code = tscGetTableMeta(pSql, pStableMetaInfo);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
- size_t size = taosArrayGetSize(pList);
- if (tscGetNumOfTags(pStableMetaInfo->pTableMeta) != size) {
- return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
- }
+ size_t valSize = taosArrayGetSize(pValList);
+
// too long tag values will return invalid sql, not be truncated automatically
SSchema *pTagSchema = tscGetTableTagSchema(pStableMetaInfo->pTableMeta);
@@ -6396,36 +6393,115 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
+
+ SArray* pNameList = NULL;
+ size_t nameSize = 0;
+ int32_t schemaSize = tscGetNumOfTags(pStableMetaInfo->pTableMeta);
int32_t ret = TSDB_CODE_SUCCESS;
- for (int32_t i = 0; i < size; ++i) {
- SSchema* pSchema = &pTagSchema[i];
- tVariantListItem* pItem = taosArrayGet(pList, i);
- char tagVal[TSDB_MAX_TAGS_LEN];
- if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
- if (pItem->pVar.nLen > pSchema->bytes) {
- tdDestroyKVRowBuilder(&kvRowBuilder);
- return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
- }
+ if (pCreateTableInfo->pTagNames) {
+ pNameList = pCreateTableInfo->pTagNames;
+ nameSize = taosArrayGetSize(pNameList);
+
+ if (valSize != nameSize) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+ }
+
+ if (schemaSize < valSize) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
- ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
+ bool findColumnIndex = false;
- // check again after the convert since it may be converted from binary to nchar.
- if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
- int16_t len = varDataTLen(tagVal);
- if (len > pSchema->bytes) {
- tdDestroyKVRowBuilder(&kvRowBuilder);
- return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ for (int32_t i = 0; i < nameSize; ++i) {
+ SStrToken* sToken = taosArrayGet(pNameList, i);
+ if (TK_STRING == sToken->type) {
+ tscDequoteAndTrimToken(sToken);
}
- }
- if (ret != TSDB_CODE_SUCCESS) {
+ tVariantListItem* pItem = taosArrayGet(pValList, i);
+
+ findColumnIndex = false;
+
+ // todo speedup by using hash list
+ for (int32_t t = 0; t < schemaSize; ++t) {
+ if (strncmp(sToken->z, pTagSchema[t].name, sToken->n) == 0 && strlen(pTagSchema[t].name) == sToken->n) {
+ SSchema* pSchema = &pTagSchema[t];
+
+ char tagVal[TSDB_MAX_TAGS_LEN];
+ if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+ if (pItem->pVar.nLen > pSchema->bytes) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ }
+ }
+
+ ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
+
+ // check again after the convert since it may be converted from binary to nchar.
+ if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+ int16_t len = varDataTLen(tagVal);
+ if (len > pSchema->bytes) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ }
+ }
+
+ if (ret != TSDB_CODE_SUCCESS) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+ }
+
+ tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
+
+ findColumnIndex = true;
+ break;
+ }
+ }
+
+ if (!findColumnIndex) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return tscInvalidSQLErrMsg(pCmd->payload, "invalid tag name", sToken->z);
+ }
+ }
+ } else {
+ if (schemaSize != valSize) {
tdDestroyKVRowBuilder(&kvRowBuilder);
- return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
- tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
+ for (int32_t i = 0; i < valSize; ++i) {
+ SSchema* pSchema = &pTagSchema[i];
+ tVariantListItem* pItem = taosArrayGet(pValList, i);
+
+ char tagVal[TSDB_MAX_TAGS_LEN];
+ if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+ if (pItem->pVar.nLen > pSchema->bytes) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ }
+ }
+
+ ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
+
+ // check again after the convert since it may be converted from binary to nchar.
+ if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+ int16_t len = varDataTLen(tagVal);
+ if (len > pSchema->bytes) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ }
+ }
+
+ if (ret != TSDB_CODE_SUCCESS) {
+ tdDestroyKVRowBuilder(&kvRowBuilder);
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+ }
+
+ tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
+ }
}
SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index b10b040c7b5c821f6e31270c235b4fd34a90aef7..cdf9aaea25ec32858bf76303709b7f7479992871 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -330,7 +330,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
pSql->cmd.submitSchema = 1;
}
- if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_FETCH || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
+ if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
(rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID ||
rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID ||
rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL ||
@@ -451,7 +451,7 @@ int doProcessSql(SSqlObj *pSql) {
if (pRes->code != TSDB_CODE_SUCCESS) {
tscAsyncResultOnError(pSql);
- return pRes->code;
+ return TSDB_CODE_SUCCESS;
}
int32_t code = tscSendMsgToServer(pSql);
@@ -460,7 +460,7 @@ int doProcessSql(SSqlObj *pSql) {
if (code != TSDB_CODE_SUCCESS) {
pRes->code = code;
tscAsyncResultOnError(pSql);
- return code;
+ return TSDB_CODE_SUCCESS;
}
return TSDB_CODE_SUCCESS;
@@ -609,7 +609,7 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
}
return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + exprSize + tsBufSize +
- tableSerialize + sqlLen + 4096;
+ tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
}
static char *doSerializeTableInfo(SQueryTableMsg* pQueryMsg, SSqlObj *pSql, char *pMsg) {
@@ -770,6 +770,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
char n[TSDB_TABLE_FNAME_LEN] = {0};
tNameExtractFullName(&pTableMetaInfo->name, n);
+
tscError("%p tid:%d uid:%" PRIu64" id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s",
pSql, pTableMeta->id.tid, pTableMeta->id.uid, n, tscGetNumOfColumns(pTableMeta), pCol->colIndex.columnIndex,
pColSchema->name);
@@ -813,6 +814,13 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
for (int32_t i = 0; i < tscSqlExprNumOfExprs(pQueryInfo); ++i) {
SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
+ // the queried table has been removed and a new table with the same name has already been created already
+ // return error msg
+ if (pExpr->uid != pTableMeta->id.uid) {
+ tscError("%p table has already been destroyed", pSql);
+ return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+ }
+
if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
tscError("%p table schema is not matched with parsed sql", pSql);
return TSDB_CODE_TSC_INVALID_SQL;
@@ -856,6 +864,13 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
SSqlExpr *pExpr = pField->pSqlExpr;
if (pExpr != NULL) {
+ // the queried table has been removed and a new table with the same name has already been created already
+ // return error msg
+ if (pExpr->uid != pTableMeta->id.uid) {
+ tscError("%p table has already been destroyed", pSql);
+ return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+ }
+
if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
tscError("%p table schema is not matched with parsed sql", pSql);
return TSDB_CODE_TSC_INVALID_SQL;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8a240accecc904675bd305c1966891bbfc62916a..13539a9b197875210d76c86bd93ec986190c0c37 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -52,7 +52,9 @@ static bool validPassword(const char* passwd) {
static SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, const char *auth, const char *db,
uint16_t port, void (*fp)(void *, TAOS_RES *, int), void *param, TAOS **taos) {
- taos_init();
+ if (taos_init()) {
+ return NULL;
+ }
if (!validUserName(user)) {
terrno = TSDB_CODE_TSC_INVALID_USER_LENGTH;
@@ -696,7 +698,7 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
}
tscAsyncResultOnError(pSubObj);
- taosReleaseRef(tscObjRef, pSubObj->self);
+ // taosRelekaseRef(tscObjRef, pSubObj->self);
}
if (pSql->subState.numOfSub <= 0) {
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 96aae423d5e394a4fcb6a728fa84b94a039d77af..380c43825547465079098870e3150dd6a2138b78 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -95,11 +95,21 @@ static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
pthread_mutex_lock(&subState->mutex);
+ bool done = allSubqueryDone(pParentSql);
+
+ if (done) {
+ tscDebug("%p subquery:%p,%d all subs already done", pParentSql, pSql, idx);
+
+ pthread_mutex_unlock(&subState->mutex);
+
+ return false;
+ }
+
tscDebug("%p subquery:%p,%d state set to 1", pParentSql, pSql, idx);
subState->states[idx] = 1;
- bool done = allSubqueryDone(pParentSql);
+ done = allSubqueryDone(pParentSql);
pthread_mutex_unlock(&subState->mutex);
@@ -1838,7 +1848,7 @@ void doAppendData(SInterResult* pInterResult, TAOS_ROW row, int32_t numOfCols, S
TSKEY key = INT64_MIN;
for(int32_t i = 0; i < numOfCols; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
- if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
+ if (TSDB_COL_IS_TAG(pExpr->colInfo.flag) || pExpr->functionId == TSDB_FUNC_PRJ) {
continue;
}
@@ -1878,14 +1888,31 @@ void doAppendData(SInterResult* pInterResult, TAOS_ROW row, int32_t numOfCols, S
}
}
+static void destroySup(SFirstRoundQuerySup* pSup) {
+ taosArrayDestroyEx(pSup->pResult, freeInterResult);
+ taosArrayDestroy(pSup->pColsInfo);
+ tfree(pSup);
+}
+
void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
SSqlObj* pSql = (SSqlObj*)tres;
SSqlRes* pRes = &pSql->res;
SFirstRoundQuerySup* pSup = param;
- SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
- if (numOfRows > 0) {
+ SSqlObj* pParent = pSup->pParent;
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+ int32_t code = taos_errno(pSql);
+ if (code != TSDB_CODE_SUCCESS) {
+ destroySup(pSup);
+ taos_free_result(pSql);
+ pParent->res.code = code;
+ tscAsyncResultOnError(pParent);
+ return;
+ }
+
+ if (numOfRows > 0) { // the number is not correct for group by column in super table query
TAOS_ROW row = NULL;
int32_t numOfCols = taos_field_count(tres);
@@ -1895,6 +1922,7 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
while ((row = taos_fetch_row(tres)) != NULL) {
doAppendData(&interResult, row, numOfCols, pQueryInfo);
+ pSup->numOfRows += 1;
}
} else { // tagLen > 0
char* p = calloc(1, pSup->tagLen);
@@ -1906,7 +1934,9 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
int32_t offset = 0;
for (int32_t i = 0; i < numOfCols && offset < pSup->tagLen; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
- if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
+
+ // tag or group by column
+ if (TSDB_COL_IS_TAG(pExpr->colInfo.flag) || pExpr->functionId == TSDB_FUNC_PRJ) {
memcpy(p + offset, row[i], length[i]);
offset += pExpr->resBytes;
}
@@ -1935,23 +1965,24 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
taosArrayPush(pSup->pResult, &interResult);
doAppendData(&interResult, row, numOfCols, pQueryInfo);
}
+
+ pSup->numOfRows += 1;
}
tfree(p);
}
}
- pSup->numOfRows += numOfRows;
if (!pRes->completed) {
taos_fetch_rows_a(tres, tscFirstRoundRetrieveCallback, param);
return;
}
// set the parameters for the second round query process
- SSqlObj *pParent = pSup->pParent;
SSqlCmd *pPCmd = &pParent->cmd;
SQueryInfo *pQueryInfo1 = tscGetQueryInfoDetail(pPCmd, 0);
-
+ int32_t resRows = pSup->numOfRows;
+
if (pSup->numOfRows > 0) {
SBufferWriter bw = tbufInitWriter(NULL, false);
interResToBinary(&bw, pSup->pResult, pSup->tagLen);
@@ -1969,14 +2000,30 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
taos_free_result(pSql);
+ if (resRows == 0) {
+ pParent->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+ (*pParent->fp)(pParent->param, pParent, 0);
+ return;
+ }
+
pQueryInfo1->round = 1;
tscDoQuery(pParent);
}
void tscFirstRoundCallback(void* param, TAOS_RES* tres, int code) {
- int32_t c = taos_errno(tres);
+ SFirstRoundQuerySup* pSup = (SFirstRoundQuerySup*) param;
+
+ SSqlObj* pSql = (SSqlObj*) tres;
+ int32_t c = taos_errno(pSql);
+
if (c != TSDB_CODE_SUCCESS) {
- // TODO HANDLE ERROR
+ SSqlObj* parent = pSup->pParent;
+
+ destroySup(pSup);
+ taos_free_result(pSql);
+ parent->res.code = code;
+ tscAsyncResultOnError(parent);
+ return;
}
taos_fetch_rows_a(tres, tscFirstRoundRetrieveCallback, param);
@@ -2010,13 +2057,13 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
pNewQueryInfo->groupbyExpr.columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
if (pNewQueryInfo->groupbyExpr.columnInfo == NULL) {
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-// goto _error;
+ goto _error;
}
}
if (tscTagCondCopy(&pNewQueryInfo->tagCond, &pQueryInfo->tagCond) != 0) {
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-// goto _error;
+ goto _error;
}
pNewQueryInfo->interval = pQueryInfo->interval;
@@ -2027,7 +2074,6 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
int32_t index = 0;
- int32_t numOfTags = 0;
for(int32_t i = 0; i < numOfExprs; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
if (pExpr->functionId == TSDB_FUNC_TS && pQueryInfo->interval.interval > 0) {
@@ -2060,7 +2106,25 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
SSqlExpr* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TAG, &colIndex, schema, TSDB_COL_TAG);
p->resColId = pExpr->resColId;
- numOfTags += 1;
+ } else if (pExpr->functionId == TSDB_FUNC_PRJ) {
+ int32_t num = (int32_t) taosArrayGetSize(pNewQueryInfo->groupbyExpr.columnInfo);
+ for(int32_t k = 0; k < num; ++k) {
+ SColIndex* pIndex = taosArrayGet(pNewQueryInfo->groupbyExpr.columnInfo, k);
+ if (pExpr->colInfo.colId == pIndex->colId) {
+ pSup->tagLen += pExpr->resBytes;
+ taosArrayPush(pSup->pColsInfo, &pExpr->resColId);
+
+ SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = pIndex->colIndex};
+ SSchema* schema = tscGetColumnSchemaById(pTableMetaInfo1->pTableMeta, pExpr->colInfo.colId);
+
+ //doLimitOutputNormalColOfGroupby
+ SSqlExpr* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_PRJ, &colIndex, schema, TSDB_COL_NORMAL);
+ p->numOfParams = 1;
+ p->param[0].i64 = 1;
+ p->param[0].nType = TSDB_DATA_TYPE_INT;
+ p->resColId = pExpr->resColId; // update the result column id
+ }
+ }
}
}
@@ -2077,6 +2141,13 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
tscHandleMasterSTableQuery(pNew);
return TSDB_CODE_SUCCESS;
+
+ _error:
+ destroySup(pSup);
+ taos_free_result(pNew);
+ pSql->res.code = terrno;
+ tscAsyncResultOnError(pSql);
+ return terrno;
}
int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
@@ -2118,7 +2189,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
tfree(pMemoryBuf);
return ret;
}
-
+
tscDebug("%p retrieved query data from %d vnode(s)", pSql, pState->numOfSub);
pSql->pSubs = calloc(pState->numOfSub, POINTER_BYTES);
if (pSql->pSubs == NULL) {
@@ -2245,7 +2316,9 @@ static void tscAbortFurtherRetryRetrieval(SRetrieveSupport *trsupport, TAOS_RES
* current query failed, and the retry count is less than the available
* count, retry query clear previous retrieved data, then launch a new sub query
*/
-static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32_t code) {
+static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32_t code, int32_t *sent) {
+ *sent = 0;
+
SRetrieveSupport *trsupport = malloc(sizeof(SRetrieveSupport));
if (trsupport == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -2277,21 +2350,28 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
SSqlObj *pNew = tscCreateSTableSubquery(trsupport->pParentSql, trsupport, pSql);
if (pNew == NULL) {
tscError("%p sub:%p failed to create new subquery due to error:%s, abort retry, vgId:%d, orderOfSub:%d",
- trsupport->pParentSql, pSql, tstrerror(terrno), pVgroup->vgId, trsupport->subqueryIndex);
+ oriTrs->pParentSql, pSql, tstrerror(terrno), pVgroup->vgId, oriTrs->subqueryIndex);
pParentSql->res.code = terrno;
- trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
+ oriTrs->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
+ tfree(trsupport);
return pParentSql->res.code;
}
int32_t ret = tscProcessSql(pNew);
+ *sent = 1;
+
// if failed to process sql, let following code handle the pSql
if (ret == TSDB_CODE_SUCCESS) {
+ tscFreeRetrieveSup(pSql);
taos_free_result(pSql);
return ret;
- } else {
+ } else {
+ pParentSql->pSubs[trsupport->subqueryIndex] = pSql;
+ tscFreeRetrieveSup(pNew);
+ taos_free_result(pNew);
return ret;
}
}
@@ -2328,7 +2408,10 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
subqueryIndex, tstrerror(pParentSql->res.code));
} else {
if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY && pParentSql->res.code == TSDB_CODE_SUCCESS) {
- if (tscReissueSubquery(trsupport, pSql, numOfRows) == TSDB_CODE_SUCCESS) {
+ int32_t sent = 0;
+
+ tscReissueSubquery(trsupport, pSql, numOfRows, &sent);
+ if (sent) {
return;
}
} else { // reach the maximum retry count, abort
@@ -2450,7 +2533,6 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
SRetrieveSupport *trsupport = (SRetrieveSupport *)param;
if (pSql->param == NULL || param == NULL) {
tscDebug("%p already freed in dnodecallback", pSql);
- assert(pSql->res.code == TSDB_CODE_TSC_QUERY_CANCELLED);
return;
}
@@ -2482,7 +2564,10 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY) {
tscError("%p sub:%p failed code:%s, retry:%d", pParentSql, pSql, tstrerror(numOfRows), trsupport->numOfRetry);
- if (tscReissueSubquery(trsupport, pSql, numOfRows) == TSDB_CODE_SUCCESS) {
+ int32_t sent = 0;
+
+ tscReissueSubquery(trsupport, pSql, numOfRows, &sent);
+ if (sent) {
return;
}
} else {
@@ -2604,7 +2689,11 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY) {
tscError("%p sub:%p failed code:%s, retry:%d", pParentSql, pSql, tstrerror(code), trsupport->numOfRetry);
- if (tscReissueSubquery(trsupport, pSql, code) == TSDB_CODE_SUCCESS) {
+
+ int32_t sent = 0;
+
+ tscReissueSubquery(trsupport, pSql, code, &sent);
+ if (sent) {
return;
}
} else {
diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c
index 52ede2318fbe62eafbfe763a03aa4c24c7e72983..4da922dadd1cf7fa55c4c7423568045886e61ab2 100644
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -47,10 +47,11 @@ void *tscRpcCache; // cache to keep rpc obj
int32_t tscNumOfThreads = 1; // num of rpc threads
static pthread_mutex_t rpcObjMutex; // mutex to protect open the rpc obj concurrently
static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
+static volatile int tscInitRes = 0;
void tscCheckDiskUsage(void *UNUSED_PARAM(para), void *UNUSED_PARAM(param)) {
taosGetDisk();
- taosTmrReset(tscCheckDiskUsage, 1000, NULL, tscTmr, &tscCheckDiskUsageTmr);
+ taosTmrReset(tscCheckDiskUsage, 20 * 1000, NULL, tscTmr, &tscCheckDiskUsageTmr);
}
void tscFreeRpcObj(void *param) {
assert(param);
@@ -64,7 +65,7 @@ void tscReleaseRpc(void *param) {
return;
}
pthread_mutex_lock(&rpcObjMutex);
- taosCacheRelease(tscRpcCache, (void *)¶m, true);
+ taosCacheRelease(tscRpcCache, (void *)¶m, false);
pthread_mutex_unlock(&rpcObjMutex);
}
@@ -101,7 +102,7 @@ int32_t tscAcquireRpc(const char *key, const char *user, const char *secretEncry
tscError("failed to init connection to TDengine");
return -1;
}
- pRpcObj = taosCachePut(tscRpcCache, rpcObj.key, strlen(rpcObj.key), &rpcObj, sizeof(rpcObj), 1000*10);
+ pRpcObj = taosCachePut(tscRpcCache, rpcObj.key, strlen(rpcObj.key), &rpcObj, sizeof(rpcObj), 1000*5);
if (pRpcObj == NULL) {
rpcClose(rpcObj.pDnodeConn);
pthread_mutex_unlock(&rpcObjMutex);
@@ -137,7 +138,11 @@ void taos_init_imp(void) {
}
taosReadGlobalCfg();
- taosCheckGlobalCfg();
+ if (taosCheckGlobalCfg()) {
+ tscInitRes = -1;
+ return;
+ }
+
taosInitNotes();
rpcInit();
@@ -154,16 +159,18 @@ void taos_init_imp(void) {
if (tscNumOfThreads < 2) {
tscNumOfThreads = 2;
}
+ taosTmrThreads = tscNumOfThreads;
tscQhandle = taosInitScheduler(queueSize, tscNumOfThreads, "tsc");
if (NULL == tscQhandle) {
tscError("failed to init scheduler");
+ tscInitRes = -1;
return;
}
tscTmr = taosTmrInit(tsMaxConnections * 2, 200, 60000, "TSC");
if(0 == tscEmbedded){
- taosTmrReset(tscCheckDiskUsage, 10, NULL, tscTmr, &tscCheckDiskUsageTmr);
+ taosTmrReset(tscCheckDiskUsage, 20 * 1000, NULL, tscTmr, &tscCheckDiskUsageTmr);
}
if (tscTableMetaInfo == NULL) {
@@ -186,7 +193,7 @@ void taos_init_imp(void) {
tscDebug("client is initialized successfully");
}
-void taos_init() { pthread_once(&tscinit, taos_init_imp); }
+int taos_init() { pthread_once(&tscinit, taos_init_imp); return tscInitRes;}
// this function may be called by user or system, or by both simultaneously.
void taos_cleanup(void) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 95cf28ec49346e500d00c1bcac9dc6f4055a0eb4..727ca9ad7f3a50442eb5a4eb461deda1ff283b32 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -2057,6 +2057,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
pnCmd->parseFinished = 1;
pnCmd->pTableNameList = NULL;
pnCmd->pTableBlockHashList = NULL;
+ pnCmd->tagData.data = NULL;
+ pnCmd->tagData.dataLen = 0;
if (tscAddSubqueryInfo(pnCmd) != TSDB_CODE_SUCCESS) {
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
diff --git a/src/client/tests/CMakeLists.txt b/src/client/tests/CMakeLists.txt
index 4ea0b80bf7c1c870532f1bc3cac313c43f1a57f0..f07af85e255eaa5e285d9a4ce0853251e0fdaa21 100644
--- a/src/client/tests/CMakeLists.txt
+++ b/src/client/tests/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
FIND_PATH(HEADER_GTEST_INCLUDE_DIR gtest.h /usr/include/gtest /usr/local/include/gtest)
diff --git a/src/client/tests/cliTest.cpp b/src/client/tests/cliTest.cpp
index 5cfe61d92a1ea36cc41585e314e907a10ea9ff59..30f248b5418b54b1be26dfcf15348b03fd70af4d 100644
--- a/src/client/tests/cliTest.cpp
+++ b/src/client/tests/cliTest.cpp
@@ -57,7 +57,7 @@ void stmtInsertTest() {
v.ts = start_ts + 20;
v.k = 123;
- char* str = "abc";
+ char str[] = "abc";
uintptr_t len = strlen(str);
v.a = str;
@@ -65,7 +65,7 @@ void stmtInsertTest() {
params[2].buffer_length = len;
params[2].buffer = str;
- char* nstr = "999";
+ char nstr[] = "999";
uintptr_t len1 = strlen(nstr);
v.b = nstr;
@@ -84,18 +84,18 @@ void stmtInsertTest() {
v.ts = start_ts + 30;
v.k = 911;
- str = "92";
- len = strlen(str);
+ char str1[] = "92";
+ len = strlen(str1);
params[2].length = &len;
params[2].buffer_length = len;
- params[2].buffer = str;
+ params[2].buffer = str1;
- nstr = "1920";
- len1 = strlen(nstr);
+ char nstr1[] = "1920";
+ len1 = strlen(nstr1);
params[3].buffer_length = len1;
- params[3].buffer = nstr;
+ params[3].buffer = nstr1;
params[3].length = &len1;
taos_stmt_bind_param(stmt, params);
@@ -103,7 +103,7 @@ void stmtInsertTest() {
ret = taos_stmt_execute(stmt);
if (ret != 0) {
- printf("%p\n", ret);
+ printf("%d\n", ret);
printf("\033[31mfailed to execute insert statement.\033[0m\n");
return;
}
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index df0ac7986599da3e53d97f64c0c5113a357f9177..0da7bda994db83882e36e9d52a7983635ad85330 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
INCLUDE_DIRECTORIES(inc)
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index fb6d7459318174bc864b8d0cc813df3d3e65dc00..349ccb35acd52aa5e3ccd5882d03a596e3e064ec 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -373,6 +373,23 @@ static void taosCheckDataDirCfg() {
}
}
+static int32_t taosCheckTmpDir(void) {
+ if (strlen(tsTempDir) <= 0){
+ uError("tempDir is not set");
+ return -1;
+ }
+
+ DIR *dir = opendir(tsTempDir);
+ if (dir == NULL) {
+ uError("can not open tempDir:%s, error:%s", tsTempDir, strerror(errno));
+ return -1;
+ }
+
+ closedir(dir);
+
+ return 0;
+}
+
static void doInitGlobalConfig(void) {
osInit();
srand(taosSafeRand());
@@ -1488,6 +1505,11 @@ int32_t taosCheckGlobalCfg() {
}
taosCheckDataDirCfg();
+
+ if (taosCheckTmpDir()) {
+ return -1;
+ }
+
taosGetSystemInfo();
tsSetLocale();
@@ -1533,6 +1555,8 @@ int32_t taosCheckGlobalCfg() {
tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
}
+ uInfo(" check global cfg completed");
+ uInfo("==================================");
taosPrintGlobalCfg();
return 0;
diff --git a/src/connector/jdbc/CMakeLists.txt b/src/connector/jdbc/CMakeLists.txt
index 59b09c8695d59c1fd0584f73a7e4be1eb1ab1c0b..47d6b90e916e4f16446e6e0ebff2e21e3f15474a 100644
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
POST_BUILD
COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
- COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.18-dist.jar ${LIBRARY_OUTPUT_PATH}
+ COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.19-dist.jar ${LIBRARY_OUTPUT_PATH}
COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
COMMENT "build jdbc driver")
ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})
diff --git a/src/connector/jdbc/deploy-pom.xml b/src/connector/jdbc/deploy-pom.xml
index 34b0a3c6d37530ad01600a455d426c1606613c23..f6221aca89e67426a28b1cf4e90e699d9963ca0e 100755
--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@@ -5,7 +5,7 @@
com.taosdata.jdbc
taos-jdbcdriver
- 2.0.18
+ 2.0.19
jar
JDBCDriver
diff --git a/src/connector/jdbc/pom.xml b/src/connector/jdbc/pom.xml
index 0626bcf1fb1161cc38ad05002b984b2200b68d68..8ebf8aa5cceb1060f735ec498c913c7606747fd5 100755
--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -3,7 +3,7 @@
4.0.0
com.taosdata.jdbc
taos-jdbcdriver
- 2.0.18
+ 2.0.19
jar
JDBCDriver
https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc
@@ -81,8 +81,6 @@
commons-dbcp2
2.7.0
-
-
@@ -130,8 +128,10 @@
**/AppMemoryLeakTest.java
+ **/AuthenticationTest.java
**/TaosInfoMonitorTest.java
**/FailOverTest.java
+ **/InvalidResultSetPointerTest.java
true
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb621bd1308e18d7d404fcc7b53e9fa07d487d73
--- /dev/null
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
@@ -0,0 +1,529 @@
+package com.taosdata.jdbc;
+
+import java.sql.*;
+import java.util.Enumeration;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.*;
+
+public abstract class AbstractConnection extends WrapperImpl implements Connection {
+
+ protected volatile boolean isClosed;
+ protected volatile String catalog;
+ protected volatile Properties clientInfoProps = new Properties();
+
+ @Override
+ public abstract Statement createStatement() throws SQLException;
+
+ @Override
+ public abstract PreparedStatement prepareStatement(String sql) throws SQLException;
+
+ @Override
+ public CallableStatement prepareCall(String sql) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public String nativeSQL(String sql) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+ // do nothing
+ return sql;
+ }
+
+ @Override
+ public void setAutoCommit(boolean autoCommit) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ //do nothing
+ }
+
+ @Override
+ public boolean getAutoCommit() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ return true;
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ // do nothing
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ // do nothing
+ }
+
+ @Override
+ public abstract void close() throws SQLException;
+
+ @Override
+ public abstract boolean isClosed() throws SQLException;
+
+ @Override
+ public abstract DatabaseMetaData getMetaData() throws SQLException;
+
+ @Override
+ public void setReadOnly(boolean readOnly) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ //do nothing
+ }
+
+ @Override
+ public boolean isReadOnly() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+ return true;
+ }
+
+ @Override
+ public void setCatalog(String catalog) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+ /*
+ try (Statement stmt = createStatement()) {
+ boolean execute = stmt.execute("use " + catalog);
+ if (execute)
+ this.catalog = catalog;
+ } catch (SQLException e) {
+ // do nothing
+ }
+ */
+
+ this.catalog = catalog;
+ }
+
+ @Override
+ public String getCatalog() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ return this.catalog;
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (level) {
+ case Connection.TRANSACTION_NONE:
+ break;
+ case Connection.TRANSACTION_READ_UNCOMMITTED:
+ case Connection.TRANSACTION_READ_COMMITTED:
+ case Connection.TRANSACTION_REPEATABLE_READ:
+ case Connection.TRANSACTION_SERIALIZABLE:
+ throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
+ default:
+ throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+ }
+ //do nothing
+ }
+
+ @Override
+ public int getTransactionIsolation() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ return Connection.TRANSACTION_NONE;
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ return null;
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ // do nothing
+ }
+
+ @Override
+ public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (resultSetType) {
+ case ResultSet.TYPE_FORWARD_ONLY:
+ break;
+ case ResultSet.TYPE_SCROLL_INSENSITIVE:
+ case ResultSet.TYPE_SCROLL_SENSITIVE:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+
+ switch (resultSetConcurrency) {
+ case ResultSet.CONCUR_READ_ONLY:
+ break;
+ case ResultSet.CONCUR_UPDATABLE:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+
+ return createStatement();
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (resultSetType) {
+ case ResultSet.TYPE_FORWARD_ONLY:
+ break;
+ case ResultSet.TYPE_SCROLL_INSENSITIVE:
+ case ResultSet.TYPE_SCROLL_SENSITIVE:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+
+ switch (resultSetConcurrency) {
+ case ResultSet.CONCUR_READ_ONLY:
+ break;
+ case ResultSet.CONCUR_UPDATABLE:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+ return prepareStatement(sql);
+ }
+
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public Map> getTypeMap() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public void setTypeMap(Map> map) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public void setHoldability(int holdability) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (holdability) {
+ case ResultSet.HOLD_CURSORS_OVER_COMMIT:
+ break;
+ case ResultSet.CLOSE_CURSORS_AT_COMMIT:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+ //do nothing
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ return ResultSet.HOLD_CURSORS_OVER_COMMIT;
+ }
+
+ @Override
+ public Savepoint setSavepoint() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public Savepoint setSavepoint(String name) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public void rollback(Savepoint savepoint) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (resultSetHoldability) {
+ case ResultSet.HOLD_CURSORS_OVER_COMMIT:
+ break;
+ case ResultSet.CLOSE_CURSORS_AT_COMMIT:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+
+ return createStatement(resultSetType, resultSetConcurrency);
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+ throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (resultSetHoldability) {
+ case ResultSet.HOLD_CURSORS_OVER_COMMIT:
+ break;
+ case ResultSet.CLOSE_CURSORS_AT_COMMIT:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ default:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+ }
+ return prepareStatement(sql, resultSetType, resultSetConcurrency);
+ }
+
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ switch (autoGeneratedKeys) {
+ case Statement.RETURN_GENERATED_KEYS:
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ case Statement.NO_GENERATED_KEYS:
+ break;
+ }
+ return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public Clob createClob() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public Blob createBlob() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public NClob createNClob() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public SQLXML createSQLXML() throws SQLException {
+ if (isClosed())
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
+ }
+
+ @Override
+ public boolean isValid(int timeout) throws SQLException {
+ //true if the connection is valid, false otherwise
+ if (isClosed())
+ return false;
+ if (timeout < 0) //SQLException - if the value supplied for timeout is less then 0
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
+
+ ExecutorService executor = Executors.newCachedThreadPool();
+ Future future = executor.submit(() -> {
+ int status;
+ try (Statement stmt = createStatement()) {
+ ResultSet resultSet = stmt.executeQuery("select server_status()");
+ resultSet.next();
+ status = resultSet.getInt("server_status()");
+ resultSet.close();
+ }
+ return status == 1 ? true : false;
+ });
+
+ boolean status = false;
+ try {
+ if (timeout == 0)
+ status = future.get();
+ else
+ status = future.get(timeout, TimeUnit.SECONDS);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ } catch (ExecutionException e) {
+ e.printStackTrace();
+ } catch (TimeoutException e) {
+ future.cancel(true);
+ status = false;
+ } finally {
+ executor.shutdownNow();
+ }
+ return status;
+ }
+
+ @Override
+ public void setClientInfo(String name, String value) throws SQLClientInfoException {
+ if (isClosed)
+ throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ if (clientInfoProps == null)
+ clientInfoProps = new Properties();
+ clientInfoProps.setProperty(name, value);
+ }
+
+ @Override
+ public void setClientInfo(Properties properties) throws SQLClientInfoException {
+ if (isClosed)
+ throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
+
+ for (Enumeration