Merge branch 'develop' into feature/dockerfile

CMakeLists.txt

@@ -26,10 +26,17 @@ SET(CMAKE_VERBOSE_MAKEFILE ON)
 #     open the file named TDengine.sln
 #
 
+SET(TD_GODLL FALSE)
+IF (${DLLTYPE} MATCHES "go")
+  ADD_DEFINITIONS(-D_TD_GO_DLL_)
+  MESSAGE(STATUS "input dll type: " ${DLLTYPE})
+  SET(TD_GODLL TRUE)
+ENDIF ()
+
 IF (NOT DEFINED TD_CLUSTER)
   MESSAGE(STATUS "Build the Lite Version")
   SET(TD_CLUSTER FALSE)
-  SET(TD_LITE TRUE)
+  SET(TD_EDGE TRUE)
 
   SET(TD_COMMUNITY_DIR ${PROJECT_SOURCE_DIR})
   MESSAGE(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
@@ -41,34 +48,49 @@ IF (NOT DEFINED TD_CLUSTER)
   SET(TD_ARM FALSE)
   SET(TD_ARM_64 FALSE)
   SET(TD_ARM_32 FALSE)
+  SET(TD_MIPS FALSE)
   SET(TD_MIPS_64 FALSE)
+  SET(TD_MIPS_32 FALSE)
   SET(TD_DARWIN_64 FALSE)
   SET(TD_WINDOWS_64 FALSE)
+  SET(TD_PAGMODE_LITE FALSE)
+  
+  IF (${PAGMODE} MATCHES "lite")
+    SET(TD_PAGMODE_LITE TRUE)
+  ENDIF ()
 
   # if generate ARM version:
-  #   cmake -DARMVER=arm32 .. or cmake -DARMVER=arm64
-  IF (${ARMVER} MATCHES "arm32")
+  #   cmake -DCPUTYPE=aarch32 .. or cmake -DCPUTYPE=aarch64
+  IF (${CPUTYPE} MATCHES "aarch32")
     SET(TD_ARM TRUE)
     SET(TD_ARM_32 TRUE)
+    SET(TD_PAGMODE_LITE TRUE)
     ADD_DEFINITIONS(-D_TD_ARM_)
     ADD_DEFINITIONS(-D_TD_ARM_32_)
-  ELSEIF (${ARMVER} MATCHES "arm64")
+  ELSEIF (${CPUTYPE} MATCHES "aarch64")
     SET(TD_ARM TRUE)
     SET(TD_ARM_64 TRUE)
     ADD_DEFINITIONS(-D_TD_ARM_)
     ADD_DEFINITIONS(-D_TD_ARM_64_)
+  ELSEIF (${CPUTYPE} MATCHES "mips64")
+    SET(TD_MIPS TRUE)
+    SET(TD_MIPS_64 TRUE)
+    ADD_DEFINITIONS(-D_TD_MIPS_)
+    ADD_DEFINITIONS(-D_TD_MIPS_64_)
+  ELSEIF (${CPUTYPE} MATCHES "x64")
+    MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
+  ELSEIF (${CPUTYPE} MATCHES "x86")
+    MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
+  ELSE ()
+    MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
   ENDIF ()
 
-  IF (TD_ARM)
-    ADD_DEFINITIONS(-D_TD_ARM_)
-    IF (TD_ARM_32)
-      ADD_DEFINITIONS(-D_TD_ARM_32_)
-    ELSEIF (TD_ARM_64)
-      ADD_DEFINITIONS(-D_TD_ARM_64_)
-    ELSE ()
-      EXIT ()
-    ENDIF ()
-  ENDIF ()
+  #
+  # Get OS information and store in variable TD_OS_INFO.
+  #
+  execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh)
+  execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
+  MESSAGE(STATUS "The current os is " ${TD_OS_INFO})
 
   IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
@@ -76,17 +98,17 @@ IF (NOT DEFINED TD_CLUSTER)
       SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/linux)
       ADD_DEFINITIONS(-D_M_X64)
       MESSAGE(STATUS "The current platform is Linux 64-bit")
-  ELSEIF (${CMAKE_SIZEOF_VOID_P} MATCHES 4)
-    IF (TD_ARM)
-      SET(TD_LINUX_32 TRUE)
-      SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/linux)
-      #ADD_DEFINITIONS(-D_M_IX86)
-      MESSAGE(STATUS "The current platform is Linux 32-bit")
+    ELSEIF (${CMAKE_SIZEOF_VOID_P} MATCHES 4)
+      IF (TD_ARM)
+        SET(TD_LINUX_32 TRUE)
+        SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/linux)
+        #ADD_DEFINITIONS(-D_M_IX86)
+        MESSAGE(STATUS "The current platform is Linux 32-bit")
+      ELSE ()
+        MESSAGE(FATAL_ERROR "The current platform is Linux 32-bit, but no ARM not supported yet")
+        EXIT ()
+      ENDIF ()
     ELSE ()
-      MESSAGE(FATAL_ERROR "The current platform is Linux 32-bit, but no ARM not supported yet")
-      EXIT ()
-    ENDIF ()
-  ELSE ()
       MESSAGE(FATAL_ERROR "The current platform is Linux neither 32-bit nor 64-bit, not supported yet")
       EXIT ()
     ENDIF ()
@@ -141,37 +163,51 @@ IF (NOT DEFINED TD_CLUSTER)
     SET(RELEASE_FLAGS "-O0")
     IF (NOT TD_ARM)
       IF (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
-        SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -Wno-char-subscripts -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+        SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
       ELSE ()
-        SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -Wno-char-subscripts -malign-stringops -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+        SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -malign-stringops -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
       ENDIF ()
     ELSE ()
-      SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -g -Wno-char-subscripts -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+      SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
     ENDIF ()
     ADD_DEFINITIONS(-DLINUX)
     ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
+    IF (${TD_OS_INFO} MATCHES "Alpine")
+      MESSAGE(STATUS "The current OS is Alpine, append extra flags")
+      SET(COMMON_FLAGS "${COMMON_FLAGS} -largp")
+      link_libraries(/usr/lib/libargp.a)
+      ADD_DEFINITIONS(-D_ALPINE)
+    ENDIF ()
   ELSEIF (TD_LINUX_32)
     IF (NOT TD_ARM)
       EXIT ()
     ENDIF ()
     SET(DEBUG_FLAGS "-O0 -DDEBUG")
     SET(RELEASE_FLAGS "-O0")
-    SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -g -Wno-char-subscripts -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+    SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -g -fsigned-char -munaligned-access -fpack-struct=8 -latomic -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
     ADD_DEFINITIONS(-DLINUX)
     ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
     ADD_DEFINITIONS(-DUSE_LIBICONV)
+    IF (${TD_OS_INFO} MATCHES "Alpine")
+      MESSAGE(STATUS "The current OS is Alpine, add extra flags")
+      SET(COMMON_FLAGS "${COMMON_FLAGS} -largp")
+      link_library(/usr/lib/libargp.a)
+      ADD_DEFINITIONS(-D_ALPINE)
+    ENDIF ()
   ELSEIF (TD_WINDOWS_64)
     SET(CMAKE_GENERATOR "NMake Makefiles" CACHE INTERNAL "" FORCE)
-    SET(COMMON_FLAGS "/nologo /WX- /Oi /Oy- /Gm- /EHsc /MT /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Gd /errorReport:prompt /analyze-")
-    SET(DEBUG_FLAGS "/Zi /W3 /GL")
-    SET(RELEASE_FLAGS "/W0 /GL")
+    IF (NOT TD_GODLL)
+      SET(COMMON_FLAGS "/nologo /WX- /Oi /Oy- /Gm- /EHsc /MT /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Gd /errorReport:prompt /analyze-")
+      SET(DEBUG_FLAGS "/Zi /W3 /GL")
+      SET(RELEASE_FLAGS "/W0 /GL")
+    ENDIF ()
     ADD_DEFINITIONS(-DWINDOWS)
     ADD_DEFINITIONS(-D__CLEANUP_C)
     ADD_DEFINITIONS(-DPTW32_STATIC_LIB)
     ADD_DEFINITIONS(-DPTW32_BUILD)
     ADD_DEFINITIONS(-D_MBCS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
   ELSEIF (TD_DARWIN_64)
-    SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -Wno-char-subscripts -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-unused-variable -Wno-bitfield-constant-conversion")
+    SET(COMMON_FLAGS "-std=gnu99 -Wall -fPIC -malign-double -g -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
     SET(DEBUG_FLAGS "-O0 -DDEBUG")
     SET(RELEASE_FLAGS "-O0")
     ADD_DEFINITIONS(-DDARWIN)
@@ -230,21 +266,31 @@ IF (NOT DEFINED TD_CLUSTER)
     INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR})")  
   ELSEIF (TD_WINDOWS_64)
     SET(CMAKE_INSTALL_PREFIX C:/TDengine)
-    INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go DESTINATION connector)
-    INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/grafana DESTINATION connector)
-    INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
-    INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/tests/examples DESTINATION .)
-    INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/packaging/cfg DESTINATION .)
-    INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taos.h DESTINATION include)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver)
-    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
-    #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
-    #INSTALL(TARGETS shell RUNTIME DESTINATION .)
-    IF (TD_MVN_INSTALLED)
-      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-1.0.2-dist.jar DESTINATION connector/jdbc)
+    IF (NOT TD_GODLL)
+      INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go DESTINATION connector)
+      INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/grafana DESTINATION connector)
+      INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
+      INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/tests/examples DESTINATION .)
+      INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/packaging/cfg DESTINATION .)
+      INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taos.h DESTINATION include)
+      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
+      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
+      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver)    
+      INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
+      #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
+      #INSTALL(TARGETS shell RUNTIME DESTINATION .)
+      IF (TD_MVN_INSTALLED)
+        INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-1.0.2-dist.jar DESTINATION connector/jdbc)
+      ENDIF ()
+    ELSE ()
+      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libtaos.dll DESTINATION driver)
+      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libtaos.dll.a DESTINATION driver)
     ENDIF ()
+  ELSEIF (TD_DARWIN_64)
+    SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
+    INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
+    INSTALL(CODE "execute_process(COMMAND chmod 777 ${TD_MAKE_INSTALL_SH})")
+    INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} ${TD_COMMUNITY_DIR} ${PROJECT_BINARY_DIR} Darwin)")
   ENDIF ()
 ENDIF ()
 

README.md

@@ -39,12 +39,24 @@ sudo apt-get install maven
 ```
 
 Build TDengine:
-```cmd
 
+```
 mkdir build && cd build
 cmake .. && cmake --build .
 ```
 
+To compile on an ARM processor (aarch64 or aarch32), please add option CPUTYPE as below:
+
+aarch64:
+```cmd
+cmake .. -DCPUTYPE=aarch64 && cmake --build .
+```
+
+aarch32:
+```cmd
+cmake .. -DCPUTYPE=aarch32 && cmake --build .
+```
+
 # Quick Run
 To quickly start a TDengine server after building, run the command below in terminal:
 ```cmd
@@ -118,3 +130,8 @@ The TDengine community has also kindly built some of their own connectors! Follo
 # Contribute to TDengine
 
 Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to the project.
+
+# Join TDengine WeChat Group
+
+Add WeChat “tdengine” to join the group，you can communicate with other users.
+

deps/iconv/iconv.c

@@ -175,7 +175,10 @@ static const struct alias sysdep_aliases[] = {
 #ifdef __GNUC__
 __inline
 #endif
-const struct alias *
+// gcc -o0 bug fix 
+// see http://git.savannah.gnu.org/gitweb/?p=libiconv.git;a=blobdiff;f=lib/iconv.c;h=31853a7f1c47871221189dbf597473a16d8a8da7;hp=5a1a32597fa3efc5f69624d37a2eb96f308cd241;hb=b29089d8b43abc8fba073da7e6dccaeba56b2b70;hpb=0a04404c90d6a725b8b6bbcd65e10c5fcf5993e9
+
+static const struct alias *
 aliases2_lookup (register const char *str)
 {
   const struct alias * ptr;

documentation/tdenginedocs-cn/connector/index.html

@@ -114,23 +114,84 @@ public Connection getConn() throws Exception{
 </ul>
 <p>对于TDengine操作的报错信息，用户可使用JDBCDriver包里提供的枚举类TSDBError.java来获取error message和error code的列表。对于更多的具体操作的相关代码，请参考TDengine提供的使用示范项目<code>JDBCDemo</code>。</p>
 <a class='anchor' id='Python-Connector'></a><h2>Python Connector</h2>
-<a class='anchor' id='Python客户端安装'></a><h3>Python客户端安装</h3>
-<p>用户可以在源代码的src/connector/python文件夹下找到python2和python3的安装包。用户可以通过pip命令安装： </p>
-<p>​    <code>pip install src/connector/python/python2/</code></p>
-<p>或</p>
-<p>​    <code>pip install src/connector/python/python3/</code></p>
-<p>如果机器上没有pip命令，用户可将src/connector/python/python3或src/connector/python/python2下的taos文件夹拷贝到应用程序的目录使用。</p>
-<a class='anchor' id='Python客户端接口'></a><h3>Python客户端接口</h3>
-<p>在使用TDengine的python接口时，需导入TDengine客户端模块：</p>
-<pre><code>import taos </code></pre>
-<p>用户可通过python的帮助信息直接查看模块的使用信息，或者参考code/examples/python中的示例程序。以下为部分常用类和方法：</p>
+<a class='anchor' id='安装准备'></a><h3>安装准备</h3>
+<li>已安装TDengine, 如果客户端在Windows上，需要安装Windows 版本的TDengine客户端</li>
+<li>已安装python 2.7 or >= 3.4</li>
+<li>已安装pip</li>
+<a class='anchor' id='安装'></a><h3>安装</h3>
+<a class='anchor' id='Linux'></a><h4>Linux</h4>
+<p>用户可以在源代码的src/connector/python文件夹下找到python2和python3的安装包， 然后通过pip命令安装</p>
+<pre><code class="cmd language-cmd">pip install src/connector/python/linux/python2/</code></pre>
+<p>或者</p>
+<pre><code>pip install src/connector/python/linux/python3/</code></pre>
+<a class='anchor' id='Windows'></a><h4>Windows</h4>
+<p>在已安装Windows TDengine 客户端的情况下， 将文件"C:\TDengine\driver\taos.dll" 拷贝到 "C:\windows\system32" 目录下, 然后进入Windwos <em>cmd</em> 命令行界面</p>
+<pre><code>cd C:\TDengine\connector\python\windows</code></pre>
+<pre><code>pip install python2\</code></pre>
+<p>或者</p>
+<pre><code>cd C:\TDengine\connector\python\windows</code></pre>
+<pre><code>pip install python3\</code></pre>
+<p>* 如果机器上没有<em>pip</em>命令，用户可将src/connector/python/windows/python3或src/connector/python/windows/python2下的taos文件夹拷贝到应用程序的目录使用。 </p>
+<a class='anchor' id='使用'></a><h3>使用</h3>
+<a class='anchor' id='代码示例'></a><h4>代码示例</h4>
+<li>导入TDengine客户端模块：</li>
+<pre><code class="python language-python">import taos </code></pre>
+<li>获取连接</li>
+<pre><code>
+conn = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos")
+c1 = conn.cursor()
+</code></pre>
+<p>* <em>host 是TDengine 服务端所有IP, config 为客户端配置文件所在目录</em></p>
+<li>写入数据</li>
+<pre><code>
+import datetime
+ 
+# 创建数据库
+c1.execute('create database db')
+c1.execute('use db')
+# 建表
+c1.execute('create table tb (ts timestamp, temperature int, humidity float)')
+# 插入数据
+start_time = datetime.datetime(2019, 11, 1)
+affected_rows = c1.execute('insert into tb values (\'%s\', 0, 0.0)' %start_time)
+# 批量插入数据
+time_interval = datetime.timedelta(seconds=60)
+sqlcmd = ['insert into tb values']
+for irow in range(1,11):
+  start_time += time_interval
+  sqlcmd.append('(\'%s\', %d, %f)' %(start_time, irow, irow*1.2))
+affected_rows = c1.execute(' '.join(sqlcmd))
+</code></pre>
+<li>查询数据</li>
+<code><pre>
+c1.execute('select * from tb')
+# 拉取查询结果
+data = c1.fetchall()
+# 返回的结果是一个列表，每一行构成列表的一个元素
+numOfRows = c1.rowcount
+numOfCols = c1.descriptions
+for irow in range(numOfRows):
+  print("Row%d: ts=%s, temperature=%d, humidity=%f" %(irow, data[irow][0], data[irow][1],data[irow][2])
+  
+# 直接使用cursor 循环拉取查询结果
+c1.execute('select * from tb')
+for data in c1:
+  print("ts=%s, temperature=%d, humidity=%f" %(data[0], data[1],data[2])
+</pre></code>
+<li>关闭连接</li>
+<code><pre>
+c1.close()
+conn.close()
+</pre></code>
+<a class='anchor' id='帮助信息''></a><h4>帮助信息</h4>
+<p>用户可通过python的帮助信息直接查看模块的使用信息，或者参考code/examples/python中的示例程序。以下为部分常用类和方法:</p>
 <ul>
-<li><p><em>TaosConnection</em>类</p>
-<p>参考python中help(taos.TaosConnection)。</p></li>
-<li><p><em>TaosCursor</em>类</p>
-<p>参考python中help(taos.TaosCursor)。</p></li>
-<li><p><em>connect</em>方法</p>
-<p>用于生成taos.TaosConnection的实例。</p></li>
+<li><p><em>TaosConnection</em> 类</p>
+<p>参考python中<code>help(taos.TDengineConnection)</code></p></li>
+<li><p><em>TaosCursor</em> 类</p>
+<p>参考python中<code>help(taos.TDengineCursor)</code></p></li>
+<li><p>connect 方法</p>
+<p>用于生成taos.TDengineConnection的实例。</p></li>
 </ul>
 <a class='anchor' id='RESTful-Connector'></a><h2>RESTful Connector</h2>
 <p>为支持各种不同类型平台的开发，TDengine提供符合REST设计标准的API，即RESTful API。为最大程度降低学习成本，不同于其他数据库RESTful API的设计方法，TDengine直接通过HTTP POST 请求BODY中包含的SQL语句来操作数据库，仅需要一个URL。 </p>

documentation/tdenginedocs-cn/getting-started/index.html

@@ -28,7 +28,7 @@
 <p>在TDengine终端中，用户可以通过SQL命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的SQL语句需要以分号结束来运行。示例：</p>
 <pre><code class="mysql language-mysql">create database db;
 use db;
-create table t (ts timestamp, cdata int);
+create table t (ts timestamp, speed int);
 insert into t values ('2019-07-15 00:00:00', 10);
 insert into t values ('2019-07-15 01:00:00', 20);
 select * from t;
@@ -85,4 +85,4 @@ Query OK, 2 row(s) in set (0.001700s)</code></pre>
 </ul>
 <p>TDengine是专为物联网、车联网、工业互联网、运维监测等场景优化设计的时序数据处理引擎。与其他方案相比，它的插入查询速度都快10倍以上。单核一秒钟就能插入100万数据点，读出1000万数据点。由于采用列式存储和优化的压缩算法，存储空间不及普通数据库的1/10.</p>
 <a class='anchor' id='深入了解TDengine'></a><h2>深入了解TDengine</h2>
-<p>请继续阅读<a href="../documentation">文档</a>来深入了解TDengine。</p><a href='../index.html'>回去</a></section></main></div><?php include($s.'/footer.php'); ?><script>$('pre').addClass('prettyprint linenums');PR.prettyPrint()</script><script src='lib/docs/liner.js'></script></body></html>
\ No newline at end of file
+<p>请继续阅读<a href="../documentation">文档</a>来深入了解TDengine。</p><a href='../index.html'>回去</a></section></main></div><?php include($s.'/footer.php'); ?><script>$('pre').addClass('prettyprint linenums');PR.prettyPrint()</script><script src='lib/docs/liner.js'></script></body></html>

documentation/tdenginedocs-cn/super-table/index.html

@@ -32,7 +32,7 @@ tags (location binary(20), type int)</code></pre>
 <p>查看数据库内全部STable，及其相关信息，包括STable的名称、创建时间、列数量、标签（TAG）数量、通过该STable建表的数量。 </p></li>
 <li><p>删除超级表</p>
 <pre><code class="mysql language-mysql">DROP TABLE &lt;stable_name&gt;</code></pre>
-<p>Note: 删除STable不会级联删除通过STable创建的表；相反删除STable时要求通过该STable创建的表都已经被删除。</p></li>
+<p>Note: 删除STable时，所有通过该STable创建的表都将被删除。</p></li>
 <li><p>查看属于某STable并满足查询条件的表</p>
 <pre><code class="mysql language-mysql">SELECT TBNAME,[TAG_NAME,…] FROM &lt;stable_name&gt; WHERE &lt;tag_name&gt; &lt;[=|=&lt;|&gt;=|&lt;&gt;] values..&gt; ([AND|OR] …)</code></pre>
 <p>查看属于某STable并满足查询条件的表。说明：TBNAME为关键词，显示通过STable建立的子表表名，查询过程中可以使用针对标签的条件。</p>

documentation/tdenginedocs-en/connector/index.html

@@ -122,15 +122,76 @@ public Connection getConn() throws Exception{
 </ul>
 <p>All the error codes and error messages can be found in <code>TSDBError.java</code> . For a more detailed coding example, please refer to the demo project <code>JDBCDemo</code> in TDengine's code examples. </p>
 <a class='anchor' id='Python-Connector'></a><h2>Python Connector</h2>
-<a class='anchor' id='Install-TDengine-Python-client'></a><h3>Install TDengine Python client</h3>
-<p>Users can find python client packages in our source code directory <em>src/connector/python</em>. There are two directories corresponding two python versions. Please choose the correct package to install. Users can use <em>pip</em> command to install:</p>
-<pre><code class="cmd language-cmd">pip install src/connector/python/python2/</code></pre>
+<a class='anchor' id='Pre-requirement'></a><h3>Pre-requirement</h3>
+<li>TDengine installed, TDengine-client installed if on Windows</li>
+<li>python 2.7 or >= 3.4</li>
+<li>pip installed </li>
+<a class='anchor' id='Installation'></a><h3>Installation</h3>
+<a class='anchor' id='Linux'></a><h4>Linux</h4>
+<p>Users can find python client packages in our source code directory <em>src/connector/python</em>. There are two directories corresponding to two python versions. Please choose the correct package to install. Users can use <em>pip</em> command to install:</p>
+<pre><code class="cmd language-cmd">pip install src/connector/python/linux/python2/</code></pre>
 <p>or</p>
-<pre><code>pip install src/connector/python/python3/</code></pre>
-<p>If <em>pip</em> command is not installed on the system, users can choose to install pip or just copy the <em>taos</em> directory in the python client directory to the application directory to use.</p>
-<a class='anchor' id='Python-client-interfaces'></a><h3>Python client interfaces</h3>
-<p>To use TDengine Python client, import TDengine module at first:</p>
+<pre><code>pip install src/connector/python/linux/python3/</code></pre>
+<a class='anchor' id='Windows'></a><h4>Windows</h4>
+<p>Assumed the Windows TDengine client has been installed , copy the file "C:\TDengine\driver\taos.dll" to the folder "C:\windows\system32", and then enter the <em>cmd</em> Windows command interface</p>
+<pre><code>cd C:\TDengine\connector\python\windows</code></pre>
+<pre><code>pip install python2\</code></pre>
+<p>or</p>
+<pre><code>cd C:\TDengine\connector\python\windows</code></pre>
+<pre><code>pip install python3\</code></pre>
+<p>* If <em>pip</em> command is not installed on the system, users can choose to install pip or just copy the <em>taos</em> directory in the python client directory to the application directory to use.</p>
+<a class='anchor' id='Usage'></a><h3>Usage</h3>
+<a class='anchor' id='Examples'></a><h4>Examples</h4>
+<li>import TDengine module at first:</li>
 <pre><code class="python language-python">import taos </code></pre>
+<li>get the connection</li>
+<pre><code>
+conn = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos")
+c1 = conn.cursor()
+</code></pre>
+<p>* <em>host is the IP of TDengine server, and config is the directory where exists the TDengine client configure file</em></p>
+<li>insert records into the database</li>
+<pre><code>
+import datetime
+ 
+# create a database
+c1.execute('create database db')
+c1.execute('use db')
+# create a table
+c1.execute('create table tb (ts timestamp, temperature int, humidity float)')
+# insert a record
+start_time = datetime.datetime(2019, 11, 1)
+affected_rows = c1.execute('insert into tb values (\'%s\', 0, 0.0)' %start_time)
+# insert multiple records in a batch
+time_interval = datetime.timedelta(seconds=60)
+sqlcmd = ['insert into tb values']
+for irow in range(1,11):
+  start_time += time_interval
+  sqlcmd.append('(\'%s\', %d, %f)' %(start_time, irow, irow*1.2))
+affected_rows = c1.execute(' '.join(sqlcmd))
+</code></pre>
+<li>query the database</li>
+<code><pre>
+c1.execute('select * from tb')
+# fetch all returned results
+data = c1.fetchall()
+# data is a list of returned rows with each row being a tuple
+numOfRows = c1.rowcount
+numOfCols = c1.descriptions
+for irow in range(numOfRows):
+  print("Row%d: ts=%s, temperature=%d, humidity=%f" %(irow, data[irow][0], data[irow][1],data[irow][2])
+  
+# use the cursor as an iterator to retrieve all returned results
+c1.execute('select * from tb')
+for data in c1:
+  print("ts=%s, temperature=%d, humidity=%f" %(data[0], data[1],data[2])
+</pre></code>
+<li>close the connection</li>
+<code><pre>
+c1.close()
+conn.close()
+</pre></code>
+<a class='anchor' id='Help information''></a><h4>Help information</h4>
 <p>Users can get module information from Python help interface or refer to our [python code example](). We list the main classes and methods below:</p>
 <ul>
 <li><p><em>TaosConnection</em> class</p>

documentation/tdenginedocs-en/getting-started/index.html

@@ -28,7 +28,7 @@
 <p>In the TDengine shell, you can create databases, create tables and insert/query data with SQL. Each query command ends with a semicolon. It works like MySQL, for example:</p>
 <pre><code class="mysql language-mysql">create database db;
 use db;
-create table t (ts timestamp, cdata int);
+create table t (ts timestamp, speed int);
 insert into t values ('2019-07-15 10:00:00', 10);
 insert into t values ('2019-07-15 10:01:05', 20);
 select * from t;
@@ -85,4 +85,4 @@ Query OK, 2 row(s) in set (0.001700s)</code></pre>
 </ul>
 <p>TDengine is specially designed and optimized for time-series data processing in IoT, connected cars, Industrial IoT, IT infrastructure and application monitoring, and other scenarios. Compared with other solutions, it is 10x faster on insert/query speed. With a single-core machine, over 20K requestes can be processed, millions data points can be ingested, and over 10 million data points can be retrieved in a second. Via column-based storage and tuned compression algorithm for different data types, less than 1/10 storage space is required. </p>
 <a class='anchor' id='Explore-More-on-TDengine'></a><h2>Explore More on TDengine</h2>
-<p>Please read through the whole <a href='../documentation'>documentation</a> to learn more about TDengine.</p><a href='../index.html'>Back</a></section></main></div><?php include($s.'/footer.php'); ?><script>$('pre').addClass('prettyprint linenums');PR.prettyPrint()</script><script src='lib/docs/liner.js'></script></body></html>
\ No newline at end of file
+<p>Please read through the whole <a href='../documentation'>documentation</a> to learn more about TDengine.</p><a href='../index.html'>Back</a></section></main></div><?php include($s.'/footer.php'); ?><script>$('pre').addClass('prettyprint linenums');PR.prettyPrint()</script><script src='lib/docs/liner.js'></script></body></html>

documentation/tdenginedocs-en/super-table/index.html

@@ -73,7 +73,7 @@ INTERVAL(10M)</code></pre>
 <p>It lists the STable's schema and tags</p>
 <a class='anchor' id='Drop-a-STable'></a><h3>Drop a STable</h3>
 <pre><code class="mysql language-mysql">DROP TABLE &lt;stable_name&gt;</code></pre>
-<p>To delete a STable, all the tables created via this STable shall be deleted first, otherwise, it will fail.</p>
+<p>To delete a STable, all the tables created via this STable will be deleted.</p>
 <a class='anchor' id='List-the-Associated-Tables-of-a-STable'></a><h3>List the Associated Tables of a STable</h3>
 <pre><code class="mysql language-mysql">SELECT TBNAME,[TAG_NAME, ...] FROM &lt;stable_name&gt; WHERE &lt;tag_name&gt; &lt;[=|=&lt;|&gt;=|&lt;&gt;] values..&gt; ([AND|OR] ...)</code></pre>
 <p>It will list all the tables which satisfy the tag filter conditions. The tables are all created from this specific STable. TBNAME is a new keyword introduced, it is the table name associated with the STable. </p>

documentation/webdocs/markdowndocs/Connections with other Tools-ch.md

@@ -34,7 +34,7 @@ TDengine能够与开源数据可视化系统[Grafana](https://www.grafana.com/)
 
 ### 安装Grafana
 
-目前TDengine支持Grafana 5.2.4以上的版本。用户可以根据当前的操作系统，到Grafana官网下载安装包，并执行安装。下载地址如下：https://grafana.com/grafana/download
+目前TDengine支持Grafana 5.2.4以上的版本。用户可以根据当前的操作系统，到Grafana官网下载安装包，并执行安装。下载地址如下：https://grafana.com/grafana/download。
 
 ### 配置Grafana
 
@@ -42,43 +42,60 @@ TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafana目录
 
 以CentOS 7.2操作系统为例，将tdengine目录拷贝到/var/lib/grafana/plugins目录下，重新启动grafana即可。
 
-### 使用Grafana
+### 使用 Grafana
 
-用户可以直接通过localhost:3000的网址，登录Grafana服务器(用户名/密码:admin/admin)，配置TDengine数据源，如下图所示，此时可以在下拉列表中看到TDengine数据源。 
+#### 配置数据源
 
-![img](../assets/clip_image001.png)
+用户可以直接通过 localhost:3000 的网址，登录 Grafana 服务器(用户名/密码:admin/admin)，通过左侧 `Configuration -> Data Sources` 可以添加数据源，如下图所示：
 
-TDengine数据源中的HTTP配置里面的Host地址要设置为TDengine集群的中任意一台服务器的IP地址与TDengine RESTful接口的端口号(6020)。假设TDengine数据库与Grafana部署在同一机器，那么应输入：http://localhost:6020。
+![img](../assets/add_datasource1.jpg)
 
-此外，还需配置登录TDengine的用户名与密码，然后点击下图中的Save&Test按钮保存。  
+点击 `Add data source` 可进入新增数据源页面，在查询框中输入 TDengine 可选择添加，如下图所示：
 
-![img](../assets/clip_image001-2474914.png)
+![img](../assets/add_datasource2.jpg)
 
-  
+进入数据源配置页面，按照默认提示修改相应配置即可：
 
-然后，就可以在Grafana的数据源列表中看到刚创建好的TDengine的数据源：
+![img](../assets/add_datasource3.jpg)
 
-![img](../assets/clip_image001-2474939.png)
+* Host： TDengine 集群的中任意一台服务器的 IP 地址与 TDengine RESTful 接口的端口号(6020)，默认 http://localhost:6020。
+* User：TDengine 用户名。
+* Password：TDengine 用户密码。
 
- 
+点击 `Save & Test` 进行测试，成功会有如下提示：
 
-基于上面的步骤，就可以在创建Dashboard的时候使用TDengine数据源，如下图所示： 
+![img](../assets/add_datasource4.jpg)
 
-![img](../assets/clip_image001-2474961.png)
+#### 创建 Dashboard
 
- 
+回到主界面创建 Dashboard，点击 Add Query 进入面板查询页面：
 
-然后，可以点击Add Query按钮增加一个新查询。
+![img](../assets/create_dashboard1.jpg)
 
-在INPUT SQL输入框中输入查询SQL语句，该SQL语句的结果集应为两行多列的曲线数据，例如SELECT count(*) FROM sys.cpu WHERE ts>=from and ts<​to interval(interval)。其中，from、to和interval为TDengine插件的内置变量，表示从Grafana插件面板获取的查询范围和时间间隔。
+如上图所示，在 Query 中选中 `TDengine` 数据源，在下方查询框可输入相应 sql 进行查询，具体说明如下：
 
-ALIAS BY输入框为查询的别名，点击GENERATE SQL 按钮可以获取发送给TDengine的SQL语句。如下图所示： 
+* INPUT SQL：输入要查询的语句（该 SQL 语句的结果集应为两列多行），例如：`select avg(mem_system) from log.dn where  ts >= $from and ts < $to interval($interval)` ，其中，from、to 和 interval 为 TDengine插件的内置变量，表示从Grafana插件面板获取的查询范围和时间间隔。除了内置变量外，`也支持可以使用自定义模板变量`。
+* ALIAS BY：可设置当前查询别名。 
+* GENERATE SQL： 点击该按钮会自动替换相应变量，并生成最终执行的语句。
+    
+按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：
 
-![img](../assets/clip_image001-2474987.png)
+![img](../assets/create_dashboard2.jpg)
 
- 
+> 关于如何使用Grafana创建相应的监测界面以及更多有关使用Grafana的信息，请参考Grafana官方的[文档](https://grafana.com/docs/)。
+
+#### 导入 Dashboard
+
+在 Grafana 插件目录 /usr/local/taos/connector/grafana/tdengine/dashboard/ 下提供了一个 `tdengine-grafana.json` 可导入的 dashboard。
+
+点击左侧 `Import` 按钮，并上传 `tdengine-grafana.json` 文件：
+
+![img](../assets/import_dashboard1.jpg)
+
+导入完成之后可看到如下效果：
+
+![img](../assets/import_dashboard2.jpg)
 
-关于如何使用Grafana创建相应的监测界面以及更多有关使用Grafana的信息，请参考Grafana官方的[文档](https://grafana.com/docs/)。
 
 ## Matlab
 

documentation/webdocs/markdowndocs/Super Table-ch.md

 # 超级表STable：多表聚合
 
-TDengine要求每个数据采集点单独建表，这样能极大提高数据的插入/查询性能，但是导致系统中表的数量猛增，让应用对表的维护以及聚合、统计操作难度加大。为降低应用的开发难度，TDengine引入了超级表STable (Super Table)的概念。
+TDengine要求每个数据采集点单独建表。独立建表的模式能够避免写入过程中的同步加锁，因此能够极大地提升数据的插入/查询性能。但是独立建表意味着系统中表的数量与采集点的数量在同一个量级。如果采集点众多，将导致系统中表的数量也非常庞大，让应用对表的维护以及聚合、统计操作难度加大。为降低应用的开发难度，TDengine引入了超级表(Super Table, 简称为STable)的概念。
 
 ## 什么是超级表
 
@@ -9,14 +9,14 @@ STable是同一类型数据采集点的抽象，是同类型采集实例的集
 TDengine扩展标准SQL语法用于定义STable，使用关键词tags指定标签信息。语法如下：
 
 ```mysql
-CREATE TABLE <stable_name> (<field_name> TIMESTAMP, field_name1 field_type,…)   TAGS(tag_name tag_type, …) 
+CREATE TABLE <stable_name> (<field_name> TIMESTAMP, field_name1 field_type,…) TAGS(tag_name tag_type, …) 
 ```
 
-其中tag_name是标签名，tag_type是标签的数据类型。标签可以使用时间戳之外的其他TDengine支持的数据类型，标签的个数最多为6个，名字不能与系统关键词相同，也不能与其他列名相同。如：
+其中tag_name是标签名，tag_type是标签的数据类型。标签可以使用时间戳之外的其他TDengine支持的数据类型，标签的个数最多为32个，名字不能与系统关键词相同，也不能与其他列名相同。如：
 
 ```mysql
-create table thermometer (ts timestamp, degree float) 
-tags (location binary(20), type int)
+CREATE TABLE thermometer (ts timestamp, degree float) 
+TAGS (location binary(20), type int)
 ```
 
 上述SQL创建了一个名为thermometer的STable，带有标签location和标签type。
@@ -30,7 +30,7 @@ CREATE TABLE <tb_name> USING <stb_name> TAGS (tag_value1,...)
 沿用上面温度计的例子，使用超级表thermometer建立单个温度计数据表的语句如下：
 
 ```mysql
-create table t1 using thermometer tags ('beijing', 10)
+CREATE TABLE t1 USING thermometer TAGS ('beijing', 10)
 ```
 
 上述SQL以thermometer为模板，创建了名为t1的表，这张表的Schema就是thermometer的Schema，但标签location值为'beijing'，标签type值为10。
@@ -72,7 +72,7 @@ STable从属于库，一个STable只属于一个库，但一个库可以有一
     DROP TABLE <stable_name>
     ```
 
-    Note: 删除STable不会级联删除通过STable创建的表；相反删除STable时要求通过该STable创建的表都已经被删除。
+    Note: 删除STable时，所有通过该STable创建的表都将被删除。
 
 - 查看属于某STable并满足查询条件的表
 

documentation/webdocs/markdowndocs/Super Table.md

@@ -142,7 +142,7 @@ It lists the STable's schema and tags
 DROP TABLE <stable_name>
 ```
 
-To delete a STable, all the tables created via this STable shall be deleted first, otherwise, it will fail.
+To delete a STable, all the tables created via this STable will be deleted first.
 
 ### List the Associated Tables of a STable
 

documentation/webdocs/markdowndocs/TAOS SQL-ch.md

 # TAOS SQL
 
-TDengine提供类似SQL语法，用户可以在TDengine Shell中使用SQL语句操纵数据库，也可以通过C/C++, Java(JDBC), Python, Go等各种程序来执行SQL语句。 
+本文档说明TAOS SQL支持的语法规则、主要查询功能、支持的SQL查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的SQL语言的基础。
+
+TAOS SQL是用户对TDengine进行数据写入和查询的主要工具。TAOS SQL为了便于用户快速上手，在一定程度上提供类似于标准SQL类似的风格和模式。严格意义上，TAOS SQL并不是也不试图提供SQL标准的语法。此外，由于TDengine针对的时序性结构化数据不提供修改和更新功能，因此在TAO SQL中不提供数据更新和数据删除的相关功能。
 
 本章节SQL语法遵循如下约定：
 
@@ -9,15 +11,46 @@ TDengine提供类似SQL语法，用户可以在TDengine Shell中使用SQL语句
 - | 表示多选一，选择其中一个即可，但不能输入|本身
 - … 表示前面的项可重复多个
 
+为更好地说明SQL语法的规则及其特点，本文假设存在一个数据集。该数据集是针对两种类型的设备温度（湿度）传感器、气压（海拔）传感器建立的数据模型。
+针对温度传感器，具有超级表（super table） temp_stable。其数据模型如下：
+```
+taos> describe temp_stable;
+Field       | Type     | Length | Note |
+=======================================================================================================
+ts          |TIMESTAMP | 8      |      |
+temperature |FLOAT     | 4      |      |
+humidity    |TINYINT   | 1      |      |
+status      |TINYINT   | 1      |      |
+deviceid    |BIGINT    | 12     |tag   |
+location    |BINARY    | 20     |tag   |
+```
+数据集包含2个温度传感器的数据，按照TDengine的建模规则，对应2个子表，其名称分别是 temp_tb_1，temp_tb_2 。
+针对压力（海拔）传感器，具有超级表（super table） pressure_stable。其数据模型如下：
+数据集包含2个压力传感器数据，对应2个子表，分别是 press_tb_1，press_tb_2。
+
+```text
+taos> describe pressure_stable;
+Field      | Type     | Length | Note |
+=======================================================================================================
+ts         |TIMESTAMP | 8      |      |
+height     |FLOAT     | 4      |      |
+pressure   |FLOAT     | 4      |      |
+devstat    |TINYINT   | 1      |      |
+id         |BIGINT    | 8      |tag   |
+city       |NCHAR     | 20     |tag   |
+longitude  |FLOAT     | 4      |tag   |
+latitude   |FLOAT     | 4      |tag   |
+```
 ## 支持的数据类型
 
 使用TDengine，最重要的是时间戳。创建并插入记录、查询历史记录的时候，均需要指定时间戳。时间戳有如下规则：
 
-- 时间格式为YYYY-MM-DD HH:mm:ss.MS, 默认时间分辨率为毫秒。比如：2017-08-12 18:25:58.128
+- 时间格式为```YYYY-MM-DD HH:mm:ss.MS```, 默认时间分辨率为毫秒。比如：```2017-08-12 18:25:58.128```
 - 内部函数now是服务器的当前时间
 - 插入记录时，如果时间戳为0，插入数据时使用服务器当前时间
 - Epoch Time: 时间戳也可以是一个长整数，表示从1970-01-01 08:00:00.000开始的毫秒数
 - 时间可以加减，比如 now-2h，表明查询时刻向前推2个小时(最近2小时)。数字后面的时间单位：a(毫秒), s(秒), m(分), h(小时), d(天)，w(周), n(月), y(年)。比如select * from t1 where ts > now-2w and ts <= now-1w, 表示查询两周前整整一周的数据
+- TDengine暂不支持时间窗口按照自然年和自然月切分。Where条件中的时间窗口单位的换算关系如下：interval(1y) 等效于 interval(365d), interval(1n) 等效于 interval(30d), interval(1w) 等效于 interval(7d)
 
 TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMicrosecond就可支持微秒。
 
@@ -26,13 +59,13 @@ 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^59,   2^59]                                 |
+| 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   | 自定义 | 用于记录字符串，最长不能超过504 bytes。binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节，将被自动截断。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 |
-| 7    | SMALLINT  | 2      | 短整型， 范围 [-32767, 32767]                                |
-| 8    |  TINYINT  | 1      | 单字节整型，范围 [-127, 127]                                 |
+| 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的空间。如用户字符串长度超出声明长度，则将被自动截断。 |
 
@@ -158,25 +191,179 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```
     同时向表tb1_name和tb2_name中按列分别插入多条记录 
 
-注意：对同一张表，插入的新记录的时间戳必须递增，否则会跳过插入该条记录。如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳。
+注意：1、对同一张表，插入的新记录的时间戳必须递增，否则会跳过插入该条记录。如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳。
+      2、允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
 
-**IMPORT**：如果需要将时间戳小于最后一条记录时间的记录写入到数据库中，可使用IMPORT替代INSERT命令，IMPORT的语法与INSERT完全一样。如果同时IMPORT多条记录，需要保证一批记录是按时间戳排序好的。
+**IMPORT**：如果需要将时间戳小于最后一条记录时间的记录写入到数据库中，可使用IMPORT替代INSERT命令，IMPORT的语法与INSERT完全一样。
 
 ## 数据查询
 
-###查询语法是：
+### 查询语法：
 
 ```mysql
-SELECT {* | expr_list} FROM tb_name
-    [WHERE where_condition]
-    [ORDER BY _c0 { DESC | ASC }]
-    [LIMIT limit [, OFFSET offset]]
-    [>> export_file]
-    
-SELECT function_list FROM tb_name
-    [WHERE where_condition]
-    [LIMIT limit [, OFFSET offset]]
-    [>> export_file]
+SELECT [DISTINCT] select_expr [, select_expr ...]
+FROM {tb_name_list}
+[WHERE where_condition]
+[INTERVAL [interval_offset,] interval_val]
+[FILL fill_val]
+[SLIDING fill_val]
+[GROUP BY col_list]
+[ORDER BY col_list { DESC | ASC }]
+[HAVING expr_list]
+[SLIMIT limit_val [, SOFFSET offset_val]]
+[LIMIT limit_val [, OFFSET offset_val]]
+[>> export_file]
+```
+#### SELECT子句
+一个选择子句可以是联合查询（UNION）和另一个查询的子查询（SUBQUERY）。
+
+##### 通配符
+通配符 * 可以用于代指全部列。对于普通表，结果中只有普通列。
+```
+taos> select * from temp_tb_1;
+ts                   | temperature |humidity|status|
+============================================================
+19-04-28 14:22:07.000| 20.00000    | 34     | 1    |
+19-04-28 14:22:08.000| 21.50000    | 38     | 1    |
+19-04-28 14:22:09.000| 21.30000    | 38     | 1    |
+19-04-28 14:22:10.000| 21.20000    | 38     | 1    |
+19-04-28 14:22:11.000| 21.30000    | 35     | 0    |
+19-04-28 14:22:12.000| 22.00000    | 34     | 0    |
+```
+在针对超级表，通配符包含 _标签列_ 。
+```
+taos> select * from temp_stable;
+ts                   | temperature |humidity|status| deviceid | location |
+==============================================================================================
+19-04-28 14:22:07.000| 21.00000    | 37     | 1    |54197     |beijing   |
+19-04-28 14:22:07.000| 20.00000    | 34     | 1    |91234     |beijing   |
+19-04-28 14:22:08.000| 21.50000    | 38     | 1    |91234     |beijing   |
+19-04-28 14:22:09.000| 21.30000    | 38     | 1    |91234     |beijing   |
+19-04-28 14:22:10.000| 21.20000    | 38     | 1    |91234     |beijing   |
+19-04-28 14:22:11.000| 21.30000    | 35     | 0    |91234     |beijing   |
+19-04-28 14:22:12.000| 22.00000    | 34     | 0    |91234     |beijing   |
+```
+通配符支持表名前缀，以下两个SQL语句均为返回全部的列：
+```
+select * from temp_tb_1;
+select temp_tb_1.* from temp_tb_1;
+```
+在Join查询中，带前缀的\*和不带前缀\*返回的结果有差别， \*返回全部表的所有列数据（不包含标签），带前缀的通配符，则只返回该表的列数据。
+```
+taos> select * from temp_tb_1,temp_tb_2 where temp_tb_1.ts=temp_tb_2.ts;
+ts                   | temperature |humidity|status| ts                   | temperature |humidity|status|
+========================================================================================================================
+19-04-28 14:22:07.000| 20.00000    | 34     | 1    | 19-04-28 14:22:07.000| 21.00000    | 37     | 1    |
+```
+
+```
+taos> select temp_tb_1.* from temp_tb_1,temp_tb_2 where temp_tb_1.ts=temp_tb_2.ts;
+ts                   | temperature |humidity|status|
+============================================================
+19-04-28 14:22:07.000| 20.00000    | 34     | 1    |
+```
+
+在使用SQL函数来进行查询过程中，部分SQL函数支持通配符操作。其中的区别在于：
+```count(\*)```函数只返回一列。```first```、```last```、```last_row```函数则是返回全部列。
+
+```
+taos> select count(*) from temp_tb_1;
+count(*)  |
+======================
+1         |
+```
+
+```
+taos> select first(*) from temp_tb_1;
+first(ts)            | first(temperature) |first(humidity)|first(status)|
+==========================================================================
+19-04-28 14:22:07.000| 20.00000           | 34            | 1           |
+```
+
+#### 结果集列名
+
+```SELECT```子句中，如果不指定返回结果集合的列名，结果集列名称默认使用```SELECT```子句中的表达式名称作为列名称。此外，用户可使用```AS```来重命名返回结果集合中列的名称。例如：
+```
+taos> select ts, ts as primary_key_ts from temp_tb_1;
+ts                   | primary_key_ts       |
+==============================================
+19-04-28 14:22:07.000| 19-04-28 14:22:07.000|
+```
+但是针对```first(*)```、```last(*)```、```last_row(*)```不支持针对单列的重命名。
+
+#### DISTINCT修饰符*
+只能用于修饰标签列（TAGS）的结果，不能用于修饰普通列来获得去重后的结果。并且应用```DISTINCT```以后，只能进行单列的标签输出。
+```count(distinct column_name)```用以返回近似的不重复结果的数量，该结果是近似值。
+
+#### 隐式结果列
+```Select_exprs```可以是表所属列的列名，也可以是基于列的函数表达式或计算式，数量的上限256个。当用户使用了```interval```或```group by tags```的子句以后，在最后返回结果中会强制返回时间戳列（第一列）和group by子句中的标签列。后续的版本中可以支持关闭group by子句中隐式列的输出，列输出完全由select子句控制。
+
+#### 表（超级表）列表
+
+FROM关键字后面可以是若干个表（超级表）列表，也可以是子查询的结果。
+如果没有指定用户的当前数据库，可以在表名称之前使用数据库的名称来指定表所属的数据库。例如：```sample.temp_tb_1``` 方式来跨库使用表。
+```
+SELECT * FROM sample.temp_tb_1;
+------------------------------
+use sample;
+SELECT * FROM temp_tb_1;
+```
+From子句中列表可以使用别名来让SQL整体更加简单。
+```
+SELECT t.ts FROM temp_tb_1 t ;
+```
+> 暂不支持FROM子句的表别名
+
+#### 特殊功能
+部分特殊的查询功能可以不使用FROM子句执行。获取当前所在的数据库 database() 
+```
+taos> SELECT database();
+database() |
+=================================
+sample     |
+```
+如果登录的时候没有指定默认数据库，且没有使用```use``命令切换数据，则返回NULL。
+```
+taos> select database();
+database() |
+=================================
+NULL       |
+```
+获取服务器和客户端版本号:
+```
+SELECT client_version()
+SELECT server_version()
+```
+服务器状态检测语句。如果服务器正常，返回一个数字（例如 1）。如果服务器异常，返回error code。该SQL语法能兼容连接池对于TDengine状态的检查及第三方工具对于数据库服务器状态的检查。并可以避免出现使用了错误的心跳检测SQL语句导致的连接池连接丢失的问题。
+```
+SELECT server_status()
+SELECT server_status() AS result
+```
+#### TAOS SQL中特殊关键词
+
+ >   TBNAME： 在超级表查询中可视为一个特殊的标签，代表查询涉及的子表名<br>
+    \_c0: 表示表（超级表）的第一列
+
+#### 小技巧
+获取一个超级表所有的子表名及相关的标签信息：
+```
+SELECT TBNAME, location FROM temp_stable
+```
+统计超级表下辖子表数量：
+```
+SELECT COUNT(TBNAME) FROM temp_stable
+```
+以上两个查询均只支持在Where条件子句中添加针对标签（TAGS）的过滤条件。例如：
+```
+taos> select count(tbname) from temp_stable;
+count(tbname) |
+======================
+2             |
+
+taos> select count(tbname) from temp_stable where deviceid > 60000;
+count(tbname) |
+======================
+1             |
 ```
 
 - 可以使用* 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名
@@ -237,7 +424,7 @@ SELECT function_list FROM tb_name
 
 ###聚合函数
 
-TDengine支持针对数据的聚合查询。提供支持的聚合和提取函数如下表：
+TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数如下：
 
 - **COUNT**
     ```mysql
@@ -260,13 +447,14 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和提取函数
     适用于：表、超级表。  
 
 
-- **WAVG**
+- **TWA**
     ```mysql
-    SELECT WAVG(field_name) FROM tb_name WHERE clause
+    SELECT TWA(field_name) FROM tb_name WHERE clause
     ```
-    功能说明：统计表/超级表中某列在一段时间内的时间加权平均。  
+    功能说明：时间加权平均函数。统计表/超级表中某列在一段时间内的时间加权平均。  
     返回结果数据类型：双精度浮点数Double。  
-    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。  
+    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+    说明：时间加权平均(time weighted average, TWA）查询需要指定查询时间段的 _开始时间_ 和 _结束时间_ 。
     适用于：表、超级表。
 
 
@@ -370,7 +558,15 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和提取函数
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。  
     说明：*k*值取值范围0≤*k*≤100，为0的时候等同于MIN，为100的时候等同于MAX。
 
-
+- **APERCENTILE**
+    ```mysql
+    SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause]
+    ```
+    功能说明：统计表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。  
+    返回结果数据类型： 双精度浮点数Double。  
+    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。  
+    说明：*k*值取值范围0≤*k*≤100，为0的时候等同于MIN，为100的时候等同于MAX。推荐使用```APERCENTILE```函数，该函数性能远胜于```PERCENTILE```函数
+    
 - **LAST_ROW**
     ```mysql
     SELECT LAST_ROW(field_name) FROM { tb_name | stb_name }

documentation/webdocs/markdowndocs/TAOS SQL.md

@@ -181,9 +181,10 @@ All the keywords in a SQL statement are case-insensitive, but strings values are
                 tb2_name (tb2_field1_name, ...) VALUES(field1_value1, ...) (field1_value2, ...)
     ```
 
-Note: For a table, the new record must have a timestamp bigger than the last data record, otherwise, it will be discarded and not inserted. If the timestamp is 0, the time stamp will be set to the system time on the server.
-
-**IMPORT**: If you do want to insert a historical data record into a table, use IMPORT command instead of INSERT. IMPORT has the same syntax as INSERT. If you want to import a batch of historical records, the records must be ordered by the timestamp, otherwise, TDengine won't handle it in the right way.
+Note: 1. For a table, the new record must have a timestamp bigger than the last data record, otherwise, it will be discarded and not inserted. If the timestamp is 0, the time stamp will be set to the system time on the server.
+      2.The timestamp of the oldest record allowed to be inserted is relative to the current server time, minus the configured keep value (the number of days the data is retained), and the timestamp of the latest record allowed to be inserted is relative to the current server time, plus the configured days value (the time span in which the data file stores data, in days). Both keep and days can be specified when creating the database. The default values are 3650 days and 10 days, respectively.
+ 
+**IMPORT**: If you do want to insert a historical data record into a table, use IMPORT command instead of INSERT. IMPORT has the same syntax as INSERT. 
 
 ## Data Query
 

documentation/webdocs/markdowndocs/administrator-ch.md

@@ -2,15 +2,15 @@
 
 ## 文件目录结构
 
-安装TDengine后，默认会在操作系统中生成下列目录或文件：
+安装TDengine的过程中，安装程序将在操作系统中创建以下目录或文件：
 
 | 目录/文件               | 说明                                              |
 | ---------------------- | :------------------------------------------------|
-| /etc/taos/taos.cfg     | TDengine默认[配置文件]                            |
-| /usr/local/taos/driver | TDengine动态链接库目录                            |
-| /var/lib/taos          | TDengine默认数据文件目录,可通过[配置文件]修改位置.    |
-| /var/log/taos          | TDengine默认日志文件目录,可通过[配置文件]修改位置     |
-| /usr/local/taos/bin    | TDengine可执行文件目录                            |
+| /etc/taos/taos.cfg     | 默认[配置文件]                            |
+| /usr/local/taos/driver | 动态链接库目录                            |
+| /var/lib/taos          | 默认数据文件目录,可通过[配置文件]修改位置.    |
+| /var/log/taos          | 默认日志文件目录,可通过[配置文件]修改位置     |
+| /usr/local/taos/bin    | 可执行文件目录                            |
 
 ### 可执行文件
 
@@ -19,33 +19,126 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 - _taosd_：TDengine服务端可执行文件
 - _taos_： TDengine Shell可执行文件
 - _taosdump_：数据导出工具
-- *rmtaos*： 一个卸载TDengine的脚本, 请谨慎执行
+- *rmtaos*： 卸载TDengine的脚本, 该脚本会删除全部的程序和数据文件。请务必谨慎执行，如非必须不建议使用。
 
 您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录
 
 ## 服务端配置
 
-TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修改配置参数，以满足不同场景的需求。配置文件的缺省位置在/etc/taos目录，可以通过taosd命令行执行参数-c指定配置文件目录。比如taosd -c /home/user来指定配置文件位于/home/user这个目录。
+TDengine系统后台服务程序是`taosd`，其启动时候读取的配置文件缺省目录是`/etc/taos`。可以通过命令行执行参数-c指定配置文件目录，比如
+```
+taosd -c /home/user
+```
+指定`taosd`启动的时候读取`/home/user`目录下的配置文件taos.cfg。
 
 下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节。**注意：配置修改后，需要重启*taosd*服务才能生效。**
 
-- internalIp: 对外提供服务的IP地址，默认取第一个IP地址
-- mgmtShellPort：管理节点与客户端通信使用的TCP/UDP端口号（默认值是6030）。此端口号在内向后连续的5个端口都会被UDP通信占用，即UDP占用[6030-6034]，同时TCP通信也会使用端口[6030]。
-- vnodeShellPort：数据节点与客户端通信使用的TCP/UDP端口号（默认值是6035）。此端口号在内向后连续的5个端口都会被UDP通信占用，即UDP占用[6035-6039]，同时TCP通信也会使用端口[6035]
-- httpPort：数据节点对外提供RESTful服务使用TCP，端口号[6020]
-- dataDir: 数据文件目录，缺省是/var/lib/taos
-- maxUsers：用户的最大数量
-- maxDbs：数据库的最大数量
-- maxTables：数据表的最大数量
-- enableMonitor: 系统监测标志位，0：关闭，1：打开
-- logDir: 日志文件目录，缺省是/var/log/taos
-- numOfLogLines：日志文件的最大行数
-- debugFlag: 系统debug日志开关，131：仅错误和报警信息，135：所有
+**privateIp**
+- 默认值：物理节点IP地址列表中的第一个IP地址
+
+对外提供服务的IP地址。
+
+**publicIp**
+- 默认值：与privateIp相同
+
+对于阿里等云平台，此为公网IP地址，publicIp在内部映射为对应的privateIP地址，仅对企业版有效。
+
+**masterIp**
+- 默认值：与privateIp相同
+
+集群内第一个物理节点的privateIp地址，仅对企业版有效。
+
+**secondIp**
+- 默认值：与privateIp相同
+
+集群内第二个物理节点的privateIp地址，仅对企业版有效。
+
+**mgmtShellPort**
+- 默认值： _6030_
+
+数据库服务中管理节点与客户端通信使用的TCP/UDP端口号。
+> 端口范围 _6030_ - _6034_ 均用于UDP通讯。此外，还使用端口 _6030_ 用于TCP通讯。
+
+**vnodeShellPort**
+- 默认值： _6035_
+
+数据节点与客户端通信使用的TCP/UDP端口号。
+> 端口范围 _6035_ - _6039_ 的5个端口用于UDP通信。此外，还使用端口 _6035_ 用于TCP通讯。
+
+**mgmtVnodePort**
+- 默认值： _6040_
+
+管理节点与数据节点通信使用的TCP/UDP端口号，仅对企业版有效。
+> 端口范围 _6040_ - _6044_ 的5个端口用于UDP通信。此外，还使用端口 _6040_ 用于TCP通讯。
+
+**vnodeVnodePort**
+- 默认值： _6045_
+
+数据节点与数据节点通信使用的TCP/UDP端口号，仅对企业版有效。
+> 端口范围 _6045_ - _6049_ 的5个端口用于UDP通信。此外，还使用端口 _6045_ 用于TCP通讯。
+
+**mgmtMgmtPort**
+- 默认值： _6050_
+
+管理节点与管理节点通信使用的UDP端口号，仅对企业版有效。
+
+**mgmtSyncPort**
+- 默认值： _6050_
+
+管理节点与管理节点同步使用的TCP端口号，仅对企业版有效。
+
+**httpPort**
+- 默认值： _6020_
+
+RESTful服务使用的端口号，所有的HTTP请求（TCP）都需要向该接口发起查询/写入请求。
+
+**dataDir**
+- 默认值：/var/lib/taos
+
+数据文件目录，所有的数据文件都将写入该目录。
+
+**logDir**
+- 默认值：/var/log/taos
+
+日志文件目录，客户端和服务器的运行日志将写入该目录。
+
+**maxUsers**
+- 默认值：10,000
+
+系统允许创建用户数量的上限
+
+**maxDbs**
+- 默认值：1,000
+
+系统允许的创建数据库的上限
+
+**maxTables**
+- 默认值：650,000
+
+系统允许创建数据表的上限。
+>系统能够创建的表受到多种因素的限制，单纯地增大该参数并不能直接增加系统能够创建的表数量。例如，由于每个表创建均需要消耗一定量的缓存空间，系统可用内存一定的情况下，创建表的总数的上限是一个固定的值。
+
+**monitor**
+- 默认值：1（激活状态）
+
+服务器内部的系统监控开关。监控主要负责收集物理节点的负载状况，包括CPU、内存、硬盘、网络带宽、HTTP请求量的监控记录，记录信息存储在`LOG`库中。0表示关闭监控服务，1表示激活监控服务。
+
+**numOfLogLines**
+- 默认值：10,000,000
+
+单个日志文件允许的最大行数（10,000,000行）。
+
+**debugFlag**
+- 默认值：131（仅输出错误和警告信息）
+
+系统（服务端和客户端）运行日志开关：
+- 131 仅输出错误和警告信息
+- 135 输入错误（ERROR）、警告（WARN）、信息（Info）
 
 不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine提供如下存储相关的系统配置参数：
 
-- days：一个数据文件覆盖的时间长度，单位为天
-- keep：数据库中数据保留的天数
+- days：数据文件存储数据的时间跨度，单位为天
+- keep：数据保留的天数
 - rows: 文件块中记录条数
 - comp: 文件压缩标志位，0：关闭，1:一阶段压缩，2:两阶段压缩
 - ctime：数据从写入内存到写入硬盘的最长时间间隔，单位为秒
@@ -66,19 +159,139 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 
 ## 客户端配置 
 
-TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。更多taos的使用方法请见[Shell命令行程序](#_TDengine_Shell命令行程序)。本节主要讲解taos客户端应用在配置文件taos.cfg文件中使用到的参数。
+TDengine系统的前台交互客户端应用程序为taos（Windows平台上为taos.exe）。与服务端程序一样，也可以通过设置taos.cfg来配置`taos`启动和运行的配置项。启动的时候如果不指定taos加载配置文件路径，默认读取`/etc/taos/`路径下的`taos.cfg`文件。指定配置文件来启动`taos`的命令如下：
+
+```
+taos -c /home/cfg/
+```
+**注意：启动设置的是配置文件所在目录，而不是配置文件本身**
+
+如果`/home/cfg/`目录下没有配置文件，程序会继续启动并打印如下告警信息：
+```plaintext
+Welcome to the TDengine shell from linux, client version:1.6.4.0
+option file:/home/cfg/taos.cfg not found, all options are set to system default
+```
+更多taos的使用方法请见[Shell命令行程序](#_TDengine_Shell命令行程序)。本节主要讲解taos客户端应用在配置文件taos.cfg文件中使用到的参数。
+
+客户端配置参数说明
+
+**masterIP**
+- 默认值：127.0.0.1
+
+客户端连接的TDengine服务器IP地址，如果不设置默认连接127.0.0.1的节点。以下两个命令等效：
+```
+taos
+taos -h 127.0.0.1
+```
+其中的IP地址是从配置文件中读取的masterIP的值。
+
+**locale**
+- 默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
+
+TDengine为存储中文、日文、韩文等非ASCII编码的宽字符，提供一种专门的字段类型`nchar`。写入`nchar`字段的数据将统一采用`UCS4-LE`格式进行编码并发送到服务器。需要注意的是，**编码正确性**是客户端来保证。因此，如果用户想要正常使用`nchar`字段来存储诸如中文、日文、韩文等非ASCII字符，需要正确设置客户端的编码格式。
+
+客户端的输入的字符均采用操作系统当前默认的编码格式，在Linux系统上多为`UTF-8`，部分中文系统编码则可能是`GB18030`或`GBK`等。在docker环境中默认的编码是`POSIX`。在中文版Windows系统中，编码则是`CP936`。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证`nchar`中的数据正确转换为`UCS4-LE`编码格式。
+
+在 Linux 中 locale 的命名规则为：
+`<语言>_<地区>.<字符集编码>`
+如：`zh_CN.UTF-8`，zh代表中文，CN代表大陆地区，UTF-8表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux系统与Mac OSX系统可以通过设置locale来确定系统的字符编码，由于Windows使用的locale中不是POSIX标准的locale格式，因此在Windows下需要采用另一个配置参数`charset`来指定字符编码。在Linux系统中也可以使用charset来指定字符编码。
+
+**charset**
+- 默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
+
+如果配置文件中不设置`charset`，在Linux系统中，taos在启动时候，自动读取系统当前的locale信息，并从locale信息中解析提取charset编码格式。如果自动读取locale信息失败，则尝试读取charset配置，如果读取charset配置也失败，**则中断启动过程**。
+
+在Linux系统中，locale信息包含了字符编码信息，因此正确设置了Linux系统locale以后可以不用再单独设置charset。例如：
+```
+locale zh_CN.UTF-8
+```
+在Windows系统中，无法从locale获取系统当前编码。如果无法从配置文件中读取字符串编码信息，`taos`默认设置为字符编码为`CP936`。其等效在配置文件中添加如下配置：
+```
+charset CP936
+```
+如果需要调整字符编码，请查阅当前操作系统使用的编码，并在配置文件中正确设置。
+
+在Linux系统中，如果用户同时设置了locale和字符集编码charset，并且locale和charset的不一致，后设置的值将覆盖前面设置的值。
+```
+locale zh_CN.UTF-8
+charset GBK
+```
+则`charset`的有效值是`GBK`。
+```
+charset GBK
+locale zh_CN.UTF-8
+```
+`charset`的有效值是`UTF-8`。
 
-客户端配置参数列表及解释
+**sockettype**
+- 默认值：UDP
 
-- masterIP：客户端默认发起请求的服务器的IP地址
-- charset：指明客户端所使用的字符集，默认值为UTF-8。TDengine存储nchar类型数据时使用的是unicode存储，因此客户端需要告知服务自己所使用的字符集，也即客户端所在系统的字符集。
-- locale：设置系统语言环境。Linux上客户端与服务端共享
-- defaultUser：默认登录用户，默认值root
-- defaultPass：默认登录密码，默认值taosdata
+客户端连接服务端的套接字的方式，可以使用`UDP`和`TCP`两种配置。
+在客户端和服务端之间的通讯需要经过恶劣的网络环境下（如公共网络、互联网）、客户端与数据库服务端连接不稳定（由于MTU的问题导致UDP丢包）的情况下，可以将连接的套接字类型调整为`TCP`
 
-TCP/UDP端口，以及日志的配置参数，与server的配置参数完全一样。
+>注意：客户端套接字的类型需要和服务端的套接字类型相同，否则无法连接数据库。
 
-启动taos时，你也可以从命令行指定IP地址、端口号，用户名和密码，否则就从taos.cfg读取。
+**compressMsgSize**
+- 默认值：-1（不压缩）
+
+客户端与服务器之间进行消息通讯过程中，对通讯的消息进行压缩的阈值，默认值为-1（不压缩）。如果要压缩消息，建议设置为64330字节，即大于64330字节的消息体才进行压缩。在配置文件中增加如下配置项即可：
+```
+compressMsgSize 64330
+```
+如果配置项设置为0，`compressMsgSize 0`表示对所有的消息均进行压缩。
+
+**timezone**
+- 默认值：从系统中动态获取当前的时区设置
+
+客户端运行系统所在的时区。为应对多时区的数据写入和查询问题，TDengine采用Unix时间戳([Unix Timestamp](https://en.wikipedia.org/wiki/Unix_time))来记录和存储时间戳。Unix时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的Unix时间戳，需要设置正确的时区。
+
+在Linux系统中，客户端会自动读取系统设置的时区信息。用户也可以采用多种方式在配置文件设置时区。例如：
+```
+timezone UTC-8
+timezone GMT-8
+timezone Asia/Shanghai
+```
+均是合法的设置东八区时区的格式。
+
+
+时区的设置对于查询和写入SQL语句中非Unix时间戳的内容（时间戳字符串、关键词`now`的解析）产生影响。例如：
+```
+SELECT count(*) FROM table_name WHERE TS<'2019-04-11 12:01:08';
+```
+在东八区，SQL语句等效于
+```
+SELECT count(*) FROM table_name WHERE TS<1554955268000;
+```
+在UTC时区，SQL语句等效于
+```
+SELECT count(*) FROM table_name WHERE TS<1554984068000;
+```
+为了避免使用字符串时间格式带来的不确定性，也可以直接使用Unix时间戳。此外，还可以在SQL语句中使用带有时区的时间戳字符串，例如：RFC3339格式的时间戳字符串，`2013-04-12T15:52:01.123+08:00`或者ISO-8601格式时间戳字符串`2013-04-12T15:52:01.123+0800`。上述两个字符串转化为Unix时间戳不受系统所在时区的影响。
+
+**defaultUser**
+- 默认值：root
+
+登录用户名，客户端登录的时候，如果不指定用户名，则自动使用该用户名登录。默认情况下，以下的两个命令等效
+```
+taos
+taos -u root
+```
+用户名为从配置中读取的`defaultUser`配置项。如果更改`defaultUser abc`，则以下两个命令等效：
+```
+taos
+taos -u abc
+```
+
+**defaultPass**
+- 默认值：taosdata
+
+登录用户名，客户端登录的时候，如果不指定密码，则自动使用该密码登录。默认情况下，以下的两个命令等效
+```
+taos
+taos -ptaosdata
+```
+
+TCP/UDP端口，以及日志的配置参数，与server的配置参数完全一样。使用命令`taos -?` 可查看`taos`允许的可选项。
 
 ## 用户管理
 
@@ -124,6 +337,8 @@ TDengine也支持在shell对已存在的表从CSV文件中进行数据导入。
 insert into tb1 file a.csv b.csv tb2 c.csv …
 import into tb1 file a.csv b.csv tb2 c.csv …
 ```
+> 注意：导入的CSV文件不能够带表头, 且表的列与CSV文件的列需要严格对应。
+> 同样还可以使用[样例数据导入工具][1]对数据进行横向和纵向扩展导入。
 
 ## 数据导出
 
@@ -191,6 +406,9 @@ KILL STREAM <stream-id>
 
 ## 系统监控
 
-TDengine启动后，会自动创建一个监测数据库SYS，并自动将服务器的CPU、内存、硬盘空间、带宽、请求数、磁盘读写速度、慢查询等信息定时写入该数据库。TDengine还将重要的系统操作（比如登录、创建、删除数据库等）日志以及各种错误报警信息记录下来存放在SYS库里。系统管理员可以从CLI直接查看这个数据库，也可以在WEB通过图形化界面查看这些监测信息。
+TDengine启动后，会自动创建一个监测数据库`LOG`，并自动将服务器的CPU、内存、硬盘空间、带宽、请求数、磁盘读写速度、慢查询等信息定时写入该数据库。TDengine还将重要的系统操作（比如登录、创建、删除数据库等）日志以及各种错误报警信息记录下来存放在`LOG`库里。系统管理员可以通过客户端程序查看记录库中的运行负载信息，（在企业版中）还可以通过浏览器查看数据的图标可视化结果。
+
+这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项`monitor`将其关闭或打开。
+
 
-这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项enableMonitor将其关闭或打开。
\ No newline at end of file
+[1]: https://github.com/taosdata/TDengine/tree/develop/importSampleData
\ No newline at end of file

documentation/webdocs/markdowndocs/advanced features-ch.md

@@ -63,28 +63,11 @@ CREATE TABLE QUERY_RES
 ## 数据订阅(Publisher/Subscriber)
 基于数据天然的时间序列特性，TDengine的数据写入（insert）与消息系统的数据发布（pub）逻辑上一致，均可视为系统中插入一条带时间戳的新记录。同时，TDengine在内部严格按照数据时间序列单调递增的方式保存数据。本质上来说，TDengine中里每一张表均可视为一个标准的消息队列。
 
-TDengine内嵌支持轻量级的消息订阅与推送服务。使用系统提供的API，用户可订阅数据库中的某一张表（或超级表）。订阅的逻辑和操作状态的维护均是由客户端完成，客户端定时轮询服务器是否有新的记录到达，有新的记录到达就会将结果反馈到客户。
+TDengine内嵌支持轻量级的消息订阅与推送服务。使用系统提供的API，用户可使用普通查询语句订阅数据库中的一张或多张表。订阅的逻辑和操作状态的维护均是由客户端完成，客户端定时轮询服务器是否有新的记录到达，有新的记录到达就会将结果反馈到客户。
 
 TDengine的订阅与推送服务的状态是客户端维持，TDengine服务器并不维持。因此如果应用重启，从哪个时间点开始获取最新数据，由应用决定。
 
-#### API说明
-
-使用订阅的功能，主要API如下：
-
-<ul>
-<li><p><code>TAOS_SUB *taos_subscribe(char *host, char *user, char *pass, char *db, char *table, int64_t time, int mseconds)</code></p><p>该函数负责启动订阅服务。其中参数说明：</p></li><ul>
-<li><p>host：主机IP地址</p></li>
-<li><p>user：数据库登录用户名</p></li>
-<li><p>pass：密码</p></li>
-<li><p>db：数据库名称</p></li>
-<li><p>table：(超级) 表的名称</p></li>
-<li><p>time：启动时间，Unix Epoch时间，单位为毫秒。从1970年1月1日起计算的毫秒数。如果设为0，表示从当前时间开始订阅</p></li>
-<li><p>mseconds：查询数据库更新的时间间隔，单位为毫秒。一般设置为1000毫秒。返回值为指向TDengine_SUB 结构的指针，如果返回为空，表示失败。</p></li>
-</ul><li><p><code>TAOS_ROW taos_consume(TAOS_SUB *tsub)</code>
-</p><p>该函数用来获取订阅的结果，用户应用程序将其置于一个无限循环语句。如果数据库有新记录到达，该API将返回该最新的记录。如果没有新的记录，该API将阻塞。如果返回值为空，说明系统出错。参数说明：</p></li><ul><li><p>tsub：taos_subscribe的结构体指针。</p></li></ul><li><p><code>void taos_unsubscribe(TAOS_SUB *tsub)</code></p><p>取消订阅。应用程序退出时，务必调用该函数以避免资源泄露。</p></li>
-<li><p><code>int taos_num_subfields(TAOS_SUB *tsub)</code></p><p>获取返回的一行记录中数据包含多少列。</p></li>
-<li><p><code>TAOS_FIELD *taos_fetch_subfields(TAOS_SUB *tsub)</code></p><p>获取每列数据的属性（数据类型、名字、长度），与taos_num_subfileds配合使用，可解析返回的每行数据。</p></li></ul>
-示例代码：请看安装包中的的示范程序
+订阅相关API文档请见 [C/C++ 数据订阅接口](https://www.taosdata.com/cn/documentation/connector/#C/C++-%E6%95%B0%E6%8D%AE%E8%AE%A2%E9%98%85%E6%8E%A5%E5%8F%A3)，《[TDEngine中订阅的用途和用法](https://www.taosdata.com/blog/2020/02/12/1277.html)》则以一个示例详细介绍了这些ＡＰＩ的用法。
 
 ## 缓存 (Cache)
 TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Use，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。
@@ -93,7 +76,7 @@ TDengine通过查询函数向用户提供毫秒级的数据获取能力。直接
 
 TDengine分配固定大小的内存空间作为缓存空间，缓存空间可根据应用的需求和硬件资源配置。通过适当的设置缓存空间，TDengine可以提供极高性能的写入和查询的支持。TDengine中每个虚拟节点（virtual node）创建时分配独立的缓存池。每个虚拟节点管理自己的缓存池，不同虚拟节点间不共享缓存池。每个虚拟节点内部所属的全部表共享该虚拟节点的缓存池。
 
-TDengine将内存池按块划分进行管理，数据在内存块里按照列式存储。一个vnode的内存池是在vnode创建时按块分配好的，而且每个内存块按照先进先出的原则进行管理。一张表所需要的内存块是从vnode的内存池中进行分配的，块的大小由系统配置参数cache决定。每张表最大内存块的数目由配置参数tblocks决定，每张表平均的内存块的个数由配置参数ablocks决定。因此对于一个vnode, 总的内存大小为: cache*ablocks*tables。内存块参数cache不宜过小，一个cache block需要能存储至少几十条以上记录，才会有效率。参数ablocks最小为2，保证每张表平均至少能分配两个内存块。
+TDengine将内存池按块划分进行管理，数据在内存块里按照列式存储。一个vnode的内存池是在vnode创建时按块分配好的，而且每个内存块按照先进先出的原则进行管理。一张表所需要的内存块是从vnode的内存池中进行分配的，块的大小由系统配置参数cache决定。每张表最大内存块的数目由配置参数tblocks决定，每张表平均的内存块的个数由配置参数ablocks决定。因此对于一个vnode, 总的内存大小为: `cache * ablocks * tables`。内存块参数cache不宜过小，一个cache block需要能存储至少几十条以上记录，才会有效率。参数ablocks最小为2，保证每张表平均至少能分配两个内存块。
 
 你可以通过函数last_row快速获取一张表或一张超级表的最后一条记录，这样很便于在大屏显示各设备的实时状态或采集值。例如：
 

documentation/webdocs/markdowndocs/advanced features.md

@@ -62,7 +62,7 @@ Time series data is a sequence of data points over time. Inside a table, the dat
 
 To reduce the development complexity and improve data consistency, TDengine provides the pub/sub functionality. To publish a message, you simply insert a record into a table. Compared with popular messaging tool Kafka, you subscribe to a table or a SQL query statement, instead of a topic. Once new data points arrive, TDengine will notify the application. The process is just like Kafka.  
 
-The detailed API will be introduced in the [connectors](https://www.taosdata.com/en/documentation/connector/) section. 
+The API documentation is at [C/C++ subscription API](https://www.taosdata.com/en/documentation/connector/#C/C++-subscription-API) section, and you can find more information from blog article (only Chinese version at present) [The usage of subscription](https://www.taosdata.com/blog/2020/02/12/1277.html).
 
 ##Caching
 TDengine allocates a fixed-size buffer in memory, the newly arrived data will be written into the buffer first. Every device or table gets one or more memory blocks. For typical IoT scenarios, the hot data shall always be newly arrived data, they are more important for timely analysis. Based on this observation, TDengine manages the cache blocks in First-In-First-Out strategy. If no enough space in the buffer, the oldest data will be saved into hard disk first, then be overwritten by newly arrived data. TDengine also guarantees every device can keep at least one block of data in the buffer. 

importSampleData/.gitignore

+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+.idea/
+.vscode/
\ No newline at end of file

importSampleData/README.md

+## 样例数据导入
+
+该工具可以根据用户提供的 `json` 或 `csv` 格式样例数据文件快速导入 `TDengine`，目前仅能在 Linux 上运行。
+
+为了体验写入和查询性能，可以对样例数据进行横向、纵向扩展。横向扩展是指将一个表（监测点）的数据克隆到多张表，纵向扩展是指将样例数据中的一段时间范围内的数据在时间轴上复制。该工具还支持历史数据导入至当前时间后持续导入，这样可以测试插入和查询并行进行的场景，以模拟真实环境。
+
+## 下载安装
+
+### 下载可执行文件
+
+由于该工具使用 go 语言开发，为了方便使用，项目中已经提供了编译好的可执行文件 `bin/taosimport`。通过 `git clone https://github.com/taosdata/TDengine.git` 命令或者直接下载 `ZIP` 文件解压进入样例导入程序目录 `cd importSampleData`，执行 `bin/taosimport`。
+
+### go 源码编译
+
+由于该工具使用 go 语言开发，编译之前需要先安装 go，具体请参考 [Getting Started][2]，而且需要安装 TDengine 的 Go Connector, 具体请参考[TDengine 连接器文档][3]。安装完成之后，执行以下命令即可编译成可执行文件 `bin/taosimport`。
+```shell
+go get https://github.com/taosdata/TDengine/importSampleData
+cd $GOPATH/src/github.com/taosdata/TDengine/importSampleData
+go build -o bin/taosimport app/main.go
+```
+
+> 注：由于目前 TDengine 的 go connector 只支持 linux 环境，所以该工具暂时只能在 linux 系统中运行。
+> 如果 go get 失败可以下载之后复制 `github.com/taosdata/TDengine/importSampleData` 文件夹到 $GOPATH 的 src 目录下再执行 `go build -o bin/taosimport app/main.go`。
+
+## 使用
+
+### 快速体验
+
+执行命令 `bin/taosimport` 会根据默认配置执行以下操作：
+1. 创建数据库
+
+   自动创建名称为 `test_yyyyMMdd` 的数据库。
+   
+2. 创建超级表
+
+   根据配置文件 `config/cfg.toml` 中指定的 `sensor_info` 场景信息创建相应的超级表。
+   > 建表语句： create table s_sensor_info(ts timestamp, temperature int, humidity float) tags(location binary(20), color binary(16), devgroup int);
+
+3. 自动建立子表并插入数据
+
+   根据配置文件 `config/cfg.toml` 中 `sensor_info` 场景指定的 `data/sensor_info.csv` 样例数据进行横向扩展 `100` 倍(可通过 hnum 参数指定)，即自动创建 `10*100=1000` 张子表(默认样例数据中有 10 张子表，每张表 100 条数据)，启动 `10` 个线程（可通过 thread 参数指定）对每张子表循环导入 `1000` 次(可通过 vnum 参数指定)。
+
+进入 `taos shell`，可运行如下查询验证：
+
+* 查询记录数
+
+    ```shell
+    taos> use test_yyyyMMdd;
+    taos> select count(*) from s_sensor_info;
+    ```
+* 查询各个分组的记录数
+
+    ```shell
+    taos> select count(*) from s_sensor_info group by devgroup;
+    ```
+* 按 1h 间隔查询各聚合指标
+
+    ```shell
+    taos> select count(temperature), sum(temperature), avg(temperature) from s_sensor_info interval(1h);
+    ```
+* 查询指定位置最新上传指标
+
+    ```shell
+    taos> select last(*) from s_sensor_info where location = 'beijing';
+    ```
+> 更多查询及函数使用请参考 [数据查询][4]
+
+### 详细使用说明
+
+执行命令 `bin/taosimport -h` 可以查看详细参数使用说明：
+
+* -cfg string
+    
+    导入配置文件路径，包含样例数据文件相关描述及对应 TDengine 配置信息。默认使用 `config/cfg.toml`。
+    
+* -cases string
+
+    需要导入的场景名称，该名称可从 -cfg 指定的配置文件中 `[usecase]` 查看，可同时导入多个场景，中间使用逗号分隔，如：`sensor_info,camera_detection`，默认为 `sensor_info`。
+    
+* -hnum int
+
+    需要将样例数据进行横向扩展的倍数，假设原有样例数据包含 1 张子表 `t_0` 数据，指定 hnum 为 2 时会根据原有表名创建 `t_0、t_1` 两张子表。默认为 100。
+    
+* -vnum int
+
+    需要将样例数据进行纵向扩展的次数，如果设置为 0 代表将历史数据导入至当前时间后持续按照指定间隔导入。默认为 1000，表示将样例数据在时间轴上纵向复制1000 次。
+
+* -delay int
+    
+    当 vnum 设置为 0 时持续导入的时间间隔，默认为所有场景中最小记录间隔时间的一半，单位 ms。
+
+* -tick int
+
+    打印统计信息的时间间隔，默认 2000 ms。
+
+* -save int
+
+    是否保存统计信息到 tdengine 的 statistic 表中，1 是，0 否， 默认 0。
+
+* -savetb int
+
+    当 save 为 1 时保存统计信息的表名， 默认 statistic。
+
+* -auto int
+    
+    是否自动生成样例数据中的主键时间戳，1 是，0 否， 默认 0。
+    
+* -start string
+
+    导入的记录开始时间，格式为 `"yyyy-MM-dd HH:mm:ss.SSS"`，不设置会使用样例数据中最小时间，设置后会忽略样例数据中的主键时间，会按照指定的 start 进行导入。如果 auto 为 1，则必须设置 start，默认为空。
+    
+* -interval int
+
+    导入的记录时间间隔，该设置只会在指定 `auto=1` 之后生效，否则会根据样例数据自动计算间隔时间。单位为毫秒，默认 1000。
+  
+* -thread int
+ 
+    执行导入数据的线程数目，默认为 10。
+  
+* -batch int
+    
+    执行导入数据时的批量大小，默认为 100。批量是指一次写操作时，包含多少条记录。
+ 
+* -host string
+
+    导入的 TDengine 服务器 IP，默认为 127.0.0.1。
+  
+* -port int
+
+    导入的 TDengine 服务器端口，默认为 6030。
+  
+* -user string
+
+    导入的 TDengine 用户名，默认为 root。
+  
+* -password string
+
+    导入的 TDengine 用户密码，默认为 taosdata。
+
+* -dropdb int
+    
+    导入数据之前是否删除数据库，1 是，0 否， 默认 0。
+
+* -db string
+
+    导入的 TDengine 数据库名称，默认为 test_yyyyMMdd。
+  
+* -dbparam string
+
+    当指定的数据库不存在时，自动创建数据库时可选项配置参数，如 `days 10 cache 16000 ablocks 4`，默认为空。
+
+### 常见使用示例
+
+* `bin/taosimport -cfg config/cfg.toml -cases sensor_info,camera_detection -hnum 1 -vnum 10`
+
+    执行上述命令后会将 sensor_info、camera_detection 两个场景的数据各导入 10 次。
+
+* `bin/taosimport -cfg config/cfg.toml -cases sensor_info -hnum 2 -vnum 0 -start "2019-12-12 00:00:00.000" -interval 5000`
+
+    执行上述命令后会将 sensor_info 场景的数据横向扩展2倍从指定时间 `2019-12-12 00:00:00.000` 开始且记录间隔时间为 5000 毫秒开始导入，导入至当前时间后会自动持续导入。
+
+### config/cfg.toml 配置文件说明
+    
+``` toml
+# 传感器场景
+[sensor_info]                               # 场景名称
+format = "csv"                              # 样例数据文件格式，可以是 json 或 csv，具体字段应至少包含 subTableName、tags、fields 指定的字段。
+filePath = "data/sensor_info.csv"           # 样例数据文件路径，程序会循环使用该文件数据
+separator = ","                             # csv 样例文件中字段分隔符，默认逗号
+
+stname = "sensor_info"                      # 超级表名称
+subTableName = "devid"                      # 使用样例数据中指定字段当作子表名称一部分，子表名称格式为 t_subTableName_stname，扩展表名为 t_subTableName_stname_i。
+timestamp = "ts"                            # 使用 fields 中哪个字段当作主键，类型必须为 timestamp
+timestampType="millisecond"                 # 样例数据中主键时间字段是 millisecond 还是 dateTime 格式
+#timestampTypeFormat = "2006-01-02 15:04:05.000"  # 主键日期时间格式，timestampType 为 dateTime 时需要指定
+tags = [
+    # 标签列表，name 为标签名称，type 为标签类型
+    { name = "location",             type = "binary(20)" },
+    { name = "color",             type = "binary(16)" },
+    { name = "devgroup",           type = "int" },
+]
+
+fields = [
+    # 字段列表，name 为字段名称，type 为字段类型
+    { name = "ts",                  type = "timestamp" },
+    { name = "temperature",         type = "int" },
+    { name = "humidity",            type = "float" },
+]
+
+# 摄像头检测场景
+[camera_detection]                          # 场景名称
+format = "json"                             # 样例数据文件格式，可以是 json 或 csv，具体字段应至少包含 subTableName、tags、fields 指定的字段。
+filePath = "data/camera_detection.json"     # 样例数据文件路径，程序会循环使用该文件数据
+#separator = ","                            # csv 样例文件中字段分隔符，默认逗号, 如果是 json 文件可以不用配置
+ 
+stname = "camera_detection"                 # 超级表名称
+subTableName = "sensor_id"                  # 使用样例数据中指定字段当作子表名称一部分，子表名称格式为 t_subTableName_stname，扩展表名为 t_subTableName_stname_i。
+timestamp = "ts"                            # 使用 fields 中哪个字段当作主键，类型必须为 timestamp
+timestampType="dateTime"                    # 样例数据中主键时间字段是 millisecond 还是 dateTime 格式
+timestampTypeFormat = "2006-01-02 15:04:05.000"  # 主键日期时间格式，timestampType 为 dateTime 时需要指定
+tags = [
+    # 标签列表，name 为标签名称，type 为标签类型
+    { name = "home_id",           type = "binary(30)" },
+    { name = "object_type",       type = "int" },
+    { name = "object_kind",       type = "binary(20)" },
+]
+
+fields = [
+    # 字段列表，name 为字段名称，type 为字段类型
+    { name = "ts",                type = "timestamp" },
+    { name = "states",               type = "tinyint" },
+    { name = "battery_voltage",   type = "float" },
+]
+
+# other cases
+
+```
+
+### 样例数据格式说明
+
+#### json
+
+当配置文件 `config/cfg.toml` 中各场景的 format="json" 时，样例数据文件需要提供 tags 和 fields 字段列表中的字段值。样例数据格式如下：
+
+```json
+{"home_id": "603", "sensor_id": "s100", "ts": "2019-01-01 00:00:00.000", "object_type": 1, "object_kind": "night", "battery_voltage": 0.8, "states": 1}
+{"home_id": "604", "sensor_id": "s200", "ts": "2019-01-01 00:00:00.000", "object_type": 2, "object_kind": "day", "battery_voltage": 0.6, "states": 0}
+```
+
+#### csv
+
+当配置文件 `config/cfg.toml` 中各场景的 format="csv" 时，样例数据文件需要提供表头和对应的数据，其中字段分隔符由使用场景中 `separator` 指定，默认逗号。具体格式如下：
+
+```csv
+devid,location,color,devgroup,ts,temperature,humidity
+0, beijing, white, 0, 1575129600000, 16, 19.405091
+0, beijing, white, 0, 1575129601000, 22, 14.377142
+```
+
+
+
+[1]: https://github.com/taosdata/TDengine
+[2]: https://golang.org/doc/install
+[3]: https://www.taosdata.com/cn/documentation/connector/#Go-Connector
+[4]: https://www.taosdata.com/cn/documentation/taos-sql/#%E6%95%B0%E6%8D%AE%E6%9F%A5%E8%AF%A2
\ No newline at end of file

importSampleData/config/cfg.toml

+# 传感器场景
+[sensor_info]                               # 场景名称
+format = "csv"                              # 样例数据文件格式，可以是 json 或 csv，具体字段应至少包含 subTableName、tags、fields 指定的字段。
+filePath = "data/sensor_info.csv"           # 样例数据文件路径，程序会循环使用该文件数据
+separator = ","                             # csv 样例文件中字段分隔符，默认逗号
+
+stname = "sensor_info"                      # 超级表名称
+subTableName = "devid"                      # 使用样例数据中指定字段当作子表名称一部分，子表名称格式为 t_subTableName_stname，扩展表名为 t_subTableName_stname_i。
+timestamp = "ts"                            # 使用 fields 中哪个字段当作主键，类型必须为 timestamp
+timestampType="millisecond"                 # 样例数据中主键时间字段是 millisecond 还是 dateTime 格式
+#timestampTypeFormat = "2006-01-02 15:04:05.000"  # 主键日期时间格式，timestampType 为 dateTime 时需要指定
+tags = [
+    # 标签列表，name 为标签名称，type 为标签类型
+    { name = "location",           type = "binary(20)" },
+    { name = "color",              type = "binary(16)" },
+    { name = "devgroup",           type = "int" },
+]
+
+fields = [
+    # 字段列表，name 为字段名称，type 为字段类型
+    { name = "ts",                  type = "timestamp" },
+    { name = "temperature",         type = "int" },
+    { name = "humidity",            type = "float" },
+]
+
+# 摄像头检测场景
+[camera_detection]                          # 场景名称
+format = "json"                             # 样例数据文件格式，可以是 json 或 csv，具体字段应至少包含 subTableName、tags、fields 指定的字段。
+filePath = "data/camera_detection.json"     # 样例数据文件路径，程序会循环使用该文件数据
+#separator = ","                            # csv 样例文件中字段分隔符，默认逗号, 如果是 json 文件可以不用配置
+ 
+stname = "camera_detection"                 # 超级表名称
+subTableName = "sensor_id"                  # 使用样例数据中指定字段当作子表名称一部分，子表名称格式为 t_subTableName_stname，扩展表名为 t_subTableName_stname_i。
+timestamp = "ts"                            # 使用 fields 中哪个字段当作主键，类型必须为 timestamp
+timestampType="dateTime"                    # 样例数据中主键时间字段是 millisecond 还是 dateTime 格式
+timestampTypeFormat = "2006-01-02 15:04:05.000"  # 主键日期时间格式，timestampType 为 dateTime 时需要指定
+tags = [
+    # 标签列表，name 为标签名称，type 为标签类型
+    { name = "home_id",           type = "binary(30)" },
+    { name = "object_type",       type = "int" },
+    { name = "object_kind",       type = "binary(20)" },
+]
+
+fields = [
+    # 字段列表，name 为字段名称，type 为字段类型
+    { name = "ts",                type = "timestamp" },
+    { name = "states",            type = "tinyint" },
+    { name = "battery_voltage",   type = "float" },
+]
+
+# other case
\ No newline at end of file

packaging/rpm/taosd

@@ -26,7 +26,7 @@ MAX_OPEN_FILES=65535
 
 # Default program options
 NAME=taosd
-PROG=/usr/local/bin/taos/taosd
+PROG=/usr/local/taos/bin/taosd
 USER=root
 GROUP=root
 

packaging/tools/get_os.sh

+#!/bin/bash
+#
+# This file is used to install TAOS time-series database on linux systems. The operating system 
+# is required to use systemd to manage services at boot
+
+set -e
+# set -x
+
+# -----------------------Variables definition---------------------
+OS=$(cat /etc/*-release | grep "^NAME=" | cut -d= -f2)
+len=$(echo ${#OS})
+len=$((len-2))
+retval=$(echo -ne ${OS:1:${len}} | cut -d" " -f1)
+echo -ne $retval