Merge pull request #1 from taosdata/develop

合并

CMakeLists.txt

@@ -26,6 +26,13 @@ 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)
@@ -183,9 +190,11 @@ IF (NOT DEFINED TD_CLUSTER)
     ENDIF ()
   ELSEIF (TD_WINDOWS_64)
     SET(CMAKE_GENERATOR "NMake Makefiles" CACHE INTERNAL "" FORCE)
+    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)
@@ -251,6 +260,7 @@ 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)
+    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)
@@ -266,6 +276,15 @@ IF (NOT DEFINED TD_CLUSTER)
       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

@@ -45,10 +45,16 @@ mkdir build && cd build
 cmake .. && cmake --build .
 ```
 
-if compiling on an arm64 processor, you need add one parameter:
+To compile on an ARM processor (aarch64 or aarch32), please add option CPUTYPE as below:
 
+aarch64:
 ```cmd
-cmake .. -DARMVER=arm64 && cmake --build .
+cmake .. -DCPUTYPE=aarch64 && cmake --build .
+```
+
+aarch32:
+```cmd
+cmake .. -DCPUTYPE=aarch32 && cmake --build .
 ```
 
 # Quick Run

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/webdocs/markdowndocs/Connector.md

@@ -175,26 +175,34 @@ TDengine provides APIs for continuous query driven by time, which run queries pe
 
 ### C/C++ subscription API
 
-For the time being, TDengine supports subscription on one table. It is implemented through periodic pulling from a TDengine server. 
+For the time being, TDengine supports subscription on one or multiple tables. It is implemented through periodic pulling from a TDengine server. 
 
-- `TAOS_SUB *taos_subscribe(char *host, char *user, char *pass, char      *db, char *table, int64_t time, int mseconds)`
-  The API is used to start a subscription session by given a handle. The parameters required are _host_ (IP address of a TDenginer server), _user_ (username), _pass_ (password), _db_ (database to use), _table_ (table name to subscribe), _time_ (start time to subscribe, 0 for now), _mseconds_ (pulling period). If failed to open a subscription session, a _NULL_ pointer is returned.
+* `TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval)`
 
+  The API is used to start a subscription session, it returns the subscription object on success and `NULL` in case of failure, the parameters are:
+  * **taos**: The database connnection, which must be established already.
+  * **restart**: `Zero` to continue a subscription if it already exits, other value to start from the beginning.
+  * **topic**: The unique identifier of a subscription.
+  * **sql**: A sql statement for data query, it can only be a `select` statement, can only query for raw data, and can only query data in ascending order of the timestamp field.
+  * **fp**: A callback function to receive query result, only used in asynchronization mode and should be `NULL` in synchronization mode, please refer below for its prototype.
+  * **param**: User provided additional parameter for the callback function.
+  * **interval**: Pulling interval in millisecond. Under asynchronization mode, API will call the callback function `fp` in this interval, system performance will be impacted if this interval is too short. Under synchronization mode, if the duration between two call to `taos_consume` is less than this interval, the second call blocks until the duration exceed this interval.
 
-- `TAOS_ROW taos_consume(TAOS_SUB *tsub)`
-  The API used to get the new data from a TDengine server. It should be put in an infinite loop. The parameter _tsub_ is the handle returned by _taos_subscribe_. If new data are updated, the API will return a row of the result. Otherwise, the API is blocked until new data arrives. If _NULL_ pointer is returned, it means an error occurs.
+* `typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code)`
 
+  Prototype of the callback function, the parameters are:
+  * tsub: The subscription object.
+  * res: The query result.
+  * param: User provided additional parameter when calling `taos_subscribe`.
+  * code: Error code in case of failures.
 
-- `void taos_unsubscribe(TAOS_SUB *tsub)`
-  Stop a subscription session by the handle returned by _taos_subscribe_.
+* `TAOS_RES *taos_consume(TAOS_SUB *tsub)`
 
+  The API used to get the new data from a TDengine server. It should be put in an loop. The parameter `tsub` is the handle returned by `taos_subscribe`. This API should only be called in synchronization mode. If the duration between two call to `taos_consume` is less than pulling interval, the second call blocks until the duration exceed the interval. The API returns the new rows if new data arrives, or empty rowset otherwise, and if there's an error, it returns `NULL`.
   
-- `int taos_num_subfields(TAOS_SUB *tsub)`
-  The API used to get the number of fields in a row.
+* `void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress)`
 
-
-- `TAOS_FIELD *taos_fetch_subfields(TAOS_SUB *tsub)`
-  The API used to get the description of each column.
+  Stop a subscription session by the handle returned by `taos_subscribe`. If `keepProgress` is **not** zero, the subscription progress information is kept and can be reused in later call to `taos_subscribe`, the information is removed otherwise.
 
 ##  Java Connector
 
@@ -208,7 +216,7 @@ Since the native language of TDengine is C, the necessary TDengine library shoul
 * taos.dll (Windows)
     After TDengine client is installed, the library `taos.dll` will be automatically copied to the `C:/Windows/System32`, which is the system's default search path. 
     
-> Note: Please make sure that TDengine Windows client has been installed if developing on Windows.
+> Note: Please make sure that [TDengine Windows client][14] has been installed if developing on Windows. Now although TDengine client would be defaultly installed together with TDengine server, it can also be installed [alone][15].
 
 Since TDengine is time-series database, there are still some differences compared with traditional databases in using TDengine JDBC driver: 
 * TDengine doesn't allow to delete/modify a single record, and thus JDBC driver also has no such method. 
@@ -583,13 +591,35 @@ data = c1.fetchall()
 numOfRows = c1.rowcount
 numOfCols = len(c1.description)
 for irow in range(numOfRows):
-  print("Row%d: ts=%s, temperature=%d, humidity=%f" %(irow, data[irow][0], data[irow][1],data[irow][2])
+  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])
 ```
+
+* create a subscription
+```python
+# Create a subscription with topic 'test' and consumption interval 1000ms.
+# The first argument is True means to restart the subscription;
+# if the subscription with topic 'test' has already been created, then pass
+# False to this argument means to continue the existing subscription.
+sub = conn.subscribe(True, "test", "select * from meters;", 1000)
+```
+
+* consume a subscription
+```python
+data = sub.consume()
+for d in data:
+    print(d)
+```
+
+* close the subscription
+```python
+sub.close()
+```
+
 * close the connection
 ```python
 c1.close()
@@ -882,4 +912,5 @@ An example of using the NodeJS connector to achieve the same things but without
 [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/documentation/administrator/#%E5%AE%A2%E6%88%B7%E7%AB%AF%E9%85%8D%E7%BD%AE
-
+[14]: https://www.taosdata.com/cn/documentation/connector/#Windows%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%8F%8A%E7%A8%8B%E5%BA%8F%E6%8E%A5%E5%8F%A3
+[15]: https://www.taosdata.com/cn/getting-started/#%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B

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,11 +11,41 @@ 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开始的毫秒数
@@ -27,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的空间。如用户字符串长度超出声明长度，则将被自动截断。 |
 
@@ -165,19 +197,172 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 
 ## 数据查询
 
-###查询语法是：
+### 查询语法：
 
 ```mysql
-SELECT {* | expr_list} FROM tb_name
-    [WHERE where_condition]
-    [ORDER BY _c0 { DESC | ASC }]
-    [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）。
 
-SELECT function_list FROM tb_name
-    [WHERE where_condition]
-    [LIMIT limit [, OFFSET offset]]
-    [>> export_file]
+##### 通配符
+通配符 * 可以用于代指全部列。对于普通表，结果中只有普通列。
+```
+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             |
 ```
 
 - 可以使用* 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名
@@ -238,7 +423,7 @@ SELECT function_list FROM tb_name
 
 ###聚合函数
 
-TDengine支持针对数据的聚合查询。提供支持的聚合和提取函数如下表：
+TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数如下：
 
 - **COUNT**
     ```mysql
@@ -261,13 +446,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类型字段。
+    说明：时间加权平均(time weighted average, TWA）查询需要指定查询时间段的 _开始时间_ 和 _结束时间_ 。
     适用于：表、超级表。
 
 
@@ -371,6 +557,14 @@ 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

documentation/webdocs/markdowndocs/administrator-ch.md

@@ -337,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]对数据进行横向和纵向扩展导入。
 
 ## 数据导出
 
@@ -407,3 +409,6 @@ KILL STREAM <stream-id>
 TDengine启动后，会自动创建一个监测数据库`LOG`，并自动将服务器的CPU、内存、硬盘空间、带宽、请求数、磁盘读写速度、慢查询等信息定时写入该数据库。TDengine还将重要的系统操作（比如登录、创建、删除数据库等）日志以及各种错误报警信息记录下来存放在`LOG`库里。系统管理员可以通过客户端程序查看记录库中的运行负载信息，（在企业版中）还可以通过浏览器查看数据的图标可视化结果。
 
 这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项`monitor`将其关闭或打开。
+
+
+[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请见 [连接器](https://www.taosdata.com/cn/documentation/connector/)。
 
 ## 缓存 (Cache)
 TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Use，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。

documentation/webdocs/markdowndocs/connector-ch.md

@@ -164,27 +164,36 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
 
 ### C/C++ 数据订阅接口
 
-订阅API目前支持订阅一张表，并通过定期轮询的方式不断获取写入表中的最新数据。 
+订阅API目前支持订阅一张或多张表，并通过定期轮询的方式不断获取写入表中的最新数据。 
 
-- `TAOS_SUB *taos_subscribe(char *host, char *user, char *pass, char *db, char *table, int64_t time, int mseconds)`
+* `TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval)`
 
-  该API用来启动订阅，需要提供的参数包含：TDengine管理主节点的IP地址、用户名、密码、数据库、数据库表的名字；time是开始订阅消息的时间，是从1970年1月1日起计算的毫秒数，为长整型, 如果设为0，表示从当前时间开始订阅；mseconds为查询数据库更新的时间间隔，单位为毫秒，建议设为1000毫秒。返回值为一指向TDengine_SUB结构的指针，如果返回为空，表示失败。
+  该函数负责启动订阅服务，成功时返回订阅对象，失败时返回 `NULL`，其参数为：
+  * taos：已经建立好的数据库连接
+  * restart：如果订阅已经存在，是重新开始，还是继续之前的订阅
+  * topic：订阅的主题（即名称），此参数是订阅的唯一标识
+  * sql：订阅的查询语句，此语句只能是 `select` 语句，只应查询原始数据，只能按时间正序查询数据
+  * fp：收到查询结果时的回调函数（稍后介绍函数原型），只在异步调用时使用，同步调用时此参数应该传 `NULL`
+  * param：调用回调函数时的附加参数，系统API将其原样传递到回调函数，不进行任何处理
+  * interval：轮询周期，单位为毫秒。异步调用时，将根据此参数周期性的调用回调函数，为避免对系统性能造成影响，不建议将此参数设置的过小；同步调用时，如两次调用`taos_consume`的间隔小于此周期，API将会阻塞，直到时间间隔超过此周期。
 
-- `TAOS_ROW taos_consume(TAOS_SUB *tsub)`
+* `typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code)`
 
-  该API用来获取最新消息，应用程序一般会将其置于一个无限循环语句中。其中参数tsub是taos_subscribe的返回值。如果数据库有新的记录，该API将返回，返回参数是一行记录。如果没有新的记录，该API将阻塞。如果返回值为空，说明系统出错，需要检查系统是否还在正常运行。
+  异步模式下，回调函数的原型，其参数为：
+  * tsub：订阅对象
+  * res：查询结果集，注意结果集中可能没有记录
+  * param：调用 `taos_subscribe`时客户程序提供的附加参数
+  * code：错误码
 
-- `void taos_unsubscribe(TAOS_SUB *tsub)`
 
-  该API用于取消订阅，参数tsub是taos_subscribe的返回值。应用程序退出时，需要调用该API，否则有资源泄露。
+* `TAOS_RES *taos_consume(TAOS_SUB *tsub)`
 
-- `int taos_num_subfields(TAOS_SUB *tsub)`
+  同步模式下，该函数用来获取订阅的结果。 用户应用程序将其置于一个循环之中。 如两次调用`taos_consume`的间隔小于订阅的轮询周期，API将会阻塞，直到时间间隔超过此周期。 如果数据库有新记录到达，该API将返回该最新的记录，否则返回一个没有记录的空结果集。 如果返回值为 `NULL`，说明系统出错。 异步模式下，用户程序不应调用此API。
 
-  该API用来获取返回的一排数据中数据的列数
+* `void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress)`
 
-- `TAOS_FIELD *taos_fetch_subfields(TAOS_SUB *tsub)`
+  取消订阅。 如参数 `keepProgress` 不为0，API会保留订阅的进度信息，后续调用 `taos_subscribe` 时可以基于此进度继续；否则将删除进度信息，后续只能重新开始读取数据。
 
-  该API用来获取每列数据的属性（数据类型、名字、字节数），与taos_num_subfields配合使用，可用来解析返回的一排数据。
 
 ##  Java Connector
 
@@ -198,14 +207,14 @@ TDengine 为了方便 Java 应用使用，提供了遵循 JDBC 标准(3.0)API
 * taos.dll
     在 windows 系统中安装完客户端之后，驱动包依赖的 taos.dll 文件会自动拷贝到系统默认搜索路径 C:/Windows/System32 下，同样无需要单独指定。
     
-> 注意：在 windows 环境开发时需要安装 TDengine 对应的 windows 版本客户端，由于目前没有提供 Linux 环境单独的客户端，需要安装 TDengine 才能使用。
+> 注意：在 windows 环境开发时需要安装 TDengine 对应的 [windows 客户端][14]，Linux 服务器安装完 TDengine 之后默认已安装 client，也可以单独安装 [Linux 客户端][15] 连接远程 TDengine Server。
 
 TDengine 的 JDBC 驱动实现尽可能的与关系型数据库驱动保持一致，但时序空间数据库与关系对象型数据库服务的对象和技术特征的差异导致 taos-jdbcdriver 并未完全实现 JDBC 标准规范。在使用时需要注意以下几点：
 
 * TDengine 不提供针对单条数据记录的删除和修改的操作，驱动中也没有支持相关方法。
 * 由于不支持删除和修改，所以也不支持事务操作。
 * 目前不支持表间的 union 操作。
-* 目前不支持嵌套查询(nested query)，`对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet还没关闭的情况下执行了新的查询，TSDBJDBCDriver 则会自动关闭上一个 ResultSet`。
+* 目前不支持嵌套查询(nested query)，对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet还没关闭的情况下执行了新的查询，TSDBJDBCDriver 则会自动关闭上一个 ResultSet。
 
 
 ## TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
@@ -579,13 +588,34 @@ data = c1.fetchall()
 numOfRows = c1.rowcount
 numOfCols = len(c1.description)
 for irow in range(numOfRows):
-  print("Row%d: ts=%s, temperature=%d, humidity=%f" %(irow, data[irow][0], data[irow][1],data[irow][2])
+  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])
 ```
+
+* 创建订阅
+```python
+# 创建一个主题为 'test' 消费周期为1000毫秒的订阅
+# 第一个参数为 True 表示重新开始订阅，如为 False 且之前创建过主题为 'test' 的订阅，则表示继续消费此订阅的数据，而不是重新开始消费所有数据
+sub = conn.subscribe(True, "test", "select * from meters;", 1000)
+```
+
+* 消费订阅的数据
+```python
+data = sub.consume()
+for d in data:
+    print(d)
+```
+
+* 取消订阅
+```python
+sub.close()
+```
+
+
 * 关闭连接
 ```python
 c1.close()
@@ -807,6 +837,8 @@ HTTP请求URL采用`sqlutc`时，返回结果集的时间戳将采用UTC时间
 
 ## Go Connector
 
+### linux环境
+
 #### 安装TDengine
 
 Go的连接器使用到了 libtaos.so 和taos.h，因此，在使用Go连接器之前，需要在程序运行的机器上安装TDengine以获得相关的驱动文件。
@@ -867,7 +899,14 @@ taosSql驱动包内采用cgo模式，调用了TDengine的C/C++同步接口，与
 
 3. 创建表、写入和查询数据
 
-在创建好了数据库后，就可以开始创建表和写入查询数据了。这些操作的基本思路都是首先组装SQL语句，然后调用db.Exec执行，并检查错误信息和执行相应的处理。可以参考上面的样例代码
+在创建好了数据库后，就可以开始创建表和写入查询数据了。这些操作的基本思路都是首先组装SQL语句，然后调用db.Exec执行，并检查错误信息和执行相应的处理。可以参考上面的样例代码。
+
+### windows环境
+
+在windows上使用Go，请参考 
+[TDengine GO windows驱动的编译和使用](https://www.taosdata.com/blog/2020/01/06/tdengine-go-windows%E9%A9%B1%E5%8A%A8%E7%9A%84%E7%BC%96%E8%AF%91/)
+
+
 
 ## Node.js Connector
 
@@ -1054,6 +1093,8 @@ https://gitee.com/maikebing/Maikebing.EntityFrameworkCore.Taos
 ├───├── jdbc
 ├───└── python
 ├── driver
+├───├── libtaos.dll
+├───├── libtaos.dll.a
 ├───├── taos.dll
 ├───├── taos.exp
 ├───└── taos.lib
@@ -1078,8 +1119,8 @@ https://gitee.com/maikebing/Maikebing.EntityFrameworkCore.Taos
 
 + Client可执行文件: C:/TDengine/taos.exe 
 + 配置文件: C:/TDengine/cfg/taos.cfg
-+ C驱动程序目录: C:/TDengine/driver
-+ C驱动程序头文件: C:/TDengine/include
++ 驱动程序目录: C:/TDengine/driver
++ 驱动程序头文件: C:/TDengine/include
 + JDBC驱动程序目录: C:/TDengine/connector/jdbc
 + GO驱动程序目录：C:/TDengine/connector/go
 + Python驱动程序目录：C:/TDengine/connector/python
@@ -1106,6 +1147,14 @@ taos -h <ServerIP>
 
 TDengine在Window系统上提供的API与Linux系统是相同的， 应用程序使用时，需要包含TDengine头文件taos.h，连接时需要链接TDengine库taos.lib，运行时将taos.dll放到可执行文件目录下。
 
+#### Go接口注意事项
+
+TDengine在Window系统上提供的API与Linux系统是相同的， 应用程序使用时，除了需要Go的驱动包（C:\TDengine\connector\go）外，还需要包含TDengine头文件taos.h，连接时需要链接TDengine库libtaos.dll、libtaos.dll.a（C:\TDengine\driver），运行时将libtaos.dll、libtaos.dll.a放到可执行文件目录下。
+
+使用参考请见：
+
+[TDengine GO windows驱动的编译和使用](https://www.taosdata.com/blog/2020/01/06/tdengine-go-windows%E9%A9%B1%E5%8A%A8%E7%9A%84%E7%BC%96%E8%AF%91/)
+
 #### JDBC接口注意事项
 
 在Windows系统上，应用程序可以使用JDBC接口来操纵数据库，使用JDBC接口的注意事项如下：
@@ -1121,6 +1170,49 @@ TDengine在Window系统上提供的API与Linux系统是相同的， 应用程序
 
 + 将Windows开发包(taos.dll)放置到system32目录下。
 
+## Mac客户端及程序接口
+
+### 客户端安装
+
+在Mac操作系统下，TDengine提供64位的Mac客户端([2月10日起提供下载](https://www.taosdata.com/cn/all-downloads/#tdengine_mac-list))，客户端安装程序为.tar.gz文件，解压并运行其中的install_client.sh后即可完成安装，安装路径为/usr/loca/taos。客户端目录结构如下：
+
+```
+├── cfg
+├───└── taos.cfg
+├── connector
+├───├── go
+├───├── grafana
+├───├── jdbc
+├───└── python
+├── driver
+├───├── libtaos.1.6.5.1.dylib
+├── examples
+├───├── bash
+├───├── c
+├───├── C#
+├───├── go
+├───├── JDBC
+├───├── lua
+├───├── matlab
+├───├── nodejs
+├───├── python
+├───├── R
+├───└── rust
+├── include
+├───└── taos.h
+└── bin
+├───└── taos
+```
+
+其中，最常用的文件列出如下：
+
++ Client可执行文件: /usr/local/taos/bin/taos 软连接到 /usr/local/bin/taos
++ 配置文件: /usr/local/taos/cfg/taos.cfg 软连接到 /etc/taos/taos.cfg
++ 驱动程序目录: /usr/local/taos/driver/libtaos.1.6.5.1.dylib 软连接到 /usr/local/lib/libtaos.dylib
++ 驱动程序头文件: /usr/local/taos/include/taos.h 软连接到 /usr/local/include/taos.h
++ 日志目录（第一次运行程序时生成）：~/TDengineLog
+
+
 
 [1]: https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver
 [2]: https://mvnrepository.com/artifact/com.taosdata.jdbc/taos-jdbcdriver
@@ -1135,3 +1227,5 @@ TDengine在Window系统上提供的API与Linux系统是相同的， 应用程序
 [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/documentation/administrator/#%E5%AE%A2%E6%88%B7%E7%AB%AF%E9%85%8D%E7%BD%AE
+[14]: https://www.taosdata.com/cn/documentation/connector/#Windows%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%8F%8A%E7%A8%8B%E5%BA%8F%E6%8E%A5%E5%8F%A3
+[15]: https://www.taosdata.com/cn/getting-started/#%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B

importSampleData/README.md

@@ -97,6 +97,10 @@ go build -o bin/taosimport app/main.go
 
     是否保存统计信息到 tdengine 的 statistic 表中，1 是，0 否， 默认 0。
 
+* -savetb int
+
+    当 save 为 1 时保存统计信息的表名， 默认 statistic。
+
 * -auto int
     
     是否自动生成样例数据中的主键时间戳，1 是，0 否， 默认 0。

importSampleData/app/main.go

@@ -28,6 +28,7 @@ const (
 	DEFAULT_STARTTIME int64 = -1
 	DEFAULT_INTERVAL int64 = 1*1000
 	DEFAULT_DELAY int64 = -1
+	DEFAULT_STATISTIC_TABLE = "statistic"
 
 	JSON_FORMAT = "json"
 	CSV_FORMAT = "csv"
@@ -37,7 +38,6 @@ const (
 	DRIVER_NAME = "taosSql"
 	STARTTIME_LAYOUT = "2006-01-02 15:04:05.000"
 	INSERT_PREFIX = "insert into "
-	STATISTIC_TABLE = "statistic"
 )
 
 var (
@@ -75,6 +75,7 @@ var (
 	delay int64  // default 10 milliseconds
 	tick int64
 	save int
+	saveTable string
 )
 
 type superTableConfig struct {
@@ -278,9 +279,9 @@ func staticSpeed(){
 
 	if save == 1 {
 		connection.Exec("use " + db)
-		_, err := connection.Exec("create table if not exists " + STATISTIC_TABLE +"(ts timestamp, speed int)")
+		_, err := connection.Exec("create table if not exists " + saveTable +"(ts timestamp, speed int)")
 		if err != nil {
-			log.Fatalf("create %s Table error: %s\n", STATISTIC_TABLE, err)
+			log.Fatalf("create %s Table error: %s\n", saveTable, err)
 		}
 	}
 
@@ -297,7 +298,7 @@ func staticSpeed(){
 		log.Printf("insert %d rows, used %d ms, speed %d rows/s", currentSuccessRows, usedTime/1e6, speed)
 
 		if save == 1 {
-			insertSql := fmt.Sprintf("insert into %s values(%d, %d)", STATISTIC_TABLE, currentTime.UnixNano()/1e6, speed)
+			insertSql := fmt.Sprintf("insert into %s values(%d, %d)", saveTable, currentTime.UnixNano()/1e6, speed)
 			connection.Exec(insertSql)
 		}
 		
@@ -353,7 +354,7 @@ func createStatisticTable(){
 	connection := getConnection()
 	defer connection.Close()
 
-	_, err := connection.Exec("create table if not exist " + db + "."+ STATISTIC_TABLE +"(ts timestamp, speed int)")
+	_, err := connection.Exec("create table if not exist " + db + "."+ saveTable +"(ts timestamp, speed int)")
 	if err != nil {
 		log.Fatalf("createStatisticTable error: %s\n", err)
 	}
@@ -1037,6 +1038,7 @@ func parseArg() {
 	flag.Int64Var(&delay, "delay", DEFAULT_DELAY, "the delay time interval(millisecond) to continue generating data when vnum set 0.")
 	flag.Int64Var(&tick, "tick", 2000, "the tick time interval(millisecond) to print statistic info.")
 	flag.IntVar(&save, "save", 0, "whether to save the statistical info into 'statistic' table. 0 is disabled and 1 is enabled.")
+	flag.StringVar(&saveTable, "savetb", DEFAULT_STATISTIC_TABLE, "the table to save 'statistic' info when save set 1.")
 	flag.IntVar(&thread, "thread", 10, "number of threads to import data.")
 	flag.IntVar(&batch, "batch", 100, "rows of records in one import batch.")
 	flag.IntVar(&auto, "auto", 0, "whether to use the starttime and interval specified by users when simulating the data. 0 is disabled and 1 is enabled.")
@@ -1062,6 +1064,7 @@ func printArg()  {
 	fmt.Println("-delay:", delay)
 	fmt.Println("-tick:", tick)
 	fmt.Println("-save:", save)
+	fmt.Println("-savetb:", saveTable)
 	fmt.Println("-thread:", thread)
 	fmt.Println("-batch:", batch)
 	fmt.Println("-auto:", auto)

importSampleData/dashboard/sensor_info.json

@@ -15,7 +15,7 @@
   "editable": true,
   "gnetId": null,
   "graphTooltip": 0,
-  "id": 4,
+  "id": 7,
   "links": [],
   "panels": [
     {
@@ -84,7 +84,7 @@
         {
           "alias": "lastest_temperature",
           "refId": "A",
-          "sql": "select last(temperature) from test.s_sensor_info where location = 'beijing' and ts > now - 1h and ts < now  interval(1m)",
+          "sql": "select  ts, temp from  test.stream_temp_last  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         }
@@ -116,9 +116,10 @@
       "options": {
         "fieldOptions": {
           "calcs": [
-            "mean"
+            "last"
           ],
           "defaults": {
+            "decimals": 2,
             "mappings": [],
             "max": 100,
             "min": 0,
@@ -146,7 +147,7 @@
         {
           "alias": "maxHumidity",
           "refId": "A",
-          "sql": "select max(humidity) from test.s_sensor_info where location = 'beijing' and ts > now -1h and ts < now",
+          "sql": "select  ts, humidity  from  test.stream_humidity_max  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         }
@@ -198,7 +199,7 @@
         {
           "alias": "avgTemperature",
           "refId": "A",
-          "sql": "select avg(temperature) from test.s_sensor_info where location = 'beijing' and ts > now -1h and ts < now  interval(1m)",
+          "sql": "select  ts, temp from  test.stream_temp_avg  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         }
@@ -284,23 +285,23 @@
       "steppedLine": false,
       "targets": [
         {
-          "alias": "avg",
+          "alias": "max",
           "refId": "A",
-          "sql": "select max(temperature) from test.t_0_sensor_info where ts > now -1h and ts < now  interval(1m)",
+          "sql": "select  ts, max_temp  from  test.stream_sensor  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         },
         {
-          "alias": "max",
+          "alias": "avg",
           "refId": "B",
-          "sql": "select avg(temperature) from test.t_0_sensor_info where ts > now -1h and ts < now  interval(1m)",
+          "sql": "select  ts, avg_temp   from  test.stream_sensor  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         },
         {
           "alias": "min",
           "refId": "C",
-          "sql": "select min(temperature) from test.t_0_sensor_info where ts > now -1h and ts < now interval(1m)",
+          "sql": "select  ts, min_temp   from  test.stream_sensor  where ts >= $from and ts < $to",
           "target": "select metric",
           "type": "timeserie"
         }
@@ -355,7 +356,7 @@
     "list": []
   },
   "time": {
-    "from": "now-1h",
+    "from": "now-5m",
     "to": "now"
   },
   "timepicker": {

minidevops/README.MD

+# 一分钟快速搭建一个DevOps监控系统
+为了让更多的Devops领域的开发者快速体验TDengine的优秀特性，本文介绍了一种快速搭建Devops领域性能监控的demo，方便大家更方便的了解TDengine，并基于此文拓展Devops领域的应用。
+为了快速上手，本文用到的软件全部采用Docker容器方式部署，大家只需要安装Docker软件，就可以直接通过脚本运行所有软件，无需安装。这个Demo用到了以下Docker容器，都可以从Dockerhub上拉取相关镜像
+- tdengine/tdengine:1.6.4.5                          TDengine开源版1.6.4.5.的镜像
+- tdengine/blm_telegraf:latest                     用于telegraf写入TDengine的API，可以schemaless的将telegraf的数据写入TDengine
+- tdengine/blm_prometheus:latest             用于Prometheus写入TDengine的API，可以schemaless的将Prometheus的数据写入TDengine
+- grafana/grafana                                         Grafana的镜像，一个广泛应用的开源可视化监控软件
+- telegraf:latest                                            一个广泛应用的开源数据采集程序
+- prom/prometheus:latest                           一个广泛应用的k8s领域的开源数据采集程序
+## 说明
+本文中的图片链接在Github上显示不出来，建议将MD文件下载后用vscode或其他md文件浏览工具进行查看
+## 前提条件
+1. 一台linux服务器或运行linux操作系统的虚拟机或者运行MacOS的计算机
+2. 安装了Docker软件。Docker软件的安装方法请参考linux下安装Docker
+3. sudo权限
+4. 下载本文用到的配置文件和脚本压缩包:[下载地址](http://www.taosdata.com/download/minidevops.tar.gz)
+
+压缩包下载下来后解压生成一个minidevops的文件夹，其结构如下
+```sh
+minidevops$ tree
+.
+├── demodashboard.json
+├── grafana
+│   └── tdengine
+│       ├── README.md
+│       ├── css
+│       │   └── query-editor.css
+│       ├── datasource.js
+│       ├── img
+│       │   └── taosdata_logo.png
+│       ├── module.js
+│       ├── partials
+│       │   ├── config.html
+│       │   └── query.editor.html
+│       ├── plugin.json
+│       └── query_ctrl.js
+├── prometheus
+│   └── prometheus.yml
+├── run.sh
+└── telegraf
+    └── telegraf.conf
+```
+`grafana`子文件夹里是TDengine的插件，用于在grafana中导入TDengine的数据源。
+`prometheus`子文件夹里是prometheus需要的配置文件。
+`run.sh`是运行脚本。
+`telegraf`子文件夹里是telegraf的配置文件。
+## 启动Docker镜像
+启动前，请确保系统里没有运行TDengine和Grafana，以及Telegraf和Prometheus，因为这些程序会占用docker所需的端口，造成脚本运行失败，建议先关闭这些程序。
+然后，只用在minidevops路径下执行
+```sh
+sudo run.sh
+```
+我们来看看`run.sh`里干了些什么：
+```sh
+#!/bin/bash
+ 
+LP=`pwd`
+ 
+#为了让脚本能够顺利执行，避免重复执行时出现错误， 首先将系统里所有docker容器停止了。请注意，如果该linux上已经运行了其他docker容器，也会被停止掉。
+docker rm -f `docker ps -a -q`
+ 
+#专门创建一个叫minidevops的虚拟网络，并指定了172.15.1.1~255这个地址段。
+docker network create --ip-range 172.15.1.255/24 --subnet 172.15.1.1/16 minidevops
+ 
+#启动grafana程序，并将tdengine插件文件所在路径绑定到容器中
+docker run -d --net minidevops --ip 172.15.1.11 -v $LP/grafana:/var/lib/grafana/plugins -p 3000:3000 grafana/grafana
+ 
+#启动tdengine的docker容器，并指定IP地址为172.15.1.6，绑定需要的端口
+docker run -d --net minidevops --ip 172.15.1.6 -p 6030:6030 -p 6020:6020 -p 6031:6031 -p 6032:6032 -p 6033:6033 -p 6034:6034 -p 6035:6035 -p 6036:6036 -p 6037:6037 -p 6038:6038 -p 6039:6039 tdengine/tdengine:1.6.4.5
+ 
+#启动prometheus的写入代理程序，这个程序可以将prometheus发来的数据直接写入TDengine中，无需提前建立相关超级表和表，实现schemaless写入功能
+docker run -d --net minidevops --ip 172.15.1.7 -p 10203:10203 tdengine/blm_prometheus 172.15.1.6
+ 
+#启动telegraf的写入代理程序，这个程序可以将telegraf发来的数据直接写入TDengine中，无需提前建立相关超级表和表，实现schemaless写入功能
+docker run -d --net minidevops --ip 172.15.1.8 -p 10202:10202 tdengine/blm_telegraf 172.15.1.6
+ 
+#启动prometheus程序，并将配置文件所在路径绑定到容器中
+docker run -d  --net minidevops --ip 172.15.1.9 -v $LP/prometheus:/etc/prometheus -p 9090:9090 prom/prometheus
+ 
+#启动telegraf程序，并将配置文件所在路径绑定到容器中
+docker run -d --net minidevops --ip 172.15.1.10 -v $LP/telegraf:/etc/telegraf -p 8092:8092 -p 8094:8094 -p 8125:8125 telegraf
+ 
+#通过Grafana的API，将TDengine配置成Grafana的datasources
+curl -X POST http://localhost:3000/api/datasources --header "Content-Type:application/json" -u admin:admin -d '{"Name": "TDengine","Type": "tdengine","TypeLogoUrl": "public/plugins/tdengine/img/taosdata_logo.png","Access": "proxy","Url": "http://172.15.1.6:6020","BasicAuth": false,"isDefault": true,"jsonData": {},"readOnly": false}'
+ 
+#通过Grafana的API，配置一个示范的监控面板
+curl -X POST http://localhost:3000/api/dashboards/db --header "Content-Type:application/json" -u admin:admin -d '{"dashboard":{"annotations":{"list":[{"builtIn":1,"datasource":"-- Grafana --","enable":true,"hide":true,"iconColor":"rgba(0, 211, 255, 1)","name":"Annotations & Alerts","type":"dashboard"}]},"editable":true,"gnetId":null,"graphTooltip":0,"id":1,"links":[],"panels":[{"datasource":null,"gridPos":{"h":8,"w":6,"x":0,"y":0},"id":6,"options":{"fieldOptions":{"calcs":["mean"],"defaults":{"color":{"mode":"thresholds"},"links":[{"title":"","url":""}],"mappings":[],"max":100,"min":0,"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null},{"color":"red","value":80}]},"unit":"percent"},"overrides":[],"values":false},"orientation":"auto","showThresholdLabels":false,"showThresholdMarkers":true},"pluginVersion":"6.6.0","targets":[{"refId":"A","sql":"select last_row(value) from telegraf.mem where field=\"used_percent\""}],"timeFrom":null,"timeShift":null,"title":"Memory used percent","type":"gauge"},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"fillGradient":0,"gridPos":{"h":8,"w":12,"x":6,"y":0},"hiddenSeries":false,"id":8,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"MEMUSED-PERCENT","refId":"A","sql":"select avg(value) from telegraf.mem where field=\"used_percent\" interval(1m)"}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"Panel Title","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}},{"datasource":null,"gridPos":{"h":9,"w":6,"x":0,"y":8},"id":10,"options":{"fieldOptions":{"calcs":["mean"],"defaults":{"mappings":[],"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null}]},"unit":"percent"},"overrides":[],"values":false},"orientation":"auto","showThresholdLabels":false,"showThresholdMarkers":true},"pluginVersion":"6.6.0","targets":[{"alias":"CPU-SYS","refId":"A","sql":"select last_row(value) from telegraf.cpu where field=\"usage_system\""},{"alias":"CPU-IDLE","refId":"B","sql":"select last_row(value) from telegraf.cpu where field=\"usage_idle\""},{"alias":"CPU-USER","refId":"C","sql":"select last_row(value) from telegraf.cpu where field=\"usage_user\""}],"timeFrom":null,"timeShift":null,"title":"Panel Title","type":"gauge"},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"TDengine","description":"General CPU monitor","fill":1,"fillGradient":0,"gridPos":{"h":9,"w":12,"x":6,"y":8},"hiddenSeries":false,"id":2,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"CPU-USER","refId":"A","sql":"select avg(value) from telegraf.cpu where field=\"usage_user\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-SYS","refId":"B","sql":"select avg(value) from telegraf.cpu where field=\"usage_system\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-IDLE","refId":"C","sql":"select avg(value) from telegraf.cpu where field=\"usage_idle\" and cpu=\"cpu-total\" interval(1m)"}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"CPU","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}}],"refresh":"10s","schemaVersion":22,"style":"dark","tags":["demo"],"templating":{"list":[]},"time":{"from":"now-3h","to":"now"},"timepicker":{"refresh_intervals":["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]},"timezone":"","title":"TDengineDashboardDemo","id":null,"uid":null,"version":0}}'
+```
+执行以上脚本后，可以通过docker container ls命令来确认容器运行的状态：
+```sh
+$docker container ls
+CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS              PORTS                                                                                        NAMES
+f875bd7d90d1        telegraf                    "/entrypoint.sh tele…"   6 hours ago         Up 6 hours          0.0.0.0:8092->8092/tcp, 8092/udp, 0.0.0.0:8094->8094/tcp, 8125/udp, 0.0.0.0:8125->8125/tcp   wonderful_antonelli
+38ee2d5c3cb3        prom/prometheus             "/bin/prometheus --c…"   6 hours ago         Up 6 hours          0.0.0.0:9090->9090/tcp                                                                       infallible_mestorf
+1a1939386c07        tdengine/blm_telegraf       "/root/blm_telegraf …"   6 hours ago         Up 6 hours          0.0.0.0:10202->10202/tcp                                                                     stupefied_hypatia
+7063eb05caa4        tdengine/blm_prometheus     "/root/blm_prometheu…"   6 hours ago         Up 6 hours          0.0.0.0:10203->10203/tcp                                                                     jovial_feynman
+4a7b27931d21        tdengine/tdengine:1.6.4.5   "taosd"                  6 hours ago         Up 6 hours          0.0.0.0:6020->6020/tcp, 0.0.0.0:6030-6039->6030-6039/tcp, 6040-6050/tcp                      eager_kowalevski
+ad2895760bc0        grafana/grafana             "/run.sh"                6 hours ago         Up 6 hours          0.0.0.0:3000->3000/tcp                                                                       romantic_mccarthy
+```
+当以上几个容器都已正常运行后，则我们的demo小系统已经开始工作了。
+## Grafana中进行配置
+打开浏览器，在地址栏输入服务器所在的IP地址
+`http://localhost:3000`
+就可以访问到grafana的页面，如果不在本机打开浏览器，则将localhost改成server的ip地址即可。
+进入登录页面，用户名和密码都是缺省的admin，输入后，即可进入grafana的控制台输入用户名/密码后，会进入修改密码页面，选择skip，跳过这一步。进入Grafana后，可以在页面的左下角看到TDengineDashboardDemo已经创建好了，![](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-2-1_22-50-58-1024x465.png)对于有些浏览器打开时，可能会在home页面中没有TDengineDashboardDemo的选项，可以通过在Dashboard->Manage中选择![](https://www.taosdata.com/blog/wp-content/uploads/2020/02/2-1024x553.png)TDengineDashboardDemo。点击TDengineDashboardDemo进入示例监控面板。刚点进去页面时，监控曲线是空白的，因为监控数据还不够多，需要等待一段时间，让数据采集程序采集更多的数据。![](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image-5-1024x853.png)
+
+如上两个监控面板分别监控了CPU和内存占用率。点击面板上的标题可以选择Edit进入编辑界面，新增监控数据。关于Grafana的监控面板设置，可以详细参考Grafana官网文档[Getting Started](https://grafana.com/docs/grafana/latest/guides/getting_started/)。
+
+## 原理介绍
+按上面的操作，我们已经将监控系统搭建起来了，目前可以监控系统的CPU占有率了。下面介绍下这个Demo系统的工作原理。
+如下图所示，这个系统由数据采集功能（prometheus，telegraf），时序数据库功能（TDengine和适配程序），可视化功能(Grafana)组成。下面虚线框里的TDengine，blm_prometheus, blm_telegraf三个容器组成了一个schemaless写入的时序数据库，对于采用telegraf和prometheus作为采集程序的监控对象，可以直接将数据写入TDengine，并通过grafana进行可视化呈现。
+![architecture](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-1-29_21-22-6.png)
+### 数据采集
+数据采集由Telegraf和Prometheus完成。Telegraf根据配置，从操作系统层面采集系统的相关统计值，并按配置上报给指定的URL，上报的数据json格式为
+```json
+{
+    "fields":{
+    "usage_guest":0,
+    "usage_guest_nice":0,
+    "usage_idle":87.73726273726274,
+    "usage_iowait":0,
+    "usage_irq":0,
+    "usage_nice":0,
+    "usage_softirq":0,
+    "usage_steal":0,
+    "usage_system":2.6973026973026974,
+    "usage_user":9.565434565434565
+    },
+    "name":"cpu",
+    "tags":{
+        "cpu":"cpu-total",
+        "host":"liutaodeMacBook-Pro.local"
+        },
+    "timestamp":1571665100
+}
+```
+其中name将被作为超级表的表名，tags作为普通表的tags，fields的名称也会作为一个tag用来描述普通表的标签。举个例子，一个普通表的结构如下，这是一个存储usage_softirq数据的普通表。
+![表结构](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-1-29_21-38-24.png)
+
+### Telegraf的配置
+对于使用telegraf作为数据采集程序的监控对象，可以在telegraf的配置文件telegraf.conf中将outputs.http部分的配置按以下配置修改，就可以直接将数据写入TDengine中了
+```toml
+[[outputs.http]]
+#   ## URL is the address to send metrics to
+url = "http://172.15.1.8:10202/telegraf"
+#
+#   ## HTTP Basic Auth credentials
+#   # username = "username"
+#   # password = "pa$$word"
+#
+ 
+data_format = "json"
+json_timestamp_units = "1ms"
+```
+可以打开HTTP basic Auth验证机制，本Demo为了简化没有打开验证功能。
+对于多个被监控对象，只需要在telegraf.conf文件中都写上以上的配置内容，就可以将数据写入TDengine中了。
+
+### Telegraf数据在TDengine中的存储结构
+Telegraf的数据在TDengine中的存储，是以数据name为超级表名，以tags值加上监控对象的ip地址，以及field的属性名作为tag值，存入TDengine中的。
+以name为cpu的数据为例，telegraf产生的数据为:
+```json
+{
+    "fields":{
+    "usage_guest":0,
+    "usage_guest_nice":0,
+    "usage_idle":87.73726273726274,
+    "usage_iowait":0,
+    "usage_irq":0,
+    "usage_nice":0,
+    "usage_softirq":0,
+    "usage_steal":0,
+    "usage_system":2.6973026973026974,
+    "usage_user":9.565434565434565
+    },
+    "name":"cpu",
+    "tags":{
+        "cpu":"cpu-total",
+        "host":"liutaodeMacBook-Pro.local"
+        },
+    "timestamp":1571665100
+}
+```
+则写入TDengine时会自动存入一个名为cpu的超级表中，这个表的结构如下
+![telegraf表结构](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-2-2_0-37-49.png)
+这个超级表的tag字段有cpu,host,srcip,field；其中cpu，host是原始数据携带的tag，而srcip是监控对象的IP地址，field是监控对象cpu类型数据中的fields属性，取值空间为[usage_guest,usage_guest_nice,usage_idle,usage_iowait,usage_irq,usage_nice,usage_softirq,usage_steal,usage_system,usage_user]，每个field值对应着一个具体含义的数据。
+
+因此，在查询的时候，可以用这些tag来过滤数据，也可以用超级表来聚合数据。
+### Prometheus的配置
+对于使用Prometheus作为数据采集程序的监控对象，可以在Prometheus的配置文件prometheus.yaml文件中，将remote write部分的配置按以下配置修改，就可以直接将数据写入TDengine中了。
+```yaml
+remote_write:
+  - url: "http://172.15.1.7:10203/receive"
+```
+对于多个被监控对象，只需要在每个被监控对象的prometheus配置中增加以上配置内容，就可以将数据写入TDengine中了。
+### Prometheus数据在TDengine中的存储结构
+Prometheus的数据在TDengine中的存储，与telegraf类似，也是以数据的name字段为超级表名，以数据的label作为tag值，存入TDengine中
+以prometheus_engine_queries这个数据为例[prom表结构](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-2-2_0-51-4.png)
+在TDengine中会自动创建一个prometheus_engine_queries的超级表，tag字段为t_instance，t_job，t_monitor。
+查询时，可以用这些tag来过滤数据，也可以用超级表来聚合数据。
+
+## 数据查询
+我们可以登陆到TDengine的客户端命令，通过命令行看看TDengine里面都存储了些什么数据，顺便也能体验一下TDengine的高性能查询。如何才能登陆到TDengine的客户端，我们可以通过以下几步来完成。
+首先通过下面的命令查询一下tdengine的Docker ID
+```sh
+docker container ls
+```
+然后再执行
+```sh
+docker exec -it tdengine的containerID bash
+```
+就可以进入TDengine容器的命令行，执行taos，就进入以下界面![](https://www.taosdata.com/blog/wp-content/uploads/2020/02/image2020-1-29_21-55-53.png)
+Telegraf的数据写入时，自动创建了一个名为telegraf的database，可以通过
+```
+use telegraf；
+```
+使用telegraf这个数据库。然后执行show tables，describe table等命令详细查询下telegraf这个库里保存了些什么数据。
+具体TDengine的查询语句可以参考[TDengine官方文档](https://www.taosdata.com/cn/documentation/taos-sql/)
+## 接入多个监控对象
+就像前面原理介绍的，这个miniDevops的小系统，已经提供了一个时序数据库和可视化系统，对于多台机器的监控，只需要将每台机器的telegraf或prometheus配置按上面所述修改，就可以完成监控数据采集和可视化呈现了。

minidevops/demodashboard.json

+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": 1,
+  "links": [],
+  "panels": [
+    {
+      "datasource": null,
+      "gridPos": {
+        "h": 8,
+        "w": 6,
+        "x": 0,
+        "y": 0
+      },
+      "id": 6,
+      "options": {
+        "fieldOptions": {
+          "calcs": [
+            "mean"
+          ],
+          "defaults": {
+            "color": {
+              "mode": "thresholds"
+            },
+            "links": [
+              {
+                "title": "",
+                "url": ""
+              }
+            ],
+            "mappings": [],
+            "max": 100,
+            "min": 0,
+            "thresholds": {
+              "mode": "absolute",
+              "steps": [
+                {
+                  "color": "green",
+                  "value": null
+                },
+                {
+                  "color": "red",
+                  "value": 80
+                }
+              ]
+            },
+            "unit": "percent"
+          },
+          "overrides": [],
+          "values": false
+        },
+        "orientation": "auto",
+        "showThresholdLabels": false,
+        "showThresholdMarkers": true
+      },
+      "pluginVersion": "6.6.0",
+      "targets": [
+        {
+          "refId": "A",
+          "sql": "select last_row(value) from telegraf.mem where field=\"used_percent\""
+        }
+      ],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Memory used percent",
+      "type": "gauge"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 6,
+        "y": 0
+      },
+      "hiddenSeries": false,
+      "id": 8,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "alias": "MEMUSED-PERCENT",
+          "refId": "A",
+          "sql": "select avg(value) from telegraf.mem where field=\"used_percent\" interval(1m)"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "MEM",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "datasource": null,
+      "gridPos": {
+        "h": 3,
+        "w": 18,
+        "x": 0,
+        "y": 8
+      },
+      "id": 10,
+      "options": {
+        "displayMode": "lcd",
+        "fieldOptions": {
+          "calcs": [
+            "mean"
+          ],
+          "defaults": {
+            "mappings": [],
+            "thresholds": {
+              "mode": "absolute",
+              "steps": [
+                {
+                  "color": "green",
+                  "value": null
+                }
+              ]
+            },
+            "unit": "percent"
+          },
+          "overrides": [],
+          "values": false
+        },
+        "orientation": "auto",
+        "showUnfilled": true
+      },
+      "pluginVersion": "6.6.0",
+      "targets": [
+        {
+          "alias": "CPU-SYS",
+          "refId": "A",
+          "sql": "select last_row(value) from telegraf.cpu where field=\"usage_system\""
+        },
+        {
+          "alias": "CPU-IDLE",
+          "refId": "B",
+          "sql": "select last_row(value) from telegraf.cpu where field=\"usage_idle\""
+        },
+        {
+          "alias": "CPU-USER",
+          "refId": "C",
+          "sql": "select last_row(value) from telegraf.cpu where field=\"usage_user\""
+        }
+      ],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "CPU-USED",
+      "type": "bargauge"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "TDengine",
+      "description": "General CPU monitor",
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 9,
+        "w": 18,
+        "x": 0,
+        "y": 11
+      },
+      "hiddenSeries": false,
+      "id": 2,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "alias": "CPU-USER",
+          "refId": "A",
+          "sql": "select avg(value) from telegraf.cpu where field=\"usage_user\" and cpu=\"cpu-total\" interval(1m)"
+        },
+        {
+          "alias": "CPU-SYS",
+          "refId": "B",
+          "sql": "select avg(value) from telegraf.cpu where field=\"usage_system\" and cpu=\"cpu-total\" interval(1m)"
+        },
+        {
+          "alias": "CPU-IDLE",
+          "refId": "C",
+          "sql": "select avg(value) from telegraf.cpu where field=\"usage_idle\" and cpu=\"cpu-total\" interval(1m)"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "CPU",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "refresh": "10s",
+  "schemaVersion": 22,
+  "style": "dark",
+  "tags": [
+    "demo"
+  ],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-3h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "",
+  "title": "TDengineDashboardDemo",
+  "uid": "2lF1wNUWz",
+  "version": 4
+}
\ No newline at end of file

minidevops/grafana/tdengine/README.md

+TDengine Datasource - build by Taosdata Inc. www.taosdata.com
+
+TDengine backend server implement 2 urls:
+
+ * `/heartbeat` return 200 ok. Used for "Test connection" on the datasource config page.
+ * `/query` return data based on input sqls.
+
+## Installation
+
+To install this plugin:
+Copy the data source you want to /var/lib/grafana/plugins/. Then restart grafana-server. The new data source should now be available in the data source type dropdown in the Add Data Source View.
+
+```
+cp -r <tdengine-extrach-dir>/connector/grafana/tdengine /var/lib/grafana/plugins/
+sudo service grafana-server restart
+```
+
+### Query API
+
+Example request
+``` javascript
+[{
+	"refId": "A",
+	"alias": "taosd-memory",
+	"sql": "select avg(mem_taosd) from sys.dn where ts > now-5m and ts < now interval(500a)"
+},
+{
+	"refId": "B",
+	"alias": "system-memory",
+	"sql": "select avg(mem_system) from sys.dn where ts > now-5m and ts < now interval(500a)"
+}]
+```
+
+Example response
+``` javascript
+[{
+	"datapoints": [
+		[206.488281, 1538137825000],
+		[206.488281, 1538137855000],
+		[206.488281, 1538137885500],
+		[210.609375, 1538137915500],
+		[210.867188, 1538137945500]
+	],
+	"refId": "A",
+	"target": "taosd-memory"
+},
+{
+	"datapoints": [
+		[2910.218750, 1538137825000],
+		[2912.265625, 1538137855000],
+		[2912.437500, 1538137885500],
+		[2916.644531, 1538137915500],
+		[2917.066406, 1538137945500]
+	],
+	"refId": "B",
+	"target": "system-memory"
+}]
+```
+
+### Heartbeat API
+
+Example request
+``` javascript
+<null> get request
+```
+
+Example response
+``` javascript   
+{
+	"message": "Grafana server receive a quest from you!"
+}
+```

minidevops/grafana/tdengine/css/query-editor.css

+.generic-datasource-query-row .query-keyword {
+  width: 75px;
+}
\ No newline at end of file

minidevops/grafana/tdengine/datasource.js

+'use strict';
+
+System.register(['lodash'], function (_export, _context) {
+  "use strict";
+  var _, _createClass, GenericDatasource;
+  
+  function strTrim(str) {
+     return str.replace(/^\s+|\s+$/gm,'');
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  return {
+    setters: [function (_lodash) {
+      _ = _lodash.default;
+    }],
+    execute: function () {
+      _createClass = function () {
+        function defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+          if (protoProps) defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) defineProperties(Constructor, staticProps);
+          return Constructor;
+        };
+      }();
+
+      _export('GenericDatasource', GenericDatasource = function () {
+        function GenericDatasource(instanceSettings, $q, backendSrv, templateSrv) {
+          _classCallCheck(this, GenericDatasource);
+          
+          this.type = instanceSettings.type;
+          this.url = instanceSettings.url;
+          this.name = instanceSettings.name;
+          this.q = $q;
+          this.backendSrv = backendSrv;
+          this.templateSrv = templateSrv;
+          //this.withCredentials = instanceSettings.withCredentials;
+          this.headers = { 'Content-Type': 'application/json' };
+          var taosuser = instanceSettings.jsonData.user;
+          var taospwd = instanceSettings.jsonData.password;
+          if (taosuser == null || taosuser == undefined || taosuser == "") {
+            taosuser = "root";
+          }
+          if (taospwd == null || taospwd == undefined || taospwd == "") {
+            taospwd = "taosdata";
+          }
+
+          this.headers.Authorization = "Basic " + this.encode(taosuser + ":" + taospwd);
+        }
+
+        _createClass(GenericDatasource, [{
+          key: 'encode',
+          value: function encode(input) {
+            var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";  
+            var output = "";  
+            var chr1, chr2, chr3, enc1, enc2, enc3, enc4;  
+            var i = 0;        
+            while (i < input.length) {  
+              chr1 = input.charCodeAt(i++);  
+              chr2 = input.charCodeAt(i++);  
+              chr3 = input.charCodeAt(i++);  
+              enc1 = chr1 >> 2;  
+              enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);  
+              enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);  
+              enc4 = chr3 & 63;  
+              if (isNaN(chr2)) {  
+                enc3 = enc4 = 64;  
+              } else if (isNaN(chr3)) {  
+                enc4 = 64;  
+              }  
+              output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);  
+            }  
+            
+            return output;
+          }
+        }, {
+          key: 'generateSql',
+          value: function generateSql(sql, queryStart, queryEnd, intervalMs) {
+            if (queryStart == undefined || queryStart == null) {
+                queryStart = "now-1h";
+            }
+            if (queryEnd == undefined || queryEnd == null) {
+                queryEnd = "now";
+            }
+            if (intervalMs == undefined || intervalMs == null) {
+                intervalMs = "20000";
+            }
+            
+            intervalMs += "a";
+            sql = sql.replace(/^\s+|\s+$/gm, '');
+            sql = sql.replace("$from", "'" + queryStart + "'");
+            sql = sql.replace("$begin", "'" + queryStart + "'");
+            sql = sql.replace("$to", "'" + queryEnd + "'");
+            sql = sql.replace("$end", "'" + queryEnd + "'");
+            sql = sql.replace("$interval", intervalMs);
+            
+            return sql;
+          }
+        }, {
+          key: 'query',
+          value: function query(options) {
+            var querys = new Array;
+            for (var i = 0; i < options.targets.length; ++i) {
+                var query = new Object;
+                
+                query.refId = options.targets[i].refId;
+                query.alias = options.targets[i].alias;
+                if (query.alias == null || query.alias == undefined) {
+                    query.alias = "";
+                }
+                
+                //query.sql = this.generateSql(options.targets[i].sql, options.range.raw.from, options.range.raw.to, options.intervalMs);
+                query.sql = this.generateSql(options.targets[i].sql, options.range.from.toISOString(), options.range.to.toISOString(), options.intervalMs);
+                console.log(query.sql);
+                
+                querys.push(query);
+            }
+            
+            if (querys.length <= 0) {
+              return this.q.when({ data: [] });
+            }
+
+            return this.doRequest({
+              url: this.url + '/grafana/query',
+              data: querys,
+              method: 'POST'
+            });
+          }
+        }, {
+          key: 'testDatasource',
+          value: function testDatasource() {
+            return this.doRequest({
+              url: this.url + '/grafana/heartbeat',
+              method: 'GET'
+            }).then(function (response) {
+              if (response.status === 200) {
+                return { status: "success", message: "TDengine Data source is working", title: "Success" };
+              }
+            });
+          }
+        }, {
+          key: 'doRequest',
+          value: function doRequest(options) {
+            options.headers = this.headers;
+            //console.log(options);
+            return this.backendSrv.datasourceRequest(options);
+          }
+        }]);
+
+        return GenericDatasource;
+      }());
+
+      _export('GenericDatasource', GenericDatasource);
+    }
+  };
+});
+//# sourceMappingURL=datasource.js.map

minidevops/grafana/tdengine/module.js

+'use strict';
+
+System.register(['./datasource', './query_ctrl'], function (_export, _context) {
+  "use strict";
+
+  var GenericDatasource, GenericDatasourceQueryCtrl, GenericConfigCtrl, GenericQueryOptionsCtrl, GenericAnnotationsQueryCtrl;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  return {
+    setters: [function (_datasource) {
+      GenericDatasource = _datasource.GenericDatasource;
+    }, function (_query_ctrl) {
+      GenericDatasourceQueryCtrl = _query_ctrl.GenericDatasourceQueryCtrl;
+    }],
+    execute: function () {
+      _export('ConfigCtrl', GenericConfigCtrl = function GenericConfigCtrl() {
+        _classCallCheck(this, GenericConfigCtrl);
+      });
+
+      GenericConfigCtrl.templateUrl = 'partials/config.html';
+
+      _export('QueryOptionsCtrl', GenericQueryOptionsCtrl = function GenericQueryOptionsCtrl() {
+        _classCallCheck(this, GenericQueryOptionsCtrl);
+      });
+
+      GenericQueryOptionsCtrl.templateUrl = 'partials/query.options.html';
+
+      _export('AnnotationsQueryCtrl', GenericAnnotationsQueryCtrl = function GenericAnnotationsQueryCtrl() {
+        _classCallCheck(this, GenericAnnotationsQueryCtrl);
+      });
+
+      GenericAnnotationsQueryCtrl.templateUrl = 'partials/annotations.editor.html';
+
+      _export('Datasource', GenericDatasource);
+
+      _export('QueryCtrl', GenericDatasourceQueryCtrl);
+
+      _export('ConfigCtrl', GenericConfigCtrl);
+
+      _export('QueryOptionsCtrl', GenericQueryOptionsCtrl);
+
+      _export('AnnotationsQueryCtrl', GenericAnnotationsQueryCtrl);
+    }
+  };
+});
+//# sourceMappingURL=module.js.map

minidevops/grafana/tdengine/partials/config.html

+<h3 class="page-heading">TDengine Connection</h3>
+
+<div class="gf-form-group">
+	<div class="gf-form max-width-30">
+		<span class="gf-form-label width-7">Host</span>
+		<input type="text" class="gf-form-input" ng-model='ctrl.current.url' placeholder="http://localhost:6020" bs-typeahead="{{['http://localhost:6020']}}" required></input>
+	</div>
+
+	<div class="gf-form-inline">
+		<div class="gf-form max-width-15">
+			<span class="gf-form-label width-7">User</span>
+			<input type="text" class="gf-form-input" ng-model='ctrl.current.jsonData.user' placeholder="root"></input>
+		</div>
+		<div class="gf-form max-width-15">
+			<span class="gf-form-label width-7">Password</span>
+			<input type="password" class="gf-form-input" ng-model='ctrl.current.jsonData.password' placeholder="taosdata"></input>
+		</div>
+	</div>
+</div>
\ No newline at end of file

minidevops/grafana/tdengine/partials/query.editor.html

+<query-editor-row query-ctrl="ctrl" can-collapse="true" >
+
+  <div class="gf-form-inline">  
+    <div class="gf-form gf-form--grow">
+      <label class="gf-form-label query-keyword width-7">INPUT SQL</label>
+      <input type="text" class="gf-form-input" ng-model="ctrl.target.sql" spellcheck='false' placeholder="select count(*) from sys.cpu where ts >= $from and ts < $to interval($interval)" ng-blur="ctrl.panelCtrl.refresh()" data-mode="sql"></input>        
+    </div>   
+  </div>
+  
+  <div class="gf-form-inline">
+    <div class="gf-form-inline"  ng-hide="ctrl.target.resultFormat === 'table'">
+      <div class="gf-form max-width-30">
+        <label class="gf-form-label query-keyword width-7">ALIAS BY</label>
+        <input type="text" class="gf-form-input" ng-model="ctrl.target.alias" spellcheck='false' placeholder="Naming pattern" ng-blur="ctrl.panelCtrl.refresh()">
+      </div>
+    </div>    
+    <div class="gf-form">
+      <label class="gf-form-label query-keyword" ng-click="ctrl.generateSQL()">
+        GENERATE SQL
+        <i class="fa fa-caret-down" ng-show="ctrl.showGenerateSQL"></i>
+        <i class="fa fa-caret-right" ng-hide="ctrl.showGenerateSQL"></i>
+      </label>
+    </div>
+    <div class="gf-form">
+      <label class="gf-form-label query-keyword" ng-click="ctrl.showHelp = !ctrl.showHelp">
+        SHOW HELP
+        <i class="fa fa-caret-down" ng-show="ctrl.showHelp"></i>
+        <i class="fa fa-caret-right" ng-hide="ctrl.showHelp"></i>
+      </label>
+    </div>        
+  </div>
+  
+  <div class="gf-form" ng-show="ctrl.showGenerateSQL">
+    <pre class="gf-form-pre">{{ctrl.lastGenerateSQL}}</pre>
+  </div>
+
+  <div class="gf-form"  ng-show="ctrl.showHelp">
+    <pre class="gf-form-pre alert alert-info">Use any SQL that can return Resultset such as:
+- [[timestamp1, value1], [timestamp2, value2], ... ]
+
+Macros:
+- $from -&gt; start timestamp of panel
+- $to -&gt; stop timestamp of panel
+- $interval -&gt; interval of panel
+
+Example of SQL:
+&nbsp;&nbsp;SELECT count(*)
+&nbsp;&nbsp;FROM db.table
+&nbsp;&nbsp;WHERE ts > $from and ts < $to
+&nbsp;&nbsp;INTERVAL ($interval)
+    </pre>
+  </div>
+
+  <div class="gf-form" ng-show="ctrl.lastQueryError">
+    <pre class="gf-form-pre alert alert-error">{{ctrl.lastQueryError}}</pre>
+  </div>
+  
+</query-editor-row>

minidevops/grafana/tdengine/plugin.json

+{
+  "name": "TDengine",
+  "id": "tdengine",
+  "type": "datasource",
+
+  "partials": {
+    "config": "partials/config.html"
+  },
+
+  "metrics": true,
+  "annotations": false,
+  "alerting": true,
+
+  "info": {
+    "description": "TDengine datasource",
+    "author": {
+      "name": "Taosdata Inc.",
+      "url": "https://www.taosdata.com"
+    },
+    "logos": {
+      "small": "img/taosdata_logo.png",
+      "large": "img/taosdata_logo.png"
+    },
+    "version": "1.6.0",
+    "updated": "2019-07-01"
+  },
+
+  "dependencies": {
+    "grafanaVersion": "5.2.4",
+    "plugins": [ ]
+  }
+}

minidevops/grafana/tdengine/query_ctrl.js

+'use strict';
+
+System.register(['app/plugins/sdk'], function (_export, _context) {
+  "use strict";
+
+  var QueryCtrl, _createClass, GenericDatasourceQueryCtrl;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _possibleConstructorReturn(self, call) {
+    if (!self) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return call && (typeof call === "object" || typeof call === "function") ? call : self;
+  }
+
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+  }
+
+  return {
+    setters: [function (_appPluginsSdk) {
+      QueryCtrl = _appPluginsSdk.QueryCtrl;
+    }, function (_cssQueryEditorCss) {}],
+    execute: function () {
+      _createClass = function () {
+        function defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+          if (protoProps) defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) defineProperties(Constructor, staticProps);
+          return Constructor;
+        };
+      }();
+
+      _export('GenericDatasourceQueryCtrl', GenericDatasourceQueryCtrl = function (_QueryCtrl) {
+        _inherits(GenericDatasourceQueryCtrl, _QueryCtrl);
+
+        function GenericDatasourceQueryCtrl($scope, $injector) {
+          _classCallCheck(this, GenericDatasourceQueryCtrl);
+
+          var _this = _possibleConstructorReturn(this, (GenericDatasourceQueryCtrl.__proto__ || Object.getPrototypeOf(GenericDatasourceQueryCtrl)).call(this, $scope, $injector));
+
+          _this.scope = $scope;
+          return _this;
+        }
+
+        _createClass(GenericDatasourceQueryCtrl, [{
+          key: 'generateSQL',
+          value: function generateSQL(query) {
+            //this.lastGenerateSQL = this.datasource.generateSql(this.target.sql, this.panelCtrl.range.raw.from, this.panelCtrl.range.raw.to, this.panelCtrl.intervalMs);
+            this.lastGenerateSQL = this.datasource.generateSql(this.target.sql, this.panelCtrl.range.from.toISOString(), this.panelCtrl.range.to.toISOString(), this.panelCtrl.intervalMs);
+            this.showGenerateSQL = !this.showGenerateSQL;
+          }
+        }]);
+
+        return GenericDatasourceQueryCtrl;
+      }(QueryCtrl));
+
+      _export('GenericDatasourceQueryCtrl', GenericDatasourceQueryCtrl);
+
+      GenericDatasourceQueryCtrl.templateUrl = 'partials/query.editor.html';
+    }
+  };
+});
+//# sourceMappingURL=query_ctrl.js.map

minidevops/prometheus/prometheus.yml

+global:
+  scrape_interval:     15s # By default, scrape targets every 15 seconds.
+
+  # Attach these labels to any time series or alerts when communicating with
+  # external systems (federation, remote storage, Alertmanager).
+  external_labels:
+    monitor: 'codelab-monitor'
+
+remote_write:
+  - url: "http://172.15.1.7:10203/receive" 
+
+# A scrape configuration containing exactly one endpoint to scrape:
+# Here it's Prometheus itself.
+scrape_configs:
+  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+  - job_name: 'prometheus'
+
+    # Override the global default and scrape targets from this job every 5 seconds.
+    scrape_interval: 5s
+
+    static_configs:
+      - targets: ['localhost:9090']
+
+  # - job_name: 'example-random'
+
+  #   # Override the global default and scrape targets from this job every 5 seconds.
+  #   scrape_interval: 5s
+
+  #   static_configs:
+  #     - targets: ['172.17.0.6:8080', '172.17.0.6:8081']
+  #       labels:
+  #         group: 'production'
+
+  #     - targets: ['172.17.0.6:8082']
+  #       labels:
+  #         group: 'canary'

minidevops/run.sh

+#!/bin/bash
+
+#set -x
+LP=`pwd`
+#echo $LP
+
+docker rm -f `docker ps -a -q`
+docker network rm minidevops
+docker network create --ip-range 172.15.1.255/24 --subnet 172.15.1.1/16 minidevops 
+
+#docker run -d   --net="host"   --pid="host"   -v "/:/host:ro"   quay.io/prometheus/node-exporter   --path.rootfs=/host
+
+docker run -d --net minidevops --ip 172.15.1.11 -v $LP/grafana:/var/lib/grafana/plugins -p 3000:3000 grafana/grafana
+#docker run -d --net minidevops --ip 172.15.1.11 -v /Users/tom/Documents/minidevops/grafana:/var/lib/grafana/plugins -p 3000:3000 grafana/grafana
+
+TDENGINE=`docker run -d --net minidevops --ip 172.15.1.6 -p 6030:6030 -p 6020:6020 -p 6031:6031 -p 6032:6032 -p 6033:6033 -p 6034:6034 -p 6035:6035 -p 6036:6036 -p 6037:6037 -p 6038:6038 -p 6039:6039 tdengine/tdengine:1.6.4.5` 
+docker cp /etc/localtime $TDENGINE:/etc/localtime
+
+BLMPROMETHEUS=`docker run -d --net minidevops --ip 172.15.1.7 -p 10203:10203 tdengine/blm_prometheus 172.15.1.6`
+
+
+BLMPTELEGRAF=`docker run -d --net minidevops --ip 172.15.1.8 -p 10202:10202 tdengine/blm_telegraf 172.15.1.6`
+
+docker run -d  --net minidevops --ip 172.15.1.9 -v $LP/prometheus:/etc/prometheus -p 9090:9090 prom/prometheus
+#docker run -d  --net minidevops --ip 172.15.1.9 -v /Users/tom/Documents/minidevops/prometheus:/etc/prometheus -p 9090:9090 prom/prometheus
+
+docker run -d --net minidevops --ip 172.15.1.10 -v $LP/telegraf:/etc/telegraf -p 8092:8092 -p 8094:8094 -p 8125:8125 telegraf
+#docker run -d --net minidevops --ip 172.15.1.10 -v /Users/tom/Documents/minidevops/telegraf:/etc/telegraf -p 8092:8092 -p 8094:8094 -p 8125:8125 telegraf
+
+
+sleep 10
+curl -X POST http://localhost:3000/api/datasources --header "Content-Type:application/json" -u admin:admin -d '{"Name": "TDengine","Type": "tdengine","TypeLogoUrl": "public/plugins/tdengine/img/taosdata_logo.png","Access": "proxy","Url": "http://172.15.1.6:6020","BasicAuth": false,"isDefault": true,"jsonData": {},"readOnly": false}'
+
+curl -X POST http://localhost:3000/api/dashboards/db --header "Content-Type:application/json" -u admin:admin -d '{"dashboard":{"annotations":{"list":[{"builtIn":1,"datasource":"-- Grafana --","enable":true,"hide":true,"iconColor":"rgba(0, 211, 255, 1)","name":"Annotations & Alerts","type":"dashboard"}]},"editable":true,"gnetId":null,"graphTooltip":0,"id":1,"links":[],"panels":[{"datasource":null,"gridPos":{"h":8,"w":6,"x":0,"y":0},"id":6,"options":{"fieldOptions":{"calcs":["mean"],"defaults":{"color":{"mode":"thresholds"},"links":[{"title":"","url":""}],"mappings":[],"max":100,"min":0,"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null},{"color":"red","value":80}]},"unit":"percent"},"overrides":[],"values":false},"orientation":"auto","showThresholdLabels":false,"showThresholdMarkers":true},"pluginVersion":"6.6.0","targets":[{"refId":"A","sql":"select last_row(value) from telegraf.mem where field=\"used_percent\""}],"timeFrom":null,"timeShift":null,"title":"Memory used percent","type":"gauge"},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":null,"fill":1,"fillGradient":0,"gridPos":{"h":8,"w":12,"x":6,"y":0},"hiddenSeries":false,"id":8,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"MEMUSED-PERCENT","refId":"A","sql":"select avg(value) from telegraf.mem where field=\"used_percent\" interval(1m)"}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"MEM","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}},{"datasource":null,"gridPos":{"h":3,"w":18,"x":0,"y":8},"id":10,"options":{"displayMode":"lcd","fieldOptions":{"calcs":["mean"],"defaults":{"mappings":[],"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null}]},"unit":"percent"},"overrides":[],"values":false},"orientation":"auto","showUnfilled":true},"pluginVersion":"6.6.0","targets":[{"alias":"CPU-SYS","refId":"A","sql":"select last_row(value) from telegraf.cpu where field=\"usage_system\""},{"alias":"CPU-IDLE","refId":"B","sql":"select last_row(value) from telegraf.cpu where field=\"usage_idle\""},{"alias":"CPU-USER","refId":"C","sql":"select last_row(value) from telegraf.cpu where field=\"usage_user\""}],"timeFrom":null,"timeShift":null,"title":"CPU-USED","type":"bargauge"},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"TDengine","description":"General CPU monitor","fill":1,"fillGradient":0,"gridPos":{"h":9,"w":18,"x":0,"y":11},"hiddenSeries":false,"id":2,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"CPU-USER","refId":"A","sql":"select avg(value) from telegraf.cpu where field=\"usage_user\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-SYS","refId":"B","sql":"select avg(value) from telegraf.cpu where field=\"usage_system\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-IDLE","refId":"C","sql":"select avg(value) from telegraf.cpu where field=\"usage_idle\" and cpu=\"cpu-total\" interval(1m)"}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"CPU","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}}],"refresh":"10s","schemaVersion":22,"style":"dark","tags":["demo"],"templating":{"list":[]},"time":{"from":"now-3h","to":"now"},"timepicker":{"refresh_intervals":["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]},"timezone":"","title":"TDengineDashboardDemo","id":null,"uid":null,"version":0}}'
+
+#curl -X POST http://localhost:3000/api/dashboards/db --header "Content-Type:application/json" -u admin:admin -d '{"dashboard":{"annotations":{"list":[{"builtIn":1,"datasource":"-- Grafana --","enable":true,"hide":true,"iconColor":"rgba(0, 211, 255, 1)","name":"Annotations & Alerts","type":"dashboard"}]},"editable":true,"gnetId":null,"graphTooltip":0,"id":3,"links":[],"panels":[{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"TDengine","description":"memory used percent","fill":1,"fillGradient":0,"gridPos":{"h":8,"w":12,"x":0,"y":0},"hiddenSeries":false,"id":4,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"memused-percent","refId":"A","sql":"select avg(value) from telegraf.mem where field=\"used_percent\" interval(1m)"},{"refId":"B","sql":""}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"MEM","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}},{"aliasColors":{},"bars":false,"dashLength":10,"dashes":false,"datasource":"TDengine","description":"General CPU monitor","fill":1,"fillGradient":0,"gridPos":{"h":9,"w":12,"x":0,"y":8},"hiddenSeries":false,"id":2,"legend":{"avg":false,"current":false,"max":false,"min":false,"show":true,"total":false,"values":false},"lines":true,"linewidth":1,"nullPointMode":"null","options":{"dataLinks":[]},"percentage":false,"pointradius":2,"points":false,"renderer":"flot","seriesOverrides":[],"spaceLength":10,"stack":false,"steppedLine":false,"targets":[{"alias":"CPU-USER","refId":"A","sql":"select avg(value) from telegraf.cpu where field=\"usage_user\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-SYS","refId":"B","sql":"select avg(value) from telegraf.cpu where field=\"usage_system\" and cpu=\"cpu-total\" interval(1m)"},{"alias":"CPU-IDLE","refId":"C","sql":"select avg(value) from telegraf.cpu where field=\"usage_idle\" and cpu=\"cpu-total\" interval(1m)"}],"thresholds":[],"timeFrom":null,"timeRegions":[],"timeShift":null,"title":"CPU","tooltip":{"shared":true,"sort":0,"value_type":"individual"},"type":"graph","xaxis":{"buckets":null,"mode":"time","name":null,"show":true,"values":[]},"yaxes":[{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true},{"format":"short","label":null,"logBase":1,"max":null,"min":null,"show":true}],"yaxis":{"align":false,"alignLevel":null}}],"refresh":"10s","schemaVersion":21,"style":"dark","tags":["demo"],"templating":{"list":[]},"time":{"from":"now-6h","to":"now"},"timepicker":{"refresh_intervals":["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]},"timezone":"","title":"TDengineDashboardDemo","id":null,"uid":null,"version":0}}'

packaging/cfg/taos.cfg

@@ -211,6 +211,12 @@
 # whether to enable HTTP compression transmission
 # httpEnableCompress    0
 
+# the delayed time for launching each continuous query. 10% of the whole computing time window by default.
+# streamCompDelayRatio  0.1
+
+# the max allowed delayed time for launching continuous query. 20ms by default
+# tsMaxStreamComputDelay  20000
+
 # whether the telegraf table name contains the number of tags and the number of fields
 # telegrafUseFieldNum   0
 

packaging/deb/makedeb.sh

@@ -2,7 +2,7 @@
 #
 # Generate deb package for ubuntu
 set -e
-#set -x
+# set -x
 
 #curr_dir=$(pwd)
 compile_dir=$1
@@ -73,7 +73,7 @@ sed -i "2c$debver" ${pkg_dir}/DEBIAN/control
 if [ "$verMode" == "cluster" ]; then
   debname="TDengine-server-"${tdengine_ver}-${osType}-${cpuType}
 elif [ "$verMode" == "lite" ]; then
-  debname="TDengine-server-edge"-${tdengine_ver}-${osType}-${cpuType}
+  debname="TDengine-server"-${tdengine_ver}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or lite"
   exit 1

packaging/docker/Dockerfile

+FROM centos:7
+
+WORKDIR /root
+
+COPY tdengine.tar.gz /root/
+RUN tar -zxf tdengine.tar.gz
+WORKDIR /root/tdengine/
+RUN sh install.sh
+
+
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib"
+ENV LANG=en_US.UTF-8
+ENV LANGUAGE=en_US:en
+ENV LC_ALL=en_US.UTF-8
+EXPOSE 6020 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042
+EXPOSE 6043 6044 6045 6046 6047 6048 6049 6050
+CMD ["taosd"]
+VOLUME [ "/var/lib/taos", "/var/log/taos","/etc/taos/" ]

packaging/docker/dockerbuild.sh

+#!/bin/bash
+set -x
+$1
+tar -zxf $1
+DIR=`echo $1|awk -F . '{print($1"."$2"."$3"."$4)}'`
+mv $DIR tdengine
+tar -czf tdengine.tar.gz tdengine
+TMP=`echo $1|awk -F . '{print($2"."$3"."$4)}'`
+TAG="1."$TMP
+docker build --rm -f "Dockerfile" -t tdengine/tdengine:$TAG "."
+docker login -u tdengine -p ********  #replace the docker registry username and password
+docker push tdengine/tdengine:$TAG
\ No newline at end of file

packaging/release.sh

@@ -3,7 +3,7 @@
 # Generate the deb package for ubunt, or rpm package for centos, or tar.gz package for other linux os
 
 set -e
-# set -x
+#set -x
 
 # releash.sh -v [cluster | lite]  -c [aarch32 | aarch64 | x64 | x86 | mips64 ...] -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | ...]  -V [stable | beta]
 
@@ -46,8 +46,17 @@ done
 echo "verMode=${verMode} verType=${verType} cpuType=${cpuType} osType=${osType}"
 
 curr_dir=$(pwd)
-script_dir="$(dirname $(readlink -f $0))"
-top_dir="$(readlink -f ${script_dir}/..)"
+
+if [ "$osType" != "Darwin" ]; then
+    script_dir="$(dirname $(readlink -f $0))"
+    top_dir="$(readlink -f ${script_dir}/..)"
+else
+    script_dir=`dirname $0`
+    cd ${script_dir}
+    script_dir="$(pwd)"
+    top_dir=${script_dir}/..
+fi
+
 versioninfo="${top_dir}/src/util/src/version.c"
 
 csudo=""
@@ -147,7 +156,14 @@ build_time=$(date +"%F %R")
 echo "char version[64] = \"${version}\";"                             > ${versioninfo}
 echo "char compatible_version[64] = \"${compatible_version}\";"      >> ${versioninfo}
 echo "char gitinfo[128] = \"$(git rev-parse --verify HEAD)\";"       >> ${versioninfo}
-echo "char gitinfoOfInternal[128] = \"\";"                           >> ${versioninfo}
+if [ "$verMode" != "cluster" ]; then
+  echo "char gitinfoOfInternal[128] = \"\";"                         >> ${versioninfo}
+else
+  enterprise_dir="${top_dir}/../enterprise"
+  cd ${enterprise_dir}
+  echo "char gitinfoOfInternal[128] = \"$(git rev-parse --verify HEAD)\";"  >> ${versioninfo}
+  cd ${curr_dir}
+fi
 echo "char buildinfo[512] = \"Built by ${USER} at ${build_time}\";"  >> ${versioninfo}
 echo ""                                                              >> ${versioninfo}
 tmp_version=$(echo $version | tr -s "." "_")
@@ -167,12 +183,20 @@ if [ -d ${compile_dir} ]; then
     ${csudo} rm -rf ${compile_dir}
 fi
 
-${csudo} mkdir -p ${compile_dir}
+if [ "$osType" != "Darwin" ]; then
+    ${csudo} mkdir -p ${compile_dir}
+else
+    mkdir -p ${compile_dir}
+fi
 cd ${compile_dir}
 
 # check support cpu type
 if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "mips64" ]] ; then
+    if [ "$verMode" != "cluster" ]; then
         cmake ../ -DCPUTYPE=${cpuType}
+    else
+	    cmake ../../ -DCPUTYPE=${cpuType}
+    fi
 else
     echo "input cpuType=${cpuType} error!!!"
     exit 1
@@ -187,28 +211,36 @@ cd ${curr_dir}
 #osinfo=$(cat /etc/os-release | grep "NAME" | cut -d '"' -f2)
 #echo "osinfo: ${osinfo}"
 
-echo "====do deb package for the ubuntu system===="
-output_dir="${top_dir}/debs"
-if [ -d ${output_dir} ]; then
+if [ "$osType" != "Darwin" ]; then
+    if [[ "$verMode" != "cluster" ]] && [[ "$cpuType" == "x64" ]]; then
+        echo "====do deb package for the ubuntu system===="
+        output_dir="${top_dir}/debs"
+        if [ -d ${output_dir} ]; then
             ${csudo} rm -rf ${output_dir}
-fi  
-${csudo} mkdir -p ${output_dir} 
-cd ${script_dir}/deb
-${csudo} ./makedeb.sh ${compile_dir} ${output_dir} ${version} ${cpuType} ${osType} ${verMode} ${verType}
+        fi
+        ${csudo} mkdir -p ${output_dir}
+        cd ${script_dir}/deb
+        ${csudo} ./makedeb.sh ${compile_dir} ${output_dir} ${version} ${cpuType} ${osType} ${verMode} ${verType}
 
-echo "====do rpm package for the centos system===="
-output_dir="${top_dir}/rpms"
-if [ -d ${output_dir} ]; then
+        echo "====do rpm package for the centos system===="
+        output_dir="${top_dir}/rpms"
+        if [ -d ${output_dir} ]; then
             ${csudo} rm -rf ${output_dir}
+        fi
+        ${csudo} mkdir -p ${output_dir}
+        cd ${script_dir}/rpm
+        ${csudo} ./makerpm.sh ${compile_dir} ${output_dir} ${version} ${cpuType} ${osType} ${verMode} ${verType}
+    fi
+	
+    echo "====do tar.gz package for all systems===="
+    cd ${script_dir}/tools
+    
+	${csudo} ./makepkg.sh    ${compile_dir} ${version} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType}
+	${csudo} ./makeclient.sh ${compile_dir} ${version} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType}
+else
+    cd ${script_dir}/tools
+    ./makeclient.sh ${compile_dir} ${version} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType}
 fi
-${csudo} mkdir -p ${output_dir}  
-cd ${script_dir}/rpm
-${csudo} ./makerpm.sh ${compile_dir} ${output_dir} ${version} ${cpuType} ${osType} ${verMode} ${verType}
-
-echo "====do tar.gz package for all systems===="  
-cd ${script_dir}/tools
-${csudo} ./makepkg.sh    ${compile_dir} ${version} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType}
-${csudo} ./makeclient.sh ${compile_dir} ${version} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType}
 
 # 4. Clean up temporary compile directories
 #${csudo} rm -rf ${compile_dir}

packaging/rpm/makerpm.sh

@@ -2,8 +2,8 @@
 #
 # Generate rpm package for centos 
 
-#set -e
-#set -x
+set -e
+# set -x
 
 #curr_dir=$(pwd)
 compile_dir=$1
@@ -66,7 +66,7 @@ cp_rpm_package ${pkg_dir}/RPMS
 if [ "$verMode" == "cluster" ]; then
   rpmname="TDengine-server-"${tdengine_ver}-${osType}-${cpuType}
 elif [ "$verMode" == "lite" ]; then
-  rpmname="TDengine-server-edge"-${tdengine_ver}-${osType}-${cpuType}
+  rpmname="TDengine-server"-${tdengine_ver}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or lite"
   exit 1

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/install.sh

@@ -6,6 +6,8 @@
 set -e
 #set -x
 
+verMode=lite
+
 # -----------------------Variables definition---------------------
 script_dir=$(dirname $(readlink -f "$0"))
 # Dynamic directory
@@ -27,7 +29,12 @@ install_main_dir="/usr/local/taos"
 # old bin dir
 bin_dir="/usr/local/taos/bin"
 
+# v1.5 jar dir
+v15_java_app_dir="/usr/local/lib/taos"
+
 service_config_dir="/etc/systemd/system"
+nginx_port=6060
+nginx_dir="/usr/local/nginxd"
 
 # Color setting
 RED='\033[0;31m'
@@ -41,6 +48,8 @@ if command -v sudo > /dev/null; then
     csudo="sudo"
 fi
 
+update_flag=0
+
 initd_mod=0
 service_mod=2
 if pidof systemd &> /dev/null; then
@@ -69,23 +78,24 @@ osinfo=$(cat /etc/os-release | grep "NAME" | cut -d '"' -f2)
 #echo "osinfo: ${osinfo}"
 os_type=0
 if echo $osinfo | grep -qwi "ubuntu" ; then
-  echo "this is ubuntu system"
+  echo "This is ubuntu system"
   os_type=1
 elif echo $osinfo | grep -qwi "debian" ; then
-  echo "this is debian system"
+  echo "This is debian system"
   os_type=1
 elif echo $osinfo | grep -qwi "Kylin" ; then
-  echo "this is Kylin system"
+  echo "This is Kylin system"
   os_type=1
 elif  echo $osinfo | grep -qwi "centos" ; then
-  echo "this is centos system"
+  echo "This is centos system"
   os_type=2
 elif echo $osinfo | grep -qwi "fedora" ; then
-  echo "this is fedora system"
+  echo "This is fedora system"
   os_type=2
 else
-  echo "this is other linux system"
-  os_type=0
+  echo "${osinfo}: This is an officially unverified linux system, If there are any problems with the installation and operation, "
+  echo "please feel free to contact taosdata.com for support."
+  os_type=1
 fi
 
 function kill_taosd() {
@@ -106,6 +116,9 @@ function install_main_path() {
     ${csudo} mkdir -p ${install_main_dir}/examples
     ${csudo} mkdir -p ${install_main_dir}/include
     ${csudo} mkdir -p ${install_main_dir}/init.d
+    if [ "$verMode" == "cluster" ]; then
+        ${csudo} mkdir -p ${nginx_dir}
+    fi
 }
 
 function install_bin() {
@@ -124,16 +137,30 @@ function install_bin() {
     [ -x ${install_main_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
     [ -x ${install_main_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
     [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos || :
+
+    if [ "$verMode" == "cluster" ]; then
+        ${csudo} cp -r ${script_dir}/nginxd/* ${nginx_dir} && ${csudo} chmod 0555 ${nginx_dir}/*
+        ${csudo} mkdir -p ${nginx_dir}/logs
+        ${csudo} chmod 777 ${nginx_dir}/sbin/nginx
+    fi
 }
 
 function install_lib() {
     # Remove links
     ${csudo} rm -f ${lib_link_dir}/libtaos.*         || :
+    ${csudo} rm -rf ${v15_java_app_dir}              || :
 
     ${csudo} cp -rf ${script_dir}/driver/* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*  
     
     ${csudo} ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1
     ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
+    
+	if [ "$verMode" == "cluster" ]; then
+        # Compatible with version 1.5
+        ${csudo} mkdir -p ${v15_java_app_dir}
+        ${csudo} ln -s ${install_main_dir}/connector/taos-jdbcdriver-1.0.2-dist.jar ${v15_java_app_dir}/JDBCDriver-1.0.2-dist.jar
+        ${csudo} chmod 777 ${v15_java_app_dir} || :
+    fi
 }
 
 function install_header() {
@@ -154,6 +181,57 @@ function install_config() {
     
     ${csudo} cp -f ${script_dir}/cfg/taos.cfg ${install_main_dir}/cfg/taos.cfg.org
     ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+
+    if [ "$verMode" == "cluster" ]; then
+        [ ! -z $1 ] && return 0 || : # only install client
+    
+        if ((${update_flag}==1)); then
+            return 0
+        fi
+
+        IP_FORMAT="(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+        IP_PATTERN="\b$IP_FORMAT\.$IP_FORMAT\.$IP_FORMAT\.$IP_FORMAT\b"
+
+        echo
+        echo -e -n "${GREEN}Enter the IP address of an existing TDengine cluster node to join${NC} OR ${GREEN}leave it blank to build one${NC} :"
+        read masterIp
+        while true; do
+            if [ ! -z "$masterIp" ]; then
+                # check the format of the masterIp
+                if [[ $masterIp =~ $IP_PATTERN ]]; then
+                    # Write the first IP to configuration file
+                    sudo sed -i -r "s/#*\s*(masterIp\s*).*/\1$masterIp/" ${cfg_dir}/taos.cfg
+
+                    # Get the second IP address
+
+                    echo
+                    echo -e -n "${GREEN}Enter the IP address of another node in cluster${NC} OR ${GREEN}leave it blank to skip${NC}: "
+                    read secondIp
+                    while true; do
+
+                        if [ ! -z "$secondIp" ]; then
+                            if [[ $secondIp =~ $IP_PATTERN ]]; then
+                                # Write the second IP to configuration file
+                                sudo sed -i -r "s/#*\s*(secondIp\s*).*/\1$secondIp/" ${cfg_dir}/taos.cfg
+                                break
+                            else
+                                read -p "Please enter the correct IP address: " secondIp
+                            fi
+                        else
+                            break
+                        fi
+                    done
+    
+                    break
+                else
+                    read -p "Please enter the correct IP address: " masterIp
+                fi
+            else
+                break
+            fi
+        done
+	
+	fi
 }
 
 
@@ -175,7 +253,9 @@ function install_connector() {
 }
 
 function install_examples() {
+    if [ -d ${script_dir}/examples ]; then
         ${csudo} cp -rf ${script_dir}/examples/* ${install_main_dir}/examples
+    fi
 }
 
 function clean_service_on_sysvinit() {
@@ -240,6 +320,18 @@ function clean_service_on_systemd() {
     ${csudo} systemctl disable taosd &> /dev/null || echo &> /dev/null
 
     ${csudo} rm -f ${taosd_service_config}
+
+    if [ "$verMode" == "cluster" ]; then
+        nginx_service_config="${service_config_dir}/nginxd.service"
+	
+        if systemctl is-active --quiet nginxd; then
+            echo "Nginx for TDengine is running, stopping it..."
+            ${csudo} systemctl stop nginxd &> /dev/null || echo &> /dev/null
+        fi
+        ${csudo} systemctl disable nginxd &> /dev/null || echo &> /dev/null
+	
+        ${csudo} rm -f ${nginx_service_config}
+	fi
 }
 
 # taos:2345:respawn:/etc/init.d/taosd start
@@ -269,6 +361,36 @@ function install_service_on_systemd() {
     ${csudo} bash -c "echo '[Install]'                          >> ${taosd_service_config}"
     ${csudo} bash -c "echo 'WantedBy=multi-user.target'         >> ${taosd_service_config}"
     ${csudo} systemctl enable taosd
+
+    if [ "$verMode" == "cluster" ]; then		
+        nginx_service_config="${service_config_dir}/nginxd.service"
+        ${csudo} bash -c "echo '[Unit]'                             >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'Description=Nginx For TDengine Service' >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'After=network-online.target'        >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'Wants=network-online.target'        >> ${nginx_service_config}"
+        ${csudo} bash -c "echo                                      >> ${nginx_service_config}"
+        ${csudo} bash -c "echo '[Service]'                          >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'Type=forking'                       >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'PIDFile=/usr/local/nginxd/logs/nginx.pid'        >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'ExecStart=/usr/local/nginxd/sbin/nginx'          >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'ExecStop=/usr/local/nginxd/sbin/nginx -s stop'   >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'LimitNOFILE=infinity'               >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'LimitNPROC=infinity'                >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'LimitCORE=infinity'                 >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'TimeoutStartSec=0'                  >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'StandardOutput=null'                >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'Restart=always'                     >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'StartLimitBurst=3'                  >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'StartLimitInterval=60s'             >> ${nginx_service_config}"
+        ${csudo} bash -c "echo                                      >> ${nginx_service_config}"
+        ${csudo} bash -c "echo '[Install]'                          >> ${nginx_service_config}"
+        ${csudo} bash -c "echo 'WantedBy=multi-user.target'         >> ${nginx_service_config}"
+        if ! ${csudo} systemctl enable nginxd &> /dev/null; then
+            ${csudo} systemctl daemon-reexec
+            ${csudo} systemctl enable nginxd
+        fi
+        ${csudo} systemctl start nginxd
+	fi
 }
 
 function install_service() {
@@ -364,6 +486,21 @@ function update_TDengine() {
         install_service
         install_config
 		
+		if [ "$verMode" == "cluster" ]; then    
+            # Check if openresty is installed
+            openresty_work=false
+
+            # Check if nginx is installed successfully
+            if type curl &> /dev/null; then
+                if curl -sSf http://127.0.0.1:${nginx_port} &> /dev/null; then
+                    echo -e "\033[44;32;1mNginx for TDengine is updated successfully!${NC}"
+                    openresty_work=true
+                else
+                    echo -e "\033[44;31;5mNginx for TDengine does not work! Please try again!\033[0m"
+                fi
+            fi
+		fi 
+
         echo
         echo -e "\033[44;32;1mTDengine is updated successfully!${NC}"
         echo
@@ -376,7 +513,15 @@ function update_TDengine() {
             echo -e "${GREEN_DARK}To start TDengine     ${NC}: ./taosd${NC}"
         fi
 
+        if [ "$verMode" == "cluster" ]; then  
+            if [ ${openresty_work} = 'true' ]; then
+                echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+            else
                 echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+            fi
+        else
+		    echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+        fi
         echo
         echo -e "\033[44;32;1mTDengine is updated successfully!${NC}"
     else
@@ -416,6 +561,20 @@ function install_TDengine() {
         # For installing new
         install_bin
         install_service
+
+        if [ "$verMode" == "cluster" ]; then  
+            openresty_work=false
+            # Check if nginx is installed successfully
+            if type curl &> /dev/null; then
+                if curl -sSf http://127.0.0.1:${nginx_port} &> /dev/null; then
+                    echo -e "\033[44;32;1mNginx for TDengine is installed successfully!${NC}"
+                    openresty_work=true
+                else
+                    echo -e "\033[44;31;5mNginx for TDengine does not work! Please try again!\033[0m"
+                fi
+            fi
+        fi
+		
         install_config	
 
         # Ask if to start the service
@@ -431,7 +590,16 @@ function install_TDengine() {
             echo -e "${GREEN_DARK}To start TDengine     ${NC}: taosd${NC}"
         fi
 		
+        if [ "$verMode" == "cluster" ]; then  
+           if [ ${openresty_work} = 'true' ]; then
+                echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${nginx_port}${NC}"
+           else
+                echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+            fi
+		else
             echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+        fi
+		
         echo
         echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
     else # Only install client
@@ -450,6 +618,7 @@ function install_TDengine() {
 if [ -z $1 ]; then
     # Install server and client
     if [ -x ${bin_dir}/taosd ]; then
+        update_flag=1
         update_TDengine
     else
         install_TDengine
@@ -457,6 +626,7 @@ if [ -z $1 ]; then
 else
     # Only install client
     if [ -x ${bin_dir}/taos ]; then
+        update_flag=1
         update_TDengine client
     else
         install_TDengine client

packaging/tools/install_client.sh

@@ -7,18 +7,35 @@ set -e
 #set -x
 
 # -----------------------Variables definition---------------------
-script_dir=$(dirname $(readlink -f "$0"))
-# Dynamic directory
-data_dir="/var/lib/taos"
-log_dir="/var/log/taos"
+
+osType=Linux
+
+if [ "$osType" != "Darwin" ]; then
+    script_dir=$(dirname $(readlink -f "$0"))
+    # Dynamic directory
+    data_dir="/var/lib/taos"
+    log_dir="/var/log/taos"
+else
+    script_dir=`dirname $0`
+    cd ${script_dir}
+    script_dir="$(pwd)"
+    data_dir="/var/lib/taos"
+    log_dir="~/TDengineLog"
+fi
 
 log_link_dir="/usr/local/taos/log"
 
 cfg_install_dir="/etc/taos"
 
-bin_link_dir="/usr/bin"
-lib_link_dir="/usr/lib"
-inc_link_dir="/usr/include"
+if [ "$osType" != "Darwin" ]; then
+    bin_link_dir="/usr/bin"
+    lib_link_dir="/usr/lib"
+    inc_link_dir="/usr/include"
+else
+    bin_link_dir="/usr/local/bin"
+    lib_link_dir="/usr/local/lib"
+    inc_link_dir="/usr/local/include"
+fi
 
 #install main path
 install_main_dir="/usr/local/taos"
@@ -26,6 +43,8 @@ install_main_dir="/usr/local/taos"
 # old bin dir
 bin_dir="/usr/local/taos/bin"
 
+# v1.5 jar dir
+v15_java_app_dir="/usr/local/lib/taos"
 
 # Color setting
 RED='\033[0;31m'
@@ -63,31 +82,40 @@ function install_main_path() {
 function install_bin() {
   # Remove links
   ${csudo} rm -f ${bin_link_dir}/taos         || :
+  if [ "$osType" == "Darwin" ]; then
       ${csudo} rm -f ${bin_link_dir}/taosdump || :
+  fi
   ${csudo} rm -f ${bin_link_dir}/rmtaos       || :
 
   ${csudo} cp -r ${script_dir}/bin/* ${install_main_dir}/bin && ${csudo} chmod 0555 ${install_main_dir}/bin/*
 
     #Make link
   [ -x ${install_main_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos                 || :
+  if [ "$osType" == "Darwin" ]; then
       [ -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 || :
 }
 
 function clean_lib() {
-    sudo rm -f /usr/lib/libtaos.so || :
+    sudo rm -f /usr/lib/libtaos.* || :
     sudo rm -rf ${lib_dir} || :
 }
 
 function install_lib() {
     # Remove links
     ${csudo} rm -f ${lib_link_dir}/libtaos.*         || :
+    ${csudo} rm -rf ${v15_java_app_dir}                         || :
 
     ${csudo} cp -rf ${script_dir}/driver/* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
 
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1
         ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
-    
+    else
+        ${csudo} ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
+        ${csudo} ln -s ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
+    fi
 }
 
 function install_header() {
@@ -113,8 +141,12 @@ function install_config() {
 
 function install_log() {
     ${csudo} rm -rf ${log_dir}  || :
-    ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
 
+    if [ "$osType" != "Darwin" ]; then
+        ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
+    else
+        mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
+    fi
     ${csudo} ln -s ${log_dir} ${install_main_dir}/log
 }
 

packaging/tools/make_install.sh

@@ -9,19 +9,37 @@ set -e
 # -----------------------Variables definition---------------------
 source_dir=$1
 binary_dir=$2
-script_dir=$(dirname $(readlink -f "$0"))
+osType=$3
+
+if [ "$osType" != "Darwin" ]; then
+    script_dir=$(dirname $(readlink -f "$0"))
+else
+    script_dir=${source_dir}/packaging/tools
+fi
+
 # Dynamic directory
 data_dir="/var/lib/taos"
-log_dir="/var/log/taos"
+
+if [ "$osType" != "Darwin" ]; then
+    log_dir="/var/log/taos"
+else
+    log_dir="~/TDengineLog"
+fi
 
 data_link_dir="/usr/local/taos/data"
 log_link_dir="/usr/local/taos/log"
 
 cfg_install_dir="/etc/taos"
 
-bin_link_dir="/usr/bin"
-lib_link_dir="/usr/lib"
-inc_link_dir="/usr/include"
+if [ "$osType" != "Darwin" ]; then
+    bin_link_dir="/usr/bin"
+    lib_link_dir="/usr/lib"
+    inc_link_dir="/usr/include"
+else
+    bin_link_dir="/usr/local/bin"
+    lib_link_dir="/usr/local/lib"
+    inc_link_dir="/usr/local/include"
+fi
 
 #install main path
 install_main_dir="/usr/local/taos"
@@ -43,11 +61,13 @@ if command -v sudo > /dev/null; then
     csudo="sudo"
 fi
 
-initd_mod=0
-service_mod=2
-if pidof systemd &> /dev/null; then
+if [ "$osType" != "Darwin" ]; then
+
+    initd_mod=0
+    service_mod=2
+    if pidof systemd &> /dev/null; then
         service_mod=0
-elif $(which service &> /dev/null); then    
+    elif $(which service &> /dev/null); then
         service_mod=1
         service_config_dir="/etc/init.d" 
         if $(which chkconfig &> /dev/null); then
@@ -59,35 +79,36 @@ elif $(which service &> /dev/null); then
         else
             service_mod=2
         fi
-else 
+    else
         service_mod=2
-fi
-
+    fi
 
-# get the operating system type for using the corresponding init file
-# ubuntu/debian(deb), centos/fedora(rpm), others: opensuse, redhat, ..., no verification
-#osinfo=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
-osinfo=$(cat /etc/os-release | grep "NAME" | cut -d '"' -f2)
-#echo "osinfo: ${osinfo}"
-os_type=0
-if echo $osinfo | grep -qwi "ubuntu" ; then
+    # get the operating system type for using the corresponding init file
+    # ubuntu/debian(deb), centos/fedora(rpm), others: opensuse, redhat, ..., no verification
+    #osinfo=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
+    osinfo=$(cat /etc/os-release | grep "NAME" | cut -d '"' -f2)
+    #echo "osinfo: ${osinfo}"
+    os_type=0
+    if echo $osinfo | grep -qwi "ubuntu" ; then
         echo "this is ubuntu system"
         os_type=1
-elif echo $osinfo | grep -qwi "debian" ; then
+    elif echo $osinfo | grep -qwi "debian" ; then
         echo "this is debian system"
         os_type=1
-elif echo $osinfo | grep -qwi "Kylin" ; then
+    elif echo $osinfo | grep -qwi "Kylin" ; then
         echo "this is Kylin system"
         os_type=1
-elif  echo $osinfo | grep -qwi "centos" ; then
+    elif  echo $osinfo | grep -qwi "centos" ; then
         echo "this is centos system"
         os_type=2
-elif echo $osinfo | grep -qwi "fedora" ; then
+    elif echo $osinfo | grep -qwi "fedora" ; then
         echo "this is fedora system"
         os_type=2
-else
-  echo "this is other linux system"
-  os_type=0
+    else
+        echo "${osinfo}: This is an officially unverified linux system, If there are any problems with the installation and operation, "
+        echo "please feel free to contact taosdata.com for support."
+        os_type=1
+    fi
 fi
 
 function kill_taosd() {
@@ -107,27 +128,46 @@ function install_main_path() {
     ${csudo} mkdir -p ${install_main_dir}/driver
     ${csudo} mkdir -p ${install_main_dir}/examples
     ${csudo} mkdir -p ${install_main_dir}/include
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} mkdir -p ${install_main_dir}/init.d
+    fi
 }
 
 function install_bin() {
     # Remove links
     ${csudo} rm -f ${bin_link_dir}/taos         || :
+
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} rm -f ${bin_link_dir}/taosd    || :
         ${csudo} rm -f ${bin_link_dir}/taosdemo || :
         ${csudo} rm -f ${bin_link_dir}/taosdump || :
+    fi
+
     ${csudo} rm -f ${bin_link_dir}/rmtaos       || :
 
     ${csudo} cp -r ${binary_dir}/build/bin/* ${install_main_dir}/bin
+
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} cp -r ${script_dir}/remove.sh   ${install_main_dir}/bin
+    else
+        ${csudo} cp -r ${script_dir}/remove_client.sh   ${install_main_dir}/bin
+    fi
     ${csudo} chmod 0555 ${install_main_dir}/bin/*
 
     #Make link
     [ -x ${install_main_dir}/bin/taos ]      && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos         || :
+
+    if [ "$osType" != "Darwin" ]; then
         [ -x ${install_main_dir}/bin/taosd ]     && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd   || :
         [ -x ${install_main_dir}/bin/taosdump ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
         [ -x ${install_main_dir}/bin/taosdemo ]  && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
+    fi
+
+    if [ "$osType" != "Darwin" ]; then
         [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos  || :
+    else
+        [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/rmtaos  || :
+    fi
 }
 
 function install_lib() {
@@ -135,9 +175,15 @@ function install_lib() {
     ${csudo} rm -f ${lib_link_dir}/libtaos.*     || :
     
     versioninfo=$(${script_dir}/get_version.sh ${source_dir}/src/util/src/version.c)
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} cp ${binary_dir}/build/lib/libtaos.so.${versioninfo} ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
         ${csudo} ln -sf ${install_main_dir}/driver/libtaos.so.${versioninfo} ${lib_link_dir}/libtaos.so.1
         ${csudo} ln -sf ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
+    else
+        ${csudo} cp ${binary_dir}/build/lib/libtaos.${versioninfo}.dylib ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
+        ${csudo} ln -sf ${install_main_dir}/driver/libtaos.${versioninfo}.dylib ${lib_link_dir}/libtaos.1.dylib
+        ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
+    fi
 }
 
 function install_header() {
@@ -163,7 +209,12 @@ function install_config() {
 
 function install_log() {  
     ${csudo} rm -rf ${log_dir}  || :
+
+    if [ "$osType" != "Darwin" ]; then
         ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
+    else
+        mkdir -p ${log_dir} && chmod 777 ${log_dir}
+    fi
 
     ${csudo} ln -s ${log_dir} ${install_main_dir}/log
 }
@@ -291,6 +342,8 @@ function install_service() {
 function update_TDengine() {
     echo -e "${GREEN}Start to update TDEngine...${NC}"
     # Stop the service if running
+
+    if [ "$osType" != "Darwin" ]; then
       if pidof taosd &> /dev/null; then
         if ((${service_mod}==0)); then
             ${csudo} systemctl stop taosd || :
@@ -301,6 +354,7 @@ function update_TDengine() {
         fi
         sleep 1
       fi
+    fi
     
     install_main_path
 
@@ -310,12 +364,18 @@ function update_TDengine() {
     install_connector
     install_examples
     install_bin
+
+    if [ "$osType" != "Darwin" ]; then
         install_service
+    fi
+
     install_config
 
+    if [ "$osType" != "Darwin" ]; then
         echo
         echo -e "\033[44;32;1mTDengine is updated successfully!${NC}"
         echo
+
         echo -e "${GREEN_DARK}To configure TDengine ${NC}: edit /etc/taos/taos.cfg"
         if ((${service_mod}==0)); then
             echo -e "${GREEN_DARK}To start TDengine     ${NC}: ${csudo} systemctl start taosd${NC}"
@@ -328,14 +388,30 @@ function update_TDengine() {
         echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
         echo
         echo -e "\033[44;32;1mTDengine is updated successfully!${NC}"
+    else
+        echo
+        echo -e "\033[44;32;1mTDengine Client is updated successfully!${NC}"
+        echo
+
+        echo -e "${GREEN_DARK}To access TDengine Client   ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+        echo
+        echo -e "\033[44;32;1mTDengine Client is updated successfully!${NC}"
+    fi
 }
 
 function install_TDengine() {
     # Start to install
+    if [ "$osType" != "Darwin" ]; then
         echo -e "${GREEN}Start to install TDEngine...${NC}"
+	else
+	    echo -e "${GREEN}Start to install TDEngine Client ...${NC}"
+    fi
 
 	install_main_path
+
+	if [ "$osType" != "Darwin" ]; then
         install_data
+    fi
     install_log 
     install_header
     install_lib
@@ -343,8 +419,14 @@ function install_TDengine() {
     install_examples
 
     install_bin
+
+    if [ "$osType" != "Darwin" ]; then
         install_service
+    fi
+
     install_config	
+
+    if [ "$osType" != "Darwin" ]; then
         # Ask if to start the service
         echo
         echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
@@ -361,12 +443,17 @@ function install_TDengine() {
         echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
         echo
         echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
+    else
+        echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
+        echo
+        echo -e "\033[44;32;1mTDengine Client is installed successfully!${NC}"
+    fi
 }
 
 ## ==============================Main program starts from here============================
 echo source directory: $1
 echo binary directory: $2
-if [ -x ${bin_dir}/taosd ]; then
+if [ -x ${bin_dir}/taos ]; then
     update_TDengine
 else
     install_TDengine

packaging/tools/makeclient.sh

@@ -13,8 +13,15 @@ osType=$5
 verMode=$6
 verType=$7
 
-script_dir="$(dirname $(readlink -f $0))"
-top_dir="$(readlink -f ${script_dir}/../..)"
+if [ "$osType" != "Darwin" ]; then
+    script_dir="$(dirname $(readlink -f $0))"
+    top_dir="$(readlink -f ${script_dir}/../..)"
+else
+    script_dir=`dirname $0`
+    cd ${script_dir}
+    script_dir="$(pwd)"
+    top_dir=${script_dir}/../..
+fi
 
 # create compressed install file.
 build_dir="${compile_dir}/build"
@@ -22,13 +29,26 @@ code_dir="${top_dir}/src"
 release_dir="${top_dir}/release"
 
 #package_name='linux'
-install_dir="${release_dir}/TDengine-client"
+
+if [ "$verMode" == "cluster" ]; then
+    install_dir="${release_dir}/TDengine-enterprise-client"
+else
+    install_dir="${release_dir}/TDengine-client"
+fi
 
 # Directories and files.
-bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdump ${script_dir}/remove_client.sh"
-lib_files="${build_dir}/lib/libtaos.so.${version}"
+
+if [ "$osType" != "Darwin" ]; then
+    bin_files="${build_dir}/bin/taos ${build_dir}/bin/taosdump ${script_dir}/remove_client.sh"
+    lib_files="${build_dir}/lib/libtaos.so.${version}"
+else
+    bin_files="${build_dir}/bin/taos ${script_dir}/remove_client.sh"
+    lib_files="${build_dir}/lib/libtaos.${version}.dylib"
+fi
+
 header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
 cfg_dir="${top_dir}/packaging/cfg"
+
 install_files="${script_dir}/install_client.sh"
 
 # make directories.
@@ -38,10 +58,23 @@ mkdir -p ${install_dir}/cfg && cp ${cfg_dir}/taos.cfg ${install_dir}/cfg/taos.cf
 mkdir -p ${install_dir}/bin && cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/*
 
 cd ${install_dir}
-tar -zcv -f taos.tar.gz * --remove-files || :
+
+if [ "$osType" != "Darwin" ]; then
+    tar -zcv -f taos.tar.gz * --remove-files || :
+else
+    tar -zcv -f taos.tar.gz * || :
+    mv taos.tar.gz ..
+    rm -rf ./*
+    mv ../taos.tar.gz .
+fi
 
 cd ${curr_dir}
-cp ${install_files} ${install_dir} && chmod a+x ${install_dir}/install*
+cp ${install_files} ${install_dir}
+if [ "$osType" == "Darwin" ]; then
+    sed 's/osType=Linux/osType=Darwin/g' ${install_dir}/install_client.sh >> install_client_temp.sh
+    mv install_client_temp.sh ${install_dir}/install_client.sh
+fi
+chmod a+x ${install_dir}/install_client.sh
 
 # Copy example code
 mkdir -p ${install_dir}/examples
@@ -60,7 +93,10 @@ cp ${lib_files} ${install_dir}/driver
 # Copy connector
 connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
-cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+
+if [ "$osType" != "Darwin" ]; then
+    cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+fi
 cp -r ${connector_dir}/grafana ${install_dir}/connector/
 cp -r ${connector_dir}/python  ${install_dir}/connector/
 cp -r ${connector_dir}/go      ${install_dir}/connector
@@ -75,7 +111,7 @@ cd ${release_dir}
 if [ "$verMode" == "cluster" ]; then
   pkg_name=${install_dir}-${version}-${osType}-${cpuType}
 elif [ "$verMode" == "lite" ]; then
-  pkg_name=${install_dir}-edge-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or lite"
   exit 1
@@ -90,6 +126,13 @@ else
   exit 1
 fi
 
-tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files
+if [ "$osType" != "Darwin" ]; then
+    tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
+else
+    tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) || :
+    mv "$(basename ${pkg_name}).tar.gz" ..
+    rm -rf ./*
+    mv ../"$(basename ${pkg_name}).tar.gz" .
+fi
 
 cd ${curr_dir}

packaging/tools/makepkg.sh

@@ -23,7 +23,11 @@ code_dir="${top_dir}/src"
 release_dir="${top_dir}/release"
 
 #package_name='linux'
-install_dir="${release_dir}/TDengine-server"
+if [ "$verMode" == "cluster" ]; then
+    install_dir="${release_dir}/TDengine-enterprise-server"
+else
+    install_dir="${release_dir}/TDengine-server"
+fi
 
 # Directories and files.
 bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdemo ${build_dir}/bin/taosdump ${script_dir}/remove.sh"
@@ -31,6 +35,7 @@ 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"
 install_files="${script_dir}/install.sh"
+nginx_dir="${code_dir}/../../enterprise/src/modules/web"
 
 # Init file
 #init_dir=${script_dir}/deb
@@ -50,11 +55,29 @@ mkdir -p ${install_dir}/bin && cp ${bin_files} ${install_dir}/bin && chmod a+x $
 mkdir -p ${install_dir}/init.d && cp ${init_file_deb} ${install_dir}/init.d/taosd.deb
 mkdir -p ${install_dir}/init.d && cp ${init_file_rpm} ${install_dir}/init.d/taosd.rpm
 
+if [ "$verMode" == "cluster" ]; then
+    mkdir -p ${install_dir}/nginxd && cp -r ${nginx_dir}/* ${install_dir}/nginxd
+    cp ${nginx_dir}/png/taos.png ${install_dir}/nginxd/admin/images/taos.png
+    rm -rf ${install_dir}/nginxd/png
+
+    if [ "$cpuType" == "aarch64" ]; then
+        cp -f ${install_dir}/nginxd/sbin/arm/64bit/nginx ${install_dir}/nginxd/sbin/
+    elif [ "$cpuType" == "aarch32" ]; then
+        cp -f ${install_dir}/nginxd/sbin/arm/32bit/nginx ${install_dir}/nginxd/sbin/
+    fi
+    rm -rf ${install_dir}/nginxd/sbin/arm
+fi
+
 cd ${install_dir}
 tar -zcv -f taos.tar.gz * --remove-files  || :
 
 cd ${curr_dir}
-cp ${install_files} ${install_dir} && chmod a+x ${install_dir}/install*
+cp ${install_files} ${install_dir}
+if [ "$verMode" == "cluster" ]; then
+    sed 's/verMode=lite/verMode=cluster/g' ${install_dir}/install.sh >> install_temp.sh
+	mv install_temp.sh ${install_dir}/install.sh
+fi
+chmod a+x ${install_dir}/install.sh
 
 # Copy example code
 mkdir -p ${install_dir}/examples
@@ -88,7 +111,7 @@ cd ${release_dir}
 if [ "$verMode" == "cluster" ]; then
   pkg_name=${install_dir}-${version}-${osType}-${cpuType}
 elif [ "$verMode" == "lite" ]; then
-  pkg_name=${install_dir}-edge-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or lite"
   exit 1
@@ -103,6 +126,6 @@ else
   exit 1
 fi
 
-tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files
+tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
 
 cd ${curr_dir}

packaging/tools/remove.sh

@@ -2,6 +2,11 @@
 #
 # Script to stop the service and uninstall TDengine, but retain the config, data and log files.
 
+set -e
+#set -x
+
+verMode=lite
+
 RED='\033[0;31m'
 GREEN='\033[1;32m'
 NC='\033[0m'
@@ -14,10 +19,14 @@ cfg_link_dir="/usr/local/taos/cfg"
 bin_link_dir="/usr/bin"
 lib_link_dir="/usr/lib"
 inc_link_dir="/usr/include"
+install_nginxd_dir="/usr/local/nginxd"
+
+# v1.5 jar dir
+v15_java_app_dir="/usr/local/lib/taos"
 
 service_config_dir="/etc/systemd/system"
 taos_service_name="taosd"
-
+nginx_service_name="nginxd"
 csudo=""
 if command -v sudo > /dev/null; then
     csudo="sudo"
@@ -62,6 +71,7 @@ function clean_bin() {
 function clean_lib() {
     # Remove link
     ${csudo} rm -f ${lib_link_dir}/libtaos.*      || :
+    ${csudo} rm -rf ${v15_java_app_dir}                      || :
 }
 
 function clean_header() {
@@ -90,6 +100,20 @@ function clean_service_on_systemd() {
     ${csudo} systemctl disable ${taos_service_name} &> /dev/null || echo &> /dev/null
 
     ${csudo} rm -f ${taosd_service_config}
+
+    if [ "$verMode" == "cluster" ]; then
+		nginx_service_config="${service_config_dir}/${nginx_service_name}.service"
+	
+   	 	if [ -d ${bin_dir}/web ]; then
+   	        if systemctl is-active --quiet ${nginx_service_name}; then
+   	            echo "Nginx for TDengine is running, stopping it..."
+   	            ${csudo} systemctl stop ${nginx_service_name} &> /dev/null || echo &> /dev/null
+   	        fi
+   	        ${csudo} systemctl disable ${nginx_service_name} &> /dev/null || echo &> /dev/null
+        
+   	        ${csudo} rm -f ${nginx_service_config}
+   	    fi
+    fi 
 }
 
 function clean_service_on_sysvinit() {
@@ -143,6 +167,7 @@ clean_config
 ${csudo} rm -rf ${data_link_dir}    || : 
 
 ${csudo} rm -rf ${install_main_dir}
+${csudo} rm -rf ${install_nginxd_dir}
 
 osinfo=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
 if echo $osinfo | grep -qwi "ubuntu" ; then

packaging/tools/remove_client.sh

@@ -17,6 +17,10 @@ bin_link_dir="/usr/bin"
 lib_link_dir="/usr/lib"
 inc_link_dir="/usr/include"
 
+
+# v1.5 jar dir
+v15_java_app_dir="/usr/local/lib/taos"
+
 csudo=""
 if command -v sudo > /dev/null; then
     csudo="sudo"
@@ -39,6 +43,7 @@ function clean_bin() {
 function clean_lib() {
     # Remove link
     ${csudo} rm -f ${lib_link_dir}/libtaos.*      || :
+    ${csudo} rm -rf ${v15_java_app_dir}                      || :
 }
 
 function clean_header() {

src/client/CMakeLists.txt

@@ -24,20 +24,10 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   #set version of .so
   #VERSION    so version
   #SOVERSION  api version
-  IF (TD_LITE)
   execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh)
   execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh ${TD_COMMUNITY_DIR}/src/util/src/version.c
         OUTPUT_VARIABLE
         VERSION_INFO)
-    MESSAGE(STATUS "build lite version ${VERSION_INFO}")
-  ELSE ()
-    execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh)
-    execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh ${TD_COMMUNITY_DIR}/src/util/src/version.c
-            OUTPUT_VARIABLE
-            VERSION_INFO)
-    MESSAGE(STATUS "build cluster version ${VERSION_INFO}")
-  ENDIF ()
-
   MESSAGE(STATUS "build version ${VERSION_INFO}")
   SET_TARGET_PROPERTIES(taos PROPERTIES VERSION ${VERSION_INFO} SOVERSION 1)
   
@@ -51,10 +41,13 @@ ELSEIF (TD_WINDOWS_64)
 
   # generate dynamic library (*.dll)
   ADD_LIBRARY(taos SHARED ${SRC})
+  IF (NOT TD_GODLL)
     SET_TARGET_PROPERTIES(taos PROPERTIES LINK_FLAGS /DEF:${TD_COMMUNITY_DIR}/src/client/src/taos.def)
+  ENDIF ()
   TARGET_LINK_LIBRARIES(taos trpc)
 
 ELSEIF (TD_DARWIN_64)
+  SET(CMAKE_MACOSX_RPATH 1)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/linux)
 
   ADD_LIBRARY(taos_static STATIC ${SRC})
@@ -65,5 +58,16 @@ ELSEIF (TD_DARWIN_64)
   ADD_LIBRARY(taos SHARED ${SRC})
   TARGET_LINK_LIBRARIES(taos trpc tutil pthread m)
 
+  SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+
+  #set version of .so
+  #VERSION    so version
+  #SOVERSION  api version
+  execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh)
+  execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_version.sh ${TD_COMMUNITY_DIR}/src/util/src/version.c
+      OUTPUT_VARIABLE
+      VERSION_INFO)
+  MESSAGE(STATUS "build version ${VERSION_INFO}")
+  SET_TARGET_PROPERTIES(taos PROPERTIES VERSION ${VERSION_INFO} SOVERSION 1)
 ENDIF ()
 

src/client/inc/tscJoinProcess.h

@@ -27,7 +27,7 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql);
 void tscGetQualifiedTSList(SSqlObj* pSql, SJoinSubquerySupporter* p1, SJoinSubquerySupporter* p2, int32_t* num);
 
 void tscSetupOutputColumnIndex(SSqlObj* pSql);
-int32_t tscLaunchSecondSubquery(SSqlObj* pSql);
+int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql);
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code);
 
 SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pState, int32_t index);
@@ -121,7 +121,7 @@ STSBuf* tsBufCreate(bool autoDelete);
 STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete);
 STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_t len, int32_t tsOrder);
 
-void tsBufDestory(STSBuf* pTSBuf);
+void* tsBufDestory(STSBuf* pTSBuf);
 
 void tsBufAppend(STSBuf* pTSBuf, int32_t vnodeId, int64_t tag, const char* pData, int32_t len);
 int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf, int32_t vnodeIdx);

src/client/inc/tscSQLParser.h

@@ -21,9 +21,70 @@ extern "C" {
 #endif
 
 #include "taos.h"
+#include "taosmsg.h"
 #include "tsqldef.h"
 #include "ttypes.h"
-#include "taosmsg.h"
+
+enum _sql_cmd {
+  TSDB_SQL_SELECT = 1,
+  TSDB_SQL_FETCH,
+  TSDB_SQL_INSERT,
+  
+  TSDB_SQL_MGMT,  // the SQL below is for mgmt node
+  TSDB_SQL_CREATE_DB,
+  TSDB_SQL_CREATE_TABLE,
+  TSDB_SQL_DROP_DB,
+  TSDB_SQL_DROP_TABLE,
+  TSDB_SQL_CREATE_ACCT,
+  TSDB_SQL_CREATE_USER,  //10
+  TSDB_SQL_DROP_ACCT,
+  TSDB_SQL_DROP_USER,
+  TSDB_SQL_ALTER_USER,
+  TSDB_SQL_ALTER_ACCT,
+  TSDB_SQL_ALTER_TABLE,
+  TSDB_SQL_ALTER_DB,
+  TSDB_SQL_CREATE_MNODE,
+  TSDB_SQL_DROP_MNODE,
+  TSDB_SQL_CREATE_DNODE,
+  TSDB_SQL_DROP_DNODE,  // 20
+  TSDB_SQL_CFG_DNODE,
+  TSDB_SQL_CFG_MNODE,
+  TSDB_SQL_SHOW,
+  TSDB_SQL_RETRIEVE,
+  TSDB_SQL_KILL_QUERY,
+  TSDB_SQL_KILL_STREAM,
+  TSDB_SQL_KILL_CONNECTION,
+  
+  TSDB_SQL_READ,  // SQL below is for read operation
+  TSDB_SQL_CONNECT,
+  TSDB_SQL_USE_DB,    // 30
+  TSDB_SQL_META,
+  TSDB_SQL_METRIC,
+  TSDB_SQL_MULTI_META,
+  TSDB_SQL_HB,
+  
+  TSDB_SQL_LOCAL,  // SQL below for client local
+  TSDB_SQL_DESCRIBE_TABLE,
+  TSDB_SQL_RETRIEVE_METRIC,
+  TSDB_SQL_METRIC_JOIN_RETRIEVE,
+  TSDB_SQL_RETRIEVE_TAGS,
+  
+  /*
+   * build empty result instead of accessing dnode to fetch result
+   * reset the client cache
+   */
+  TSDB_SQL_RETRIEVE_EMPTY_RESULT,  //40
+  
+  TSDB_SQL_RESET_CACHE,
+  TSDB_SQL_SERV_STATUS,
+  TSDB_SQL_CURRENT_DB,
+  TSDB_SQL_SERV_VERSION,
+  TSDB_SQL_CLI_VERSION,
+  TSDB_SQL_CURRENT_USER,
+  TSDB_SQL_CFG_LOCAL,
+  
+  TSDB_SQL_MAX   //48
+};
 
 #define MAX_TOKEN_LEN 30
 
@@ -72,72 +133,12 @@ typedef struct tFieldList {
   TAOS_FIELD *p;
 } tFieldList;
 
-// sql operation type
+// create table operation type
 enum TSQL_TYPE {
-  TSQL_CREATE_NORMAL_METER = 0x01,
-  TSQL_CREATE_NORMAL_METRIC = 0x02,
-  TSQL_CREATE_METER_FROM_METRIC = 0x04,
-  TSQL_CREATE_STREAM = 0x08,
-  TSQL_QUERY_METER = 0x10,
-  TSQL_INSERT = 0x20,
-
-  DROP_DNODE = 0x40,
-  DROP_DATABASE = 0x41,
-  DROP_TABLE = 0x42,
-  DROP_USER = 0x43,
-  DROP_ACCOUNT = 0x44,
-
-  USE_DATABASE = 0x50,
-
-  // show operation
-  SHOW_DATABASES = 0x60,
-  SHOW_TABLES = 0x61,
-  SHOW_STABLES = 0x62,
-  SHOW_MNODES = 0x63,
-  SHOW_DNODES = 0x64,
-  SHOW_ACCOUNTS = 0x65,
-  SHOW_USERS = 0x66,
-  SHOW_VGROUPS = 0x67,
-  SHOW_QUERIES = 0x68,
-  SHOW_STREAMS = 0x69,
-  SHOW_CONFIGS = 0x6a,
-  SHOW_SCORES = 0x6b,
-  SHOW_MODULES = 0x6c,
-  SHOW_CONNECTIONS = 0x6d,
-  SHOW_GRANTS = 0x6e,
-  SHOW_VNODES = 0x6f,
-
-  // create dnode
-  CREATE_DNODE = 0x80,
-  CREATE_DATABASE = 0x81,
-  CREATE_USER = 0x82,
-  CREATE_ACCOUNT = 0x83,
-
-  DESCRIBE_TABLE = 0x90,
-
-  ALTER_USER_PASSWD = 0xA0,
-  ALTER_USER_PRIVILEGES = 0xA1,
-  ALTER_DNODE = 0xA2,
-  ALTER_LOCAL = 0xA3,
-  ALTER_DATABASE = 0xA4,
-  ALTER_ACCT = 0xA5,
-
-  // reset operation
-  RESET_QUERY_CACHE = 0xB0,
-
-  // alter tags
-  ALTER_TABLE_TAGS_ADD = 0xC0,
-  ALTER_TABLE_TAGS_DROP = 0xC1,
-  ALTER_TABLE_TAGS_CHG = 0xC2,
-  ALTER_TABLE_TAGS_SET = 0xC4,
-
-  // alter table column
-  ALTER_TABLE_ADD_COLUMN = 0xD0,
-  ALTER_TABLE_DROP_COLUMN = 0xD1,
-
-  KILL_QUERY = 0xD2,
-  KILL_STREAM = 0xD3,
-  KILL_CONNECTION = 0xD4,
+  TSQL_CREATE_TABLE = 0x1,
+  TSQL_CREATE_STABLE = 0x2,
+  TSQL_CREATE_TABLE_FROM_STABLE = 0x3,
+  TSQL_CREATE_STREAM = 0x4,
 };
 
 typedef struct SQuerySQL {
@@ -158,32 +159,30 @@ typedef struct SCreateTableSQL {
   struct SSQLToken name;  // meter name, create table [meterName] xxx
   bool             existCheck;
   
+  int8_t           type; // create normal table/from super table/ stream
   struct {
     tFieldList *pTagColumns;  // for normal table, pTagColumns = NULL;
     tFieldList *pColumns;
   } colInfo;
 
   struct {
-    SSQLToken     metricName;  // metric name, for using clause
+    SSQLToken     stableName;  // super table name, for using clause
     tVariantList *pTagVals;    // create by using metric, tag value
+    STagData      tagdata;
   } usingInfo;
 
   SQuerySQL *pSelect;
-
 } SCreateTableSQL;
 
 typedef struct SAlterTableSQL {
   SSQLToken     name;
+  int16_t       type;
+  STagData      tagData;
+  
   tFieldList *  pAddColumns;
-  SSQLToken     dropTagToken;
   tVariantList *varList;  // set t=val or: change src dst
 } SAlterTableSQL;
 
-typedef struct SInsertSQL {
-  SSQLToken                name;
-  struct tSQLExprListList *pValue;
-} SInsertSQL;
-
 typedef struct SCreateDBInfo {
   SSQLToken dbname;
   int32_t   replica;
@@ -204,40 +203,67 @@ typedef struct SCreateDBInfo {
 } SCreateDBInfo;
 
 typedef struct SCreateAcctSQL {
-  int32_t   users;
-  int32_t   dbs;
-  int32_t   tseries;
-  int32_t   streams;
-  int32_t   pps;
-  int64_t   storage;
-  int64_t   qtime;
-  int32_t   conns;
+  int32_t   maxUsers;
+  int32_t   maxDbs;
+  int32_t   maxTimeSeries;
+  int32_t   maxStreams;
+  int32_t   maxPointsPerSecond;
+  int64_t   maxStorage;
+  int64_t   maxQueryTime;
+  int32_t   maxConnections;
   SSQLToken stat;
 } SCreateAcctSQL;
 
+typedef struct SShowInfo {
+  uint8_t showType;
+  SSQLToken prefix;
+  SSQLToken pattern;
+} SShowInfo;
+
+typedef struct SUserInfo {
+  SSQLToken user;
+  SSQLToken passwd;
+//  bool      hasPasswd;
+  
+  SSQLToken privilege;
+//  bool      hasPrivilege;
+  
+  int16_t   type;
+} SUserInfo;
+
 typedef struct tDCLSQL {
   int32_t    nTokens; /* Number of expressions on the list */
   int32_t    nAlloc;  /* Number of entries allocated below */
   SSQLToken *a;       /* one entry for element */
+  bool  existsCheck;
 
   union {
     SCreateDBInfo  dbOpt;
     SCreateAcctSQL acctOpt;
+    SShowInfo      showOpt;
+    SSQLToken ip;
   };
+  
+  SUserInfo user;
+  
 } tDCLSQL;
 
+typedef struct SSubclauseInfo {  // "UNION" multiple select sub-clause
+  SQuerySQL **pClause;
+  int32_t     numOfClause;
+} SSubclauseInfo;
+
 typedef struct SSqlInfo {
-  int32_t sqlType;
-  bool    validSql;
+  int32_t type;
+  bool    valid;
 
   union {
     SCreateTableSQL *pCreateTableInfo;
-    SInsertSQL *     pInsertInfo;
     SAlterTableSQL * pAlterInfo;
-    SQuerySQL *      pQueryInfo;
     tDCLSQL *        pDCLInfo;
   };
 
+  SSubclauseInfo subclauseInfo;
   char           pzErrMsg[256];
 } SSqlInfo;
 
@@ -338,7 +364,7 @@ SQuerySQL *tSetQuerySQLElems(SSQLToken *pSelectToken, tSQLExprList *pSelection,
 
 SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SSQLToken *pMetricName,
                                     tVariantList *pTagVals, SQuerySQL *pSelect, int32_t type);
-void tSQLExprDestroy(tSQLExpr *);
+
 void      tSQLExprNodeDestroy(tSQLExpr *pExpr);
 tSQLExpr *tSQLExprNodeClone(tSQLExpr *pExpr);
 
@@ -346,23 +372,31 @@ SAlterTableSQL *tAlterTableSQLElems(SSQLToken *pMeterName, tFieldList *pCols, tV
 
 tSQLExprListList *tSQLListListAppend(tSQLExprListList *pList, tSQLExprList *pExprList);
 
-void tSetInsertSQLElems(SSqlInfo *pInfo, SSQLToken *pName, tSQLExprListList *pList);
+void destroyAllSelectClause(SSubclauseInfo *pSql);
+void doDestroyQuerySql(SQuerySQL *pSql);
 
-void destroyQuerySql(SQuerySQL *pSql);
+SSqlInfo *      setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SSQLToken *pMeterName, int32_t type);
+SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
 
-void setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SSQLToken *pMeterName, int32_t type);
+SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
 
 void setCreatedMeterName(SSqlInfo *pInfo, SSQLToken *pMeterName, SSQLToken *pIfNotExists);
 
 void SQLInfoDestroy(SSqlInfo *pInfo);
 
 void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
+void setDropDBTableInfo(SSqlInfo *pInfo, int32_t type, SSQLToken* pToken, SSQLToken* existsCheck);
+void setShowOptions(SSqlInfo *pInfo, int32_t type, SSQLToken* prefix, SSQLToken* pPatterns);
 
 tDCLSQL *tTokenListAppend(tDCLSQL *pTokenList, SSQLToken *pToken);
 
 void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pToken, SCreateDBInfo *pDB, SSQLToken *pIgExists);
 
 void setCreateAcctSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *pName, SSQLToken *pPwd, SCreateAcctSQL *pAcctInfo);
+void setCreateUserSQL(SSqlInfo *pInfo, SSQLToken *pName, SSQLToken *pPasswd);
+void setKillSQL(SSqlInfo *pInfo, int32_t type, SSQLToken *ip);
+void setAlterUserSQL(SSqlInfo *pInfo, int16_t type, SSQLToken *pName, SSQLToken* pPwd, SSQLToken *pPrivilege);
+
 void setDefaultCreateDbOption(SCreateDBInfo *pDBInfo);
 
 // prefix show db.tables;

src/client/inc/tscSecondaryMerge.h

@@ -120,7 +120,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
 
 void tscDestroyLocalReducer(SSqlObj *pSql);
 
-int32_t tscLocalDoReduce(SSqlObj *pSql);
+int32_t tscDoLocalreduce(SSqlObj *pSql);
 
 #ifdef __cplusplus
 }

src/client/inc/tscUtil.h

@@ -29,9 +29,9 @@ extern "C" {
 #include "tsclient.h"
 #include "tsdb.h"
 
-#define UTIL_METER_IS_METRIC(metaInfo) \
+#define UTIL_METER_IS_SUPERTABLE(metaInfo) \
   (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->meterType == TSDB_METER_METRIC))
-#define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_METRIC(metaInfo)))
+#define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_SUPERTABLE(metaInfo)))
 #define UTIL_METER_IS_CREATE_FROM_METRIC(metaInfo) \
   (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->meterType == TSDB_METER_MTABLE))
 
@@ -67,7 +67,7 @@ typedef struct SJoinSubquerySupporter {
 } SJoinSubquerySupporter;
 
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, const char* name,
-                           STableDataBlocks** dataBlocks);
+                           SMeterMeta* pMeterMeta, STableDataBlocks** dataBlocks);
 void    tscAppendDataBlock(SDataBlockList* pList, STableDataBlocks* pBlocks);
 void    tscDestroyDataBlock(STableDataBlocks* pDataBlock);
 
@@ -81,7 +81,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
 void    tscFreeUnusedDataBlocks(SDataBlockList* pList);
 int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pDataList);
 int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList, int64_t id, int32_t size,
-                                int32_t startOffset, int32_t rowSize, const char* tableId,
+                                int32_t startOffset, int32_t rowSize, const char* tableId, SMeterMeta* pMeterMeta,
                                 STableDataBlocks** dataBlocks);
 
 SVnodeSidList*    tscGetVnodeSidList(SMetricMeta* pMetricmeta, int32_t vnodeIdx);
@@ -95,23 +95,27 @@ SMeterSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
  * @param pSql  sql object
  * @return
  */
-bool tscIsPointInterpQuery(SSqlCmd* pCmd);
-bool tscIsTWAQuery(SSqlCmd* pCmd);
-bool tscProjectionQueryOnMetric(SSqlCmd* pCmd);
-bool tscProjectionQueryOnTable(SSqlCmd* pCmd);
+bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
+bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
+
+bool tscNonOrderedProjectionQueryOnSTable(SQueryInfo *pQueryInfo, int32_t tableIndex);
+bool tscOrderedProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
+bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
 
-bool tscIsTwoStageMergeMetricQuery(SSqlCmd* pCmd);
+bool tscProjectionQueryOnTable(SQueryInfo* pQueryInfo);
+
+bool tscIsTwoStageMergeMetricQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryOnMetric(SSqlCmd* pCmd);
-bool tscQueryMetricTags(SSqlCmd* pCmd);
+bool tscQueryMetricTags(SQueryInfo* pQueryInfo);
 bool tscIsSelectivityWithTagQuery(SSqlCmd* pCmd);
 
-void tscAddSpecialColumnForSelect(SSqlCmd* pCmd, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
+void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
                                   SSchema* pColSchema, int16_t isTag);
 
-void addRequiredTagColumn(SSqlCmd* pCmd, int32_t tagColIndex, int32_t tableIndex);
+void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
 
-int32_t setMeterID(SSqlObj* pSql, SSQLToken* pzTableName, int32_t tableIndex);
-void    tscClearInterpInfo(SSqlCmd* pCmd);
+int32_t setMeterID(SMeterMetaInfo* pMeterMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
+void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertOrImportData(char* sqlstr);
 
@@ -125,29 +129,33 @@ void tscFieldInfoSetValFromField(SFieldInfo* pFieldInfo, int32_t index, TAOS_FIE
 void tscFieldInfoSetValue(SFieldInfo* pFieldInfo, int32_t index, int8_t type, const char* name, int16_t bytes);
 void tscFieldInfoUpdateVisible(SFieldInfo* pFieldInfo, int32_t index, bool visible);
 
-void tscFieldInfoCalOffset(SSqlCmd* pCmd);
-void tscFieldInfoUpdateOffset(SSqlCmd* pCmd);
+void tscFieldInfoCalOffset(SQueryInfo* pQueryInfo);
+void tscFieldInfoUpdateOffsetForInterResult(SQueryInfo* pQueryInfo);
 void tscFieldInfoCopy(SFieldInfo* src, SFieldInfo* dst, const int32_t* indexList, int32_t size);
-void tscFieldInfoCopyAll(SFieldInfo* src, SFieldInfo* dst);
+void tscFieldInfoCopyAll(SFieldInfo* dst, SFieldInfo* src);
 
-TAOS_FIELD* tscFieldInfoGetField(SSqlCmd* pCmd, int32_t index);
-int16_t     tscFieldInfoGetOffset(SSqlCmd* pCmd, int32_t index);
-int32_t     tscGetResRowLength(SSqlCmd* pCmd);
+TAOS_FIELD* tscFieldInfoGetField(SQueryInfo* pQueryInfo, int32_t index);
+int16_t     tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
+int32_t     tscGetResRowLength(SQueryInfo* pQueryInfo);
 void        tscClearFieldInfo(SFieldInfo* pFieldInfo);
+int32_t tscNumOfFields(SQueryInfo* pQueryInfo);
+int32_t tscFieldInfoCompare(SFieldInfo* pFieldInfo1, SFieldInfo* pFieldInfo2);
 
 void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes, int16_t tableIndex);
 
-SSqlExpr* tscSqlExprInsert(SSqlCmd* pCmd, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t interSize);
-SSqlExpr* tscSqlExprInsertEmpty(SSqlCmd* pCmd, int32_t index, int16_t functionId);
+SSqlExpr* tscSqlExprInsertEmpty(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId);
 
-SSqlExpr* tscSqlExprUpdate(SSqlCmd* pCmd, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
+SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
 
-SSqlExpr* tscSqlExprGet(SSqlCmd* pCmd, int32_t index);
+SSqlExpr* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
 void      tscSqlExprCopy(SSqlExprInfo* dst, const SSqlExprInfo* src, uint64_t uid);
+void*     tscSqlExprDestroy(SSqlExpr* pExpr);
+void      tscSqlExprInfoDestroy(SSqlExprInfo* pExprInfo);
 
-SColumnBase* tscColumnBaseInfoInsert(SSqlCmd* pCmd, SColumnIndex* colIndex);
+SColumnBase* tscColumnBaseInfoInsert(SQueryInfo* pQueryInfo, SColumnIndex* colIndex);
 void         tscColumnFilterInfoCopy(SColumnFilterInfo* dst, const SColumnFilterInfo* src);
 void         tscColumnBaseCopy(SColumnBase* dst, const SColumnBase* src);
 
@@ -162,7 +170,7 @@ int32_t tscValidateName(SSQLToken* pToken);
 
 void tscIncStreamExecutionCount(void* pStream);
 
-bool tscValidateColumnId(SSqlCmd* pCmd, int32_t colId);
+bool tscValidateColumnId(SMeterMetaInfo* pMeterMetaInfo, int32_t colId);
 
 // get starter position of metric query condition (query on tags) in SSqlCmd.payload
 SCond* tsGetMetricQueryCondPos(STagCond* pCond, uint64_t tableIndex);
@@ -171,30 +179,38 @@ void   tsSetMetricQueryCond(STagCond* pTagCond, uint64_t uid, const char* str);
 void tscTagCondCopy(STagCond* dest, const STagCond* src);
 void tscTagCondRelease(STagCond* pCond);
 
-void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SSqlCmd* pCmd);
+void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo);
 
 void tscSetFreeHeatBeat(STscObj* pObj);
 bool tscShouldFreeHeatBeat(SSqlObj* pHb);
 void tscCleanSqlCmd(SSqlCmd* pCmd);
 bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql);
 
-void            tscRemoveAllMeterMetaInfo(SSqlCmd* pCmd, bool removeFromCache);
-SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd* pCmd, int32_t index);
-SMeterMetaInfo* tscGetMeterMetaInfoByUid(SSqlCmd* pCmd, uint64_t uid, int32_t* index);
+void            tscRemoveAllMeterMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool removeFromCache);
+SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
+SMeterMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
+
+SQueryInfo *tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex);
+int32_t tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex, SQueryInfo** pQueryInfo);
+
+SMeterMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index);
 void            tscClearMeterMetaInfo(SMeterMetaInfo* pMeterMetaInfo, bool removeFromCache);
 
-SMeterMetaInfo* tscAddMeterMetaInfo(SSqlCmd* pCmd, const char* name, SMeterMeta* pMeterMeta, SMetricMeta* pMetricMeta,
+SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, SMeterMeta* pMeterMeta, SMetricMeta* pMetricMeta,
                                     int16_t numOfTags, int16_t* tags);
-SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SSqlCmd* pCmd);
+SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo *pQueryInfo);
+int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
+void tscFreeSubqueryInfo(SSqlCmd* pCmd);
+void tscClearSubqueryInfo(SSqlCmd* pCmd);
 
-void tscGetMetricMetaCacheKey(SSqlCmd* pCmd, char* keyStr, uint64_t uid);
-int  tscGetMetricMeta(SSqlObj* pSql);
-int  tscGetMeterMeta(SSqlObj* pSql, char* meterId, int32_t tableIndex);
-int  tscGetMeterMetaEx(SSqlObj* pSql, char* meterId, bool createIfNotExists);
+void tscGetMetricMetaCacheKey(SQueryInfo* pQueryInfo, char* keyStr, uint64_t uid);
+int  tscGetMetricMeta(SSqlObj* pSql, int32_t clauseIndex);
+int  tscGetMeterMeta(SSqlObj* pSql, SMeterMetaInfo* pMeterMetaInfo);
+int  tscGetMeterMetaEx(SSqlObj* pSql, SMeterMetaInfo* pMeterMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
 
-void tscAddTimestampColumn(SSqlCmd* pCmd, int16_t functionId, int16_t tableIndex);
+void tscAddTimestampColumn(SQueryInfo* pQueryInfo, int16_t functionId, int16_t tableIndex);
 void tscDoQuery(SSqlObj* pSql);
 
 /**
@@ -215,9 +231,9 @@ void tscDoQuery(SSqlObj* pSql);
  * @return
  */
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void* param, SSqlObj* pPrevSql);
-void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t tableIndex);
+void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
 
-void doAddGroupColumnForSubquery(SSqlCmd* pCmd, int32_t tagIndex);
+void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);
 
 int16_t tscGetJoinTagColIndexByUid(STagCond* pTagCond, uint64_t uid);
 
@@ -226,7 +242,13 @@ TAOS* taos_connect_a(char* ip, char* user, char* pass, char* db, uint16_t port,
 
 void sortRemoveDuplicates(STableDataBlocks* dataBuf);
 
-void tscPrintSelectClause(SSqlCmd* pCmd);
+void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex);
+
+bool hasMoreVnodesToTry(SSqlObj *pSql);
+void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
+void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
+void tscTryQueryNextClause(SSqlObj* pSql, void (*queryFp)());
+
 
 #ifdef __cplusplus
 }

src/client/inc/tsclient.h

@@ -20,14 +20,6 @@
 extern "C" {
 #endif
 
-#include <errno.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
 #include "os.h"
 #include "taos.h"
 #include "taosmsg.h"
@@ -39,69 +31,8 @@ extern "C" {
 #include "tsqlfunction.h"
 #include "tutil.h"
 
-#define TSC_GET_RESPTR_BASE(res, cmd, col, ord)                     \
-  ((res->data + tscFieldInfoGetOffset(cmd, col) * res->numOfRows) + \
-   (1 - ord.order) * (res->numOfRows - 1) * tscFieldInfoGetField(cmd, col)->bytes)
-
-enum _sql_cmd {
-  TSDB_SQL_SELECT,
-  TSDB_SQL_FETCH,
-  TSDB_SQL_INSERT,
-
-  TSDB_SQL_MGMT,  // the SQL below is for mgmt node
-  TSDB_SQL_CREATE_DB,
-  TSDB_SQL_CREATE_TABLE,
-  TSDB_SQL_DROP_DB,
-  TSDB_SQL_DROP_TABLE,
-  TSDB_SQL_CREATE_ACCT,
-  TSDB_SQL_CREATE_USER,
-  TSDB_SQL_DROP_ACCT,  // 10
-  TSDB_SQL_DROP_USER,
-  TSDB_SQL_ALTER_USER,
-  TSDB_SQL_ALTER_ACCT,
-  TSDB_SQL_ALTER_TABLE,
-  TSDB_SQL_ALTER_DB,
-  TSDB_SQL_CREATE_MNODE,
-  TSDB_SQL_DROP_MNODE,
-  TSDB_SQL_CREATE_DNODE,
-  TSDB_SQL_DROP_DNODE,
-  TSDB_SQL_CFG_DNODE,  // 20
-  TSDB_SQL_CFG_MNODE,
-  TSDB_SQL_SHOW,
-  TSDB_SQL_RETRIEVE,
-  TSDB_SQL_KILL_QUERY,
-  TSDB_SQL_KILL_STREAM,
-  TSDB_SQL_KILL_CONNECTION,
-
-  TSDB_SQL_READ,  // SQL below is for read operation
-  TSDB_SQL_CONNECT,
-  TSDB_SQL_USE_DB,
-  TSDB_SQL_META,  // 30
-  TSDB_SQL_METRIC,
-  TSDB_SQL_MULTI_META,
-  TSDB_SQL_HB,
-
-  TSDB_SQL_LOCAL,  // SQL below for client local
-  TSDB_SQL_DESCRIBE_TABLE,
-  TSDB_SQL_RETRIEVE_METRIC,
-  TSDB_SQL_METRIC_JOIN_RETRIEVE,
-  TSDB_SQL_RETRIEVE_TAGS,
-  /*
-   * build empty result instead of accessing dnode to fetch result
-   * reset the client cache
-   */
-  TSDB_SQL_RETRIEVE_EMPTY_RESULT,
-
-  TSDB_SQL_RESET_CACHE,  // 40
-  TSDB_SQL_SERV_STATUS,
-  TSDB_SQL_CURRENT_DB,
-  TSDB_SQL_SERV_VERSION,
-  TSDB_SQL_CLI_VERSION,
-  TSDB_SQL_CURRENT_USER,
-  TSDB_SQL_CFG_LOCAL,
-
-  TSDB_SQL_MAX
-};
+#define TSC_GET_RESPTR_BASE(res, _queryinfo, col, ord)                     \
+  (res->data + tscFieldInfoGetOffset(_queryinfo, col) * res->numOfRows)
   
 // forward declaration
 struct SSqlInfo;
@@ -182,13 +113,6 @@ typedef struct SColumnBaseInfo {
 
 struct SLocalReducer;
 
-// todo move to utility
-typedef struct SString {
-  int32_t alloc;
-  int32_t n;
-  char *  z;
-} SString;
-
 typedef struct SCond {
   uint64_t uid;
   char *   cond;
@@ -239,13 +163,14 @@ typedef struct STableDataBlocks {
 
   int32_t  rowSize;  // row size for current table
   uint32_t nAllocSize;
+  uint32_t headerSize;    // header for metadata (submit metadata)
   uint32_t size;
 
   /*
    * the metermeta for current table, the metermeta will be used during submit stage, keep a ref
    * to avoid it to be removed from cache
    */
-  SMeterMeta* pMeterMeta;
+  SMeterMeta *pMeterMeta;
 
   union {
     char *filename;
@@ -267,52 +192,69 @@ typedef struct SDataBlockList {
   STableDataBlocks **pData;
 } SDataBlockList;
 
-typedef struct {
-  SOrderVal order;
-  int       command;
-  int       count;  // TODO refactor
-
-  union {
-    bool   existsCheck;  // check if the table exists
-    int8_t showType;     // show command type
-  };
-
-  int8_t          isInsertFromFile;  // load data from file or not
-  bool            import;            // import/insert type
-  uint8_t         msgType;
-  uint16_t        type;  // query type
+typedef struct SQueryInfo {
+  int16_t  command;  // the command may be different for each subclause, so keep it seperately.
+  uint16_t type;     // query/insert/import type
   char     intervalTimeUnit;
+
   int64_t         etime, stime;
   int64_t         nAggTimeInterval;  // aggregation time interval
   int64_t         nSlidingTime;      // sliding window in mseconds
   SSqlGroupbyExpr groupbyExpr;       // group by tags info
 
-  /*
-   * use to keep short request msg and error msg, in such case, SSqlCmd->payload == SSqlCmd->ext;
-   * create table/query/insert operations will exceed the TSDB_SQLCMD_SIZE.
-   *
-   * In such cases, allocate the memory dynamically, and need to free the memory
-   */
-  uint32_t        allocSize;
-  char *          payload;
-  int             payloadLen;
-  short           numOfCols;
   SColumnBaseInfo  colList;
   SFieldInfo       fieldsInfo;
   SSqlExprInfo     exprsInfo;
   SLimitVal        limit;
   SLimitVal        slimit;
-  int64_t         globalLimit;
   STagCond         tagCond;
+  SOrderVal        order;
   int16_t          interpoType;  // interpolate type
   int16_t          numOfTables;
-
-  // submit data blocks branched according to vnode
-  SDataBlockList * pDataBlocks;
   SMeterMetaInfo **pMeterInfo;
   struct STSBuf *  tsBuf;
-  // todo use dynamic allocated memory for defaultVal
-  int64_t defaultVal[TSDB_MAX_COLUMNS];  // default value for interpolation
+  int64_t *        defaultVal;   // default value for interpolation
+  char *           msg;          // pointer to the pCmd->payload to keep error message temporarily
+  int64_t          clauseLimit;  // limit for current sub clause
+  
+  // offset value in the original sql expression, NOT sent to virtual node, only applied at client side
+  int64_t          prjOffset;
+} SQueryInfo;
+
+// data source from sql string or from file
+enum {
+  DATA_FROM_SQL_STRING = 1,
+  DATA_FROM_DATA_FILE = 2,
+};
+
+typedef struct {
+  int     command;
+  uint8_t msgType;
+
+  union {
+    bool   existsCheck;     // check if the table exists or not
+    bool   inStream;        // denote if current sql is executed in stream or not
+    bool   createOnDemand;  // if the table is missing, on-the-fly create it. during getmeterMeta
+    int8_t dataSourceType;  // load data from file or not
+  };
+
+  union {
+    int32_t count;
+    int32_t numOfTablesInSubmit;
+  };
+
+  int32_t  clauseIndex;  // index of multiple subclause query
+  int8_t   isParseFinish;
+  short    numOfCols;
+  uint32_t allocSize;
+  char *   payload;
+  int      payloadLen;
+
+  SQueryInfo **pQueryInfo;
+  int32_t      numOfClause;
+
+  // submit data blocks branched according to vnode
+  SDataBlockList *pDataBlocks;
 
   // for parameter ('?') binding and batch processing
   int32_t batchSize;
@@ -328,12 +270,15 @@ struct STSBuf;
 
 typedef struct {
   uint8_t               code;
-  int                   numOfRows;   // num of results in current retrieved
-  int                   numOfTotal;  // num of total results
+  int64_t               numOfRows;   // num of results in current retrieved
+  int64_t               numOfTotal;  // num of total results
+  int64_t               numOfTotalInCurrentClause;  // num of total result in current subclause
+  
   char *                pRsp;
   int                   rspType;
   int                   rspLen;
   uint64_t              qhandle;
+  int64_t               uid;
   int64_t               useconds;
   int64_t               offset;  // offset value from vnode during projection query of stable
   int                   row;
@@ -380,6 +325,7 @@ typedef struct _sql_obj {
   uint32_t          queryId;
   void *            thandle;
   void *            pStream;
+  void *            pSubscription;
   char *            sqlstr;
   char              retry;
   char              maxRetry;
@@ -391,8 +337,8 @@ typedef struct _sql_obj {
   SSqlCmd           cmd;
   SSqlRes           res;
   uint8_t           numOfSubs;
-  char*             asyncTblPos;
-  void*             pTableHashList;
+  char *            asyncTblPos;
+  void *            pTableHashList;
   struct _sql_obj **pSubs;
   struct _sql_obj * prev, *next;
 } SSqlObj;
@@ -432,9 +378,11 @@ typedef struct {
 } SIpStrList;
 
 // tscSql API
-int tsParseSql(SSqlObj *pSql, char *acct, char *db, bool multiVnodeInsertion);
+int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion);
 
 void tscInitMsgs();
+extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
+
 void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle);
 int   tscProcessSql(SSqlObj *pSql);
 
@@ -453,15 +401,22 @@ int taos_retrieve(TAOS_RES *res);
  * transfer function for metric query in stream computing, the function need to be change
  * before send query message to vnode
  */
-int32_t tscTansformSQLFunctionForMetricQuery(SSqlCmd *pCmd);
-void    tscRestoreSQLFunctionForMetricQuery(SSqlCmd *pCmd);
+int32_t tscTansformSQLFunctionForSTableQuery(SQueryInfo *pQueryInfo);
+void    tscRestoreSQLFunctionForMetricQuery(SQueryInfo *pQueryInfo);
 
 void tscClearSqlMetaInfoForce(SSqlCmd *pCmd);
 
-int32_t tscCreateResPointerInfo(SSqlCmd *pCmd, SSqlRes *pRes);
+int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void    tscDestroyResPointerInfo(SSqlRes *pRes);
 
 void tscFreeSqlCmdData(SSqlCmd *pCmd);
+void tscFreeResData(SSqlObj* pSql);
+
+/**
+ * free query result of the sql object
+ * @param pObj
+ */
+void tscFreeSqlResult(SSqlObj* pSql);
 
 /**
  * only free part of resources allocated during query.
@@ -480,11 +435,13 @@ void tscFreeSqlObj(SSqlObj *pObj);
 void tscCloseTscObj(STscObj *pObj);
 
 void tscProcessMultiVnodesInsert(SSqlObj *pSql);
-void    tscProcessMultiVnodesInsertForFile(SSqlObj *pSql);
+void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql);
 void tscKillMetricQuery(SSqlObj *pSql);
 void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
 bool tscIsUpdateQuery(STscObj *pObj);
-bool    tscHasReachLimitation(SSqlObj* pSql);
+bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
+
+char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
 
 int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *sql);
 
@@ -506,6 +463,8 @@ extern int        tsInsertHeadSize;
 extern int        tscNumOfThreads;
 extern SIpStrList tscMgmtIpList;
 
+typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int numOfRows);
+
 #ifdef __cplusplus
 }
 #endif

src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h

@@ -135,7 +135,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionIm
  * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JI)J
  */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp
-  (JNIEnv *, jobject, jstring, jstring, jstring, jstring, jstring, jlong, jint);
+  (JNIEnv *, jobject, jlong, jboolean, jstring, jstring, jint);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
@@ -143,7 +143,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp
  * Signature: (J)Lcom/taosdata/jdbc/TSDBResultSetRowData;
  */
 JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp
-  (JNIEnv *, jobject, jlong);
+  (JNIEnv *, jobject, jlong, jint);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
@@ -151,7 +151,7 @@ JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp
  * Signature: (J)V
  */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp
-  (JNIEnv *, jobject, jlong);
+  (JNIEnv *, jobject, jlong, jboolean);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector

src/client/src/TSDBJNIConnector.c

@@ -20,6 +20,7 @@
 #include "tscJoinProcess.h"
 #include "tsclient.h"
 #include "tscUtil.h"
+#include "ttime.h"
 
 int __init = 0;
 
@@ -514,92 +515,42 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionIm
   }
 }
 
-JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNIEnv *env, jobject jobj, jstring jhost,
-                                                                             jstring juser, jstring jpass, jstring jdb,
-                                                                             jstring jtable, jlong jtime,
-                                                                             jint jperiod) {
-  TAOS_SUB *tsub;
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNIEnv *env, jobject jobj, jlong con,
+                                                                             jboolean restart, jstring jtopic, jstring jsql, jint jinterval) {
   jlong sub = 0;
-  char *    host = NULL;
-  char *    user = NULL;
-  char *    pass = NULL;
-  char *    db = NULL;
-  char *    table = NULL;
-  int64_t   time = 0;
-  int       period = 0;
+  TAOS *taos = (TAOS *)con;
+  char *topic = NULL;
+  char *sql = NULL;
 
   jniGetGlobalMethod(env);
   jniTrace("jobj:%p, in TSDBJNIConnector_subscribeImp", jobj);
 
-  if (jhost != NULL) {
-    host = (char *)(*env)->GetStringUTFChars(env, jhost, NULL);
-  }
-  if (juser != NULL) {
-    user = (char *)(*env)->GetStringUTFChars(env, juser, NULL);
-  }
-  if (jpass != NULL) {
-    pass = (char *)(*env)->GetStringUTFChars(env, jpass, NULL);
-  }
-  if (jdb != NULL) {
-    db = (char *)(*env)->GetStringUTFChars(env, jdb, NULL);
-  }
-  if (jtable != NULL) {
-    table = (char *)(*env)->GetStringUTFChars(env, jtable, NULL);
+  if (jtopic != NULL) {
+    topic = (char *)(*env)->GetStringUTFChars(env, jtopic, NULL);
   }
-  time = (int64_t)jtime;
-  period = (int)jperiod;
-
-  if (user == NULL) {
-    jniTrace("jobj:%p, user is null, use tsDefaultUser", jobj);
-    user = tsDefaultUser;
-  }
-  if (pass == NULL) {
-    jniTrace("jobj:%p, pass is null, use tsDefaultPass", jobj);
-    pass = tsDefaultPass;
+  if (jsql != NULL) {
+    sql = (char *)(*env)->GetStringUTFChars(env, jsql, NULL);
   }
 
-  jniTrace("jobj:%p, host:%s, user:%s, pass:%s, db:%s, table:%s, time:%d, period:%d", jobj, host, user, pass, db, table,
-           time, period);
-  tsub = taos_subscribe(host, user, pass, db, table, time, period);
+  TAOS_SUB *tsub = taos_subscribe(taos, (int)restart, topic, sql, NULL, NULL, jinterval);
   sub = (jlong)tsub;
 
   if (sub == 0) {
-    jniTrace("jobj:%p, failed to subscribe to db:%s, table:%s", jobj, db, table);
+    jniTrace("jobj:%p, failed to subscribe: topic:%s", jobj, jtopic);
   } else {
-    jniTrace("jobj:%p, successfully subscribe to db:%s, table:%s, sub:%ld, tsub:%p", jobj, db, table, sub, tsub);
+    jniTrace("jobj:%p, successfully subscribe: topic: %s", jobj, jtopic);
   }
 
-  if (host != NULL) (*env)->ReleaseStringUTFChars(env, jhost, host);
-  if (user != NULL && user != tsDefaultUser) (*env)->ReleaseStringUTFChars(env, juser, user);
-  if (pass != NULL && pass != tsDefaultPass) (*env)->ReleaseStringUTFChars(env, jpass, pass);
-  if (db != NULL) (*env)->ReleaseStringUTFChars(env, jdb, db);
-  if (table != NULL) (*env)->ReleaseStringUTFChars(env, jtable, table);
+  if (topic != NULL) (*env)->ReleaseStringUTFChars(env, jtopic, topic);
+  if (sql != NULL) (*env)->ReleaseStringUTFChars(env, jsql, sql);
 
   return sub;
 }
 
-JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *env, jobject jobj, jlong sub) {
-  jniTrace("jobj:%p, in TSDBJNIConnector_consumeImp, sub:%ld", jobj, sub);
-
-  TAOS_SUB *  tsub = (TAOS_SUB *)sub;
-  TAOS_ROW    row = taos_consume(tsub);
-  TAOS_FIELD *fields = taos_fetch_subfields(tsub);
-  int         num_fields = taos_subfields_count(tsub);
-
-  jniGetGlobalMethod(env);
-
-  jniTrace("jobj:%p, check fields:%p, num_fields=%d", jobj, fields, num_fields);
-
+static jobject convert_one_row(JNIEnv *env, TAOS_ROW row, TAOS_FIELD* fields, int num_fields) {
   jobject rowobj = (*env)->NewObject(env, g_rowdataClass, g_rowdataConstructor, num_fields);
   jniTrace("created a rowdata object, rowobj:%p", rowobj);
 
-  if (row == NULL) {
-    jniTrace("jobj:%p, tsub:%p, fields size is %d, fetch row to the end", jobj, tsub, num_fields);
-    return NULL;
-  }
-
-  char tmp[TSDB_MAX_BYTES_PER_ROW] = {0};
-
   for (int i = 0; i < num_fields; i++) {
     if (row[i] == NULL) {
       continue;
@@ -634,6 +585,7 @@ JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNI
       }
         break;
       case TSDB_DATA_TYPE_BINARY: {
+        char tmp[TSDB_MAX_BYTES_PER_ROW] = {0};
         strncpy(tmp, row[i], (size_t) fields[i].bytes);  // handle the case that terminated does not exist
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetStringFp, i, (*env)->NewStringUTF(env, tmp));
 
@@ -651,13 +603,56 @@ JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNI
         break;
     }
   }
-  jniTrace("jobj:%p, rowdata retrieved, rowobj:%p", jobj, rowobj);
   return rowobj;
 }
 
-JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *env, jobject jobj, jlong sub) {
+JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *env, jobject jobj, jlong sub, jint timeout) {
+  jniTrace("jobj:%p, in TSDBJNIConnector_consumeImp, sub:%ld", jobj, sub);
+  jniGetGlobalMethod(env);
+
+  TAOS_SUB *tsub = (TAOS_SUB *)sub;
+  jobject   rows = (*env)->NewObject(env, g_arrayListClass, g_arrayListConstructFp);
+
+  int64_t start = taosGetTimestampMs();
+  int count = 0;
+
+  while (true) {
+    TAOS_RES *  res = taos_consume(tsub);
+    if (res == NULL) {
+      jniError("jobj:%p, tsub:%p, taos_consume returns NULL", jobj, tsub);
+      return NULL;
+    }
+
+    TAOS_FIELD *fields = taos_fetch_fields(res);
+    int         num_fields = taos_num_fields(res);
+    while (true) {
+      TAOS_ROW row = taos_fetch_row(res);
+      if (row == NULL) {
+        break;
+      }
+      jobject rowobj = convert_one_row(env, row, fields, num_fields);
+      (*env)->CallBooleanMethod(env, rows, g_arrayListAddFp, rowobj);
+      count++;
+    }
+
+    if (count > 0) {
+      break;
+    }
+    if (timeout == -1) {
+      continue;
+    }
+    if (((int)(taosGetTimestampMs() - start)) >= timeout) {
+      jniTrace("jobj:%p, sub:%ld, timeout", jobj, sub);
+      break;
+    }
+  }
+
+  return rows;
+}
+
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *env, jobject jobj, jlong sub, jboolean keepProgress) {
   TAOS_SUB *tsub = (TAOS_SUB *)sub;
-  taos_unsubscribe(tsub);
+  taos_unsubscribe(tsub, keepProgress);
 }
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTableSqlImp(JNIEnv *env, jobject jobj,

src/client/src/taos.def

@@ -24,8 +24,6 @@ taos_fetch_row_a
 taos_subscribe
 taos_consume
 taos_unsubscribe
-taos_subfields_count
-taos_fetch_subfields
 taos_open_stream
 taos_close_stream
 taos_fetch_block

src/client/src/tscAst.c

@@ -17,6 +17,7 @@
 #include "taosmsg.h"
 #include "tast.h"
 #include "tlog.h"
+#include "tscSQLParser.h"
 #include "tscSyntaxtreefunction.h"
 #include "tschemautil.h"
 #include "tsdb.h"
@@ -26,7 +27,6 @@
 #include "tstoken.h"
 #include "ttypes.h"
 #include "tutil.h"
-#include "tscSQLParser.h"
 
 /*
  *
@@ -115,6 +115,9 @@ static tSQLSyntaxNode *tSQLSyntaxNodeCreate(SSchema *pSchema, int32_t numOfCols,
     int32_t i = 0;
     if (pToken->type == TK_ID) {
       do {
+        SSQLToken tableToken = {0};
+        extractTableNameFromToken(pToken, &tableToken);
+
         size_t len = strlen(pSchema[i].name);
         if (strncmp(pToken->z, pSchema[i].name, pToken->n) == 0 && pToken->n == len) break;
       } while (++i < numOfCols);
@@ -492,12 +495,12 @@ static void setInitialValueForRangeQueryCondition(tSKipListQueryCond *q, int8_t
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_BINARY: {
       q->upperBnd.nType = type;
-      q->upperBnd.pz = "\0";
+      q->upperBnd.pz = NULL;
       q->upperBnd.nLen = -1;
 
       q->lowerBnd.nType = type;
-      q->lowerBnd.pz = "\0";
-      q->lowerBnd.nLen = 0;
+      q->lowerBnd.pz = NULL;
+      q->lowerBnd.nLen = -1;
     }
   }
 }
@@ -833,7 +836,7 @@ void tSQLBinaryExprCalcTraverse(tSQLBinaryExpr *pExprs, int32_t numOfRows, char
   tSQLSyntaxNode *pRight = pExprs->pRight;
 
   /* the left output has result from the left child syntax tree */
-  char *pLeftOutput = malloc(sizeof(int64_t) * numOfRows);
+  char *pLeftOutput = (char*)malloc(sizeof(int64_t) * numOfRows);
   if (pLeft->nodeType == TSQL_NODE_EXPR) {
     tSQLBinaryExprCalcTraverse(pLeft->pExpr, numOfRows, pLeftOutput, param, order, getSourceDataBlock);
   }

src/client/src/tscAsync.c

@@ -26,19 +26,18 @@
 #include "tutil.h"
 #include "tnote.h"
 
-void tscProcessFetchRow(SSchedMsg *pMsg);
-void tscProcessAsyncRetrieve(void *param, TAOS_RES *tres, int numOfRows);
-static void tscProcessAsyncRetrieveNextVnode(void *param, TAOS_RES *tres, int numOfRows);
-static void tscProcessAsyncContinueRetrieve(void *param, TAOS_RES *tres, int numOfRows);
+static void tscProcessFetchRow(SSchedMsg *pMsg);
+static void tscAsyncQueryRowsForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 
 static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRows, void (*fp)());
 
 /*
- * proxy function to perform sequentially query&retrieve operation.
- * If sql queries upon metric and two-stage merge procedure is not needed,
- * it will sequentially query&retrieve data for all vnodes in pCmd->pMetricMeta
+ * Proxy function to perform sequentially query&retrieve operation.
+ * If sql queries upon a super table and two-stage merge procedure is not involved (when employ the projection
+ * query), it will sequentially query&retrieve data for all vnodes
  */
-static void tscProcessAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows);
+static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows);
+static void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows);
 
 // TODO return the correct error code to client in tscQueueAsyncError
 void taos_query_a(TAOS *taos, const char *sqlstr, void (*fp)(void *, TAOS_RES *, int), void *param) {
@@ -81,7 +80,6 @@ void taos_query_a(TAOS *taos, const char *sqlstr, void (*fp)(void *, TAOS_RES *,
     return;
   }
 
-
   pSql->sqlstr = malloc(sqlLen + 1);
   if (pSql->sqlstr == NULL) {
     tscError("%p failed to malloc sql string buffer", pSql);
@@ -95,9 +93,9 @@ void taos_query_a(TAOS *taos, const char *sqlstr, void (*fp)(void *, TAOS_RES *,
   pRes->numOfRows = 1;
 
   strtolower(pSql->sqlstr, sqlstr);
-  tscTrace("%p Async SQL: %s, pObj:%p", pSql, pSql->sqlstr, pObj);
+  tscDump("%p pObj:%p, Async SQL: %s", pSql, pObj, pSql->sqlstr);
 
-  int32_t code = tsParseSql(pSql, pObj->acctId, pObj->db, true);
+  int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
   if (code != TSDB_CODE_SUCCESS) {
@@ -109,7 +107,7 @@ void taos_query_a(TAOS *taos, const char *sqlstr, void (*fp)(void *, TAOS_RES *,
   tscDoQuery(pSql);
 }
 
-static void tscProcessAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows) {
+static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows) {
   if (tres == NULL) {
     return;
   }
@@ -118,36 +116,32 @@ static void tscProcessAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOf
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  // sequentially retrieve data from remain vnodes first, query vnode specified by vnodeIdx
-  if (numOfRows == 0 && tscProjectionQueryOnMetric(pCmd)) {
-    // vnode is denoted by vnodeIdx, continue to query vnode specified by vnodeIdx
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-    assert(pMeterMetaInfo->vnodeIndex >= 0);
-
-    /* reach the maximum number of output rows, abort */
-    if (pCmd->globalLimit > 0 && pRes->numOfTotal >= pCmd->globalLimit) {
-      (*pSql->fetchFp)(param, tres, 0);
+  if (numOfRows == 0) {
+    if (hasMoreVnodesToTry(pSql)) { // sequentially retrieve data from remain vnodes.
+      tscTryQueryNextVnode(pSql, tscAsyncQueryRowsForNextVnode);
+    } else {
+      /*
+       * all available virtual node has been checked already, now we need to check
+       * for the next subclause queries
+       */
+      if (pCmd->clauseIndex < pCmd->numOfClause - 1) {
+        tscTryQueryNextClause(pSql, tscAsyncQueryRowsForNextVnode);
         return;
       }
 
-    /* update the limit value according to current retrieval results */
-    pCmd->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
-    pCmd->limit.offset = pRes->offset;
-
-    if ((++(pMeterMetaInfo->vnodeIndex)) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
-      tscTrace("%p retrieve data from next vnode:%d", pSql, pMeterMetaInfo->vnodeIndex);
-
-      pSql->cmd.command = TSDB_SQL_SELECT;  // reset flag to launch query first.
+      /*
+       * 1. has reach the limitation
+       * 2. no remain virtual nodes to be retrieved anymore
+       */
+      (*pSql->fetchFp)(param, pSql, 0);
+    }
     
-      tscResetForNextRetrieve(pRes);
-      pSql->fp = tscProcessAsyncRetrieveNextVnode;
-      tscProcessSql(pSql);
     return;
   }
-  } else { // localreducer has handle this situation
+  
+  // local reducer has handle this situation during super table non-projection query.
   if (pCmd->command != TSDB_SQL_RETRIEVE_METRIC) {
-      pRes->numOfTotal += pRes->numOfRows;
-    }
+    pRes->numOfTotalInCurrentClause += pRes->numOfRows;
   }
 
   (*pSql->fetchFp)(param, tres, numOfRows);
@@ -164,7 +158,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
-  if (pRes->qhandle == 0 || numOfRows != 0) {
+  if ((pRes->qhandle == 0 || numOfRows != 0) && pCmd->command < TSDB_SQL_LOCAL) {
     if (pRes->qhandle == 0) {
       tscError("qhandle is NULL");
     } else {
@@ -183,14 +177,18 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
 }
 
 /*
- * retrieve callback for fetch rows proxy. It serves as the callback function of querying vnode
+ * retrieve callback for fetch rows proxy.
+ * The below two functions both serve as the callback function of query virtual node.
+ * query callback first, and then followed by retrieve callback
  */
-static void tscProcessAsyncRetrieveNextVnode(void *param, TAOS_RES *tres, int numOfRows) {
-  tscProcessAsyncRetrieveImpl(param, tres, numOfRows, tscProcessAsyncFetchRowsProxy);
+static void tscAsyncQueryRowsForNextVnode(void *param, TAOS_RES *tres, int numOfRows) {
+  // query completed, continue to retrieve
+  tscProcessAsyncRetrieveImpl(param, tres, numOfRows, tscAsyncFetchRowsProxy);
 }
 
-static void tscProcessAsyncContinueRetrieve(void *param, TAOS_RES *tres, int numOfRows) {
-  tscProcessAsyncRetrieveImpl(param, tres, numOfRows, tscProcessAsyncRetrieve);
+void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows) {
+  // query completed, continue to retrieve
+  tscProcessAsyncRetrieveImpl(param, tres, numOfRows, tscAsyncFetchSingleRowProxy);
 }
 
 void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), void *param) {
@@ -213,7 +211,7 @@ void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), voi
 
   // user-defined callback function is stored in fetchFp
   pSql->fetchFp = fp;
-  pSql->fp = tscProcessAsyncFetchRowsProxy;
+  pSql->fp = tscAsyncFetchRowsProxy;
 
   pSql->param = param;
   tscResetForNextRetrieve(pRes);
@@ -248,8 +246,12 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
   
   if (pRes->row >= pRes->numOfRows) {
     tscResetForNextRetrieve(pRes);
-    pSql->fp = tscProcessAsyncRetrieve;
+    pSql->fp = tscAsyncFetchSingleRowProxy;
+    
+    if (pCmd->command != TSDB_SQL_RETRIEVE_METRIC && pCmd->command < TSDB_SQL_LOCAL) {
       pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
+    }
+    
     tscProcessSql(pSql);
   } else {
     SSchedMsg schedMsg;
@@ -261,47 +263,31 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
   }
 }
 
-void tscProcessAsyncRetrieve(void *param, TAOS_RES *tres, int numOfRows) {
+void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows) {
   SSqlObj *pSql = (SSqlObj *)tres;
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  
   if (numOfRows == 0) {
-    // sequentially retrieve data from remain vnodes.
-    if (tscProjectionQueryOnMetric(pCmd)) {
+    if (hasMoreVnodesToTry(pSql)) {     // sequentially retrieve data from remain vnodes.
+      tscTryQueryNextVnode(pSql, tscAsyncQuerySingleRowForNextVnode);
+    } else {
       /*
-       * vnode is denoted by vnodeIdx, continue to query vnode specified by vnodeIdx till all vnode have been retrieved
+       * 1. has reach the limitation
+       * 2. no remain virtual nodes to be retrieved anymore
        */
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-      assert(pMeterMetaInfo->vnodeIndex >= 0);
-
-      /* reach the maximum number of output rows, abort */
-      if (pCmd->globalLimit > 0 && pRes->numOfTotal >= pCmd->globalLimit) {
       (*pSql->fetchFp)(pSql->param, pSql, NULL);
-        return;
     }
-
-      /* update the limit value according to current retrieval results */
-      pCmd->limit.limit = pCmd->globalLimit - pRes->numOfTotal;
-
-      if ((++pMeterMetaInfo->vnodeIndex) <= pMeterMetaInfo->pMetricMeta->numOfVnodes) {
-        pSql->cmd.command = TSDB_SQL_SELECT;  // reset flag to launch query first.
-
-        tscResetForNextRetrieve(pRes);
-        pSql->fp = tscProcessAsyncContinueRetrieve;
-        tscProcessSql(pSql);
     return;
   }
-    } else {
-      (*pSql->fetchFp)(pSql->param, pSql, NULL);
-    }
-  } else {
+  
   for (int i = 0; i < pCmd->numOfCols; ++i)
-      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) + pRes->bytes[i] * pRes->row;
+    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
   pRes->row++;
 
   (*pSql->fetchFp)(pSql->param, pSql, pSql->res.tsrow);
-  }
 }
 
 void tscProcessFetchRow(SSchedMsg *pMsg) {
@@ -309,10 +295,13 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
   
-  for (int i = 0; i < pCmd->numOfCols; ++i)
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pCmd, i, pCmd->order) + pRes->bytes[i] * pRes->row;
-  pRes->row++;
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
 
+  for (int i = 0; i < pCmd->numOfCols; ++i) {
+    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
+  }
+  
+  pRes->row++;
   (*pSql->fetchFp)(pSql->param, pSql, pRes->tsrow);
 }
 
@@ -371,7 +360,7 @@ void tscQueueAsyncRes(SSqlObj *pSql) {
     tscTrace("%p SqlObj is freed, not add into queue async res", pSql);
     return;
   } else {
-    tscTrace("%p add into queued async res, code:%d", pSql, pSql->res.code);
+    tscError("%p add into queued async res, code:%d", pSql, pSql->res.code);
   }
 
   SSchedMsg schedMsg;
@@ -404,10 +393,13 @@ void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows)
   SSqlCmd *pCmd = &pSql->cmd;
   int32_t  code = TSDB_CODE_SUCCESS;
 
-  assert(!pCmd->isInsertFromFile && pSql->signature == pSql);
+  assert(pCmd->dataSourceType != 0 && pSql->signature == pSql);
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-  assert(pCmd->numOfTables == 1);
+  int32_t index = 0;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, index);
+  
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  assert(pQueryInfo->numOfTables == 1 || pQueryInfo->numOfTables == 2);
   
   SDataBlockList *pDataBlocks = pCmd->pDataBlocks;
   if (pDataBlocks == NULL || pMeterMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
@@ -444,7 +436,6 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
   SSqlObj *pSql = (SSqlObj *)param;
   if (pSql == NULL || pSql->signature != pSql) return;
 
-  STscObj *pObj = pSql->pTscObj;
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
@@ -465,9 +456,10 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
       tscTrace("%p renew meterMeta successfully, command:%d, code:%d, thandle:%p, retry:%d",
           pSql, pSql->cmd.command, pSql->res.code, pSql->thandle, pSql->retry);
   
-      assert(tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta == NULL);
-      tscGetMeterMeta(pSql, tscGetMeterMetaInfo(&pSql->cmd, 0)->name, 0);
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+      assert(pMeterMetaInfo->pMeterMeta == NULL);
       
+      tscGetMeterMeta(pSql, pMeterMetaInfo);
       code = tscSendMsgToServer(pSql);
       if (code != 0) {
         pRes->code = code;
@@ -485,49 +477,65 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
   }
 
   if (pSql->pStream == NULL) {
-    // check if it is a sub-query of metric query first, if true, enter another routine
-    if ((pSql->cmd.type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) == TSDB_QUERY_TYPE_STABLE_SUBQUERY) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+    // check if it is a sub-query of super table query first, if true, enter another routine
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  
+    if ((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) == TSDB_QUERY_TYPE_STABLE_SUBQUERY) {
+      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
       assert(pMeterMetaInfo->pMeterMeta->numOfTags != 0 && pMeterMetaInfo->vnodeIndex >= 0 && pSql->param != NULL);
 
       SRetrieveSupport *trs = (SRetrieveSupport *)pSql->param;
       SSqlObj *         pParObj = trs->pParentSqlObj;
+      
       assert(pParObj->signature == pParObj && trs->subqueryIndex == pMeterMetaInfo->vnodeIndex &&
           pMeterMetaInfo->pMeterMeta->numOfTags != 0);
 
-      tscTrace("%p get metricMeta during metric query successfully", pSql);
+      tscTrace("%p get metricMeta during super table query successfully", pSql);
       
-      code = tscGetMeterMeta(pSql, tscGetMeterMetaInfo(&pSql->cmd, 0)->name, 0);
+      code = tscGetMeterMeta(pSql, pMeterMetaInfo);
       pRes->code = code;
 
       if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
-      code = tscGetMetricMeta(pSql);
+      code = tscGetMetricMeta(pSql, 0);
       pRes->code = code;
 
       if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
     } else {  // normal async query continues
-      code = tsParseSql(pSql, pObj->acctId, pObj->db, false);
+      if (pCmd->isParseFinish) {
+        tscTrace("%p resend data to vnode in metermeta callback since sql has been parsed completed", pSql);
+        
+        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+        code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+        assert(code == TSDB_CODE_SUCCESS);
+      
+        if (pMeterMetaInfo->pMeterMeta) {
+          code = tscSendMsgToServer(pSql);
+          if (code == TSDB_CODE_SUCCESS) return;
+        }
+      } else {
+        code = tsParseSql(pSql, false);
         if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
       }
+    }
 
   } else {  // stream computing
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-    code = tscGetMeterMeta(pSql, pMeterMetaInfo->name, 0);
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+    code = tscGetMeterMeta(pSql, pMeterMetaInfo);
     pRes->code = code;
 
     if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
-    pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
-      code = tscGetMetricMeta(pSql);
+    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+      code = tscGetMetricMeta(pSql, pCmd->clauseIndex);
       pRes->code = code;
 
       if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
     }
   }
 
-  if (code != 0) {
+  if (code != TSDB_CODE_SUCCESS) {
+    pSql->res.code = code;
     tscQueueAsyncRes(pSql);
     return;
   }
@@ -536,10 +544,12 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     tscTrace("%p stream:%p meta is updated, start new query, command:%d", pSql, pSql->pStream, pSql->cmd.command);
     /*
      * NOTE:
-     * transfer the sql function for metric query before get meter/metric meta,
+     * transfer the sql function for super table query before get meter/metric meta,
      * since in callback functions, only tscProcessSql(pStream->pSql) is executed!
      */
-    tscTansformSQLFunctionForMetricQuery(&pSql->cmd);
+    SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+    
+    tscTansformSQLFunctionForSTableQuery(pQueryInfo);
     tscIncStreamExecutionCount(pSql->pStream);
   } else {
     tscTrace("%p get meterMeta/metricMeta successfully", pSql);

src/client/src/tscCache.c

@@ -96,11 +96,7 @@ void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, uint16_t port,
   pObj = (SConnCache *)handle;
   if (pObj == NULL || pObj->maxSessions == 0) return NULL;
 
-#ifdef CLUSTER
-  if (data == NULL || ip == 0) {
-#else
   if (data == NULL) {
-#endif
     tscTrace("data:%p ip:%p:%d not valid, not added in cache", data, ip, port);
     return NULL;
   }

src/client/src/tscLocal.c

@@ -77,7 +77,7 @@ static int32_t getToStringLength(const char *pData, int32_t length, int32_t type
  * length((uint64_t) 123456789011) > 12, greater than sizsof(uint64_t)
  */
 static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) {
-  SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta;
+  SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta;
 
   if (pMeta->meterType == TSDB_METER_METRIC || pMeta->meterType == TSDB_METER_OTABLE ||
       pMeta->meterType == TSDB_METER_STABLE) {
@@ -106,8 +106,9 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSqlRes *pRes = &pSql->res;
 
   // one column for each row
-  SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   SMeterMeta *    pMeta = pMeterMetaInfo->pMeterMeta;
 
   /*
@@ -119,7 +120,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   int32_t numOfRows = pMeta->numOfColumns;
   int32_t totalNumOfRows = numOfRows + pMeta->numOfTags;
 
-  if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
     numOfRows = pMeta->numOfColumns + pMeta->numOfTags;
   }
 
@@ -127,31 +128,31 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSchema *pSchema = tsGetSchema(pMeta);
 
   for (int32_t i = 0; i < numOfRows; ++i) {
-    TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
+    TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
             TSDB_COL_NAME_LEN);
 
     char *type = tDataTypeDesc[pSchema[i].type].aName;
 
-    pField = tscFieldInfoGetField(pCmd, 1);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
+    pField = tscFieldInfoGetField(pQueryInfo, 1);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
 
     int32_t bytes = pSchema[i].bytes;
     if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
       bytes = bytes / TSDB_NCHAR_SIZE;
     }
 
-    pField = tscFieldInfoGetField(pCmd, 2);
-    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pCmd, 2) * totalNumOfRows + pField->bytes * i) = bytes;
+    pField = tscFieldInfoGetField(pQueryInfo, 2);
+    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 2) * totalNumOfRows + pField->bytes * i) = bytes;
 
-    pField = tscFieldInfoGetField(pCmd, 3);
+    pField = tscFieldInfoGetField(pQueryInfo, 3);
     if (i >= pMeta->numOfColumns && pMeta->numOfTags != 0) {
-      strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 3) * totalNumOfRows + pField->bytes * i, "tag",
+      strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i, "tag",
               strlen("tag") + 1);
     }
   }
 
-  if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
     return 0;
   }
 
@@ -159,27 +160,27 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   char *pTagValue = tsGetTagsValue(pMeta);
   for (int32_t i = numOfRows; i < totalNumOfRows; ++i) {
     // field name
-    TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
+    TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * totalNumOfRows + pField->bytes * i, pSchema[i].name,
             TSDB_COL_NAME_LEN);
 
     // type name
-    pField = tscFieldInfoGetField(pCmd, 1);
+    pField = tscFieldInfoGetField(pQueryInfo, 1);
     char *type = tDataTypeDesc[pSchema[i].type].aName;
-    strncpy(pRes->data + tscFieldInfoGetOffset(pCmd, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
+    strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * totalNumOfRows + pField->bytes * i, type, pField->bytes);
 
     // type length
     int32_t bytes = pSchema[i].bytes;
-    pField = tscFieldInfoGetField(pCmd, 2);
+    pField = tscFieldInfoGetField(pQueryInfo, 2);
     if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
       bytes = bytes / TSDB_NCHAR_SIZE;
     }
 
-    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pCmd, 2) * totalNumOfRows + pField->bytes * i) = bytes;
+    *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 2) * totalNumOfRows + pField->bytes * i) = bytes;
 
     // tag value
-    pField = tscFieldInfoGetField(pCmd, 3);
-    char *target = pRes->data + tscFieldInfoGetOffset(pCmd, 3) * totalNumOfRows + pField->bytes * i;
+    pField = tscFieldInfoGetField(pQueryInfo, 3);
+    char *target = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i;
 
     if (isNull(pTagValue, pSchema[i].type)) {
       sprintf(target, "%s", TSDB_DATA_NULL_STR);
@@ -236,25 +237,28 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->numOfCols = numOfCols;
 
-  pCmd->order.order = TSQL_SO_ASC;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  pQueryInfo->order.order = TSQL_SO_ASC;
 
-  tscFieldInfoSetValue(&pCmd->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, "Field", TSDB_COL_NAME_LEN);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, "Field", TSDB_COL_NAME_LEN);
   rowLen += TSDB_COL_NAME_LEN;
 
-  tscFieldInfoSetValue(&pCmd->fieldsInfo, 1, TSDB_DATA_TYPE_BINARY, "Type", typeColLength);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 1, TSDB_DATA_TYPE_BINARY, "Type", typeColLength);
   rowLen += typeColLength;
 
-  tscFieldInfoSetValue(&pCmd->fieldsInfo, 2, TSDB_DATA_TYPE_INT, "Length", sizeof(int32_t));
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 2, TSDB_DATA_TYPE_INT, "Length", sizeof(int32_t));
   rowLen += sizeof(int32_t);
 
-  tscFieldInfoSetValue(&pCmd->fieldsInfo, 3, TSDB_DATA_TYPE_BINARY, "Note", noteColLength);
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 3, TSDB_DATA_TYPE_BINARY, "Note", noteColLength);
   rowLen += noteColLength;
 
   return rowLen;
 }
 
 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
-  assert(tscGetMeterMetaInfo(&pSql->cmd, 0)->pMeterMeta != NULL);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  assert(tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta != NULL);
 
   const int32_t NUM_OF_DESCRIBE_TABLE_COLUMNS = 4;
   const int32_t TYPE_COLUMN_LENGTH = 16;
@@ -267,7 +271,7 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
 
   int32_t rowLen =
       tscBuildMeterSchemaResultFields(pSql, NUM_OF_DESCRIBE_TABLE_COLUMNS, TYPE_COLUMN_LENGTH, note_field_length);
-  tscFieldInfoCalOffset(&pSql->cmd);
+  tscFieldInfoCalOffset(pQueryInfo);
   return tscSetValueToResObj(pSql, rowLen);
 }
 
@@ -277,7 +281,9 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   // only need to reorganize the results in the column format
   SSqlCmd *       pCmd = &pSql->cmd;
   SSqlRes *       pRes = &pSql->res;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   SMetricMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
   SSchema *    pSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
@@ -294,7 +300,7 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   }
 
   int32_t totalNumOfResults = pMetricMeta->numOfMeters;
-  int32_t rowLen = tscGetResRowLength(pCmd);
+  int32_t rowLen = tscGetResRowLength(pQueryInfo);
 
   tscInitResObjForLocalQuery(pSql, totalNumOfResults, rowLen);
 
@@ -305,16 +311,16 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
     for (int32_t j = 0; j < pSidList->numOfSids; ++j) {
       SMeterSidExtInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
       
-      for (int32_t k = 0; k < pCmd->fieldsInfo.numOfOutputCols; ++k) {
-        SColIndexEx *pColIndex = &tscSqlExprGet(pCmd, k)->colInfo;
+      for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
+        SColIndexEx *pColIndex = &tscSqlExprGet(pQueryInfo, k)->colInfo;
         int16_t      offsetId = pColIndex->colIdx;
 
         assert((pColIndex->flag & TSDB_COL_TAG) != 0);
 
         char *      val = pSidExt->tags + vOffset[offsetId];
-        TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, k);
+        TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
-        memcpy(pRes->data + tscFieldInfoGetOffset(pCmd, k) * totalNumOfResults + pField->bytes * rowIdx, val,
+        memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, k) * totalNumOfResults + pField->bytes * rowIdx, val,
                (size_t)pField->bytes);
       }
       rowIdx++;
@@ -328,21 +334,23 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
-  SMetricMeta *pMetricMeta = tscGetMeterMetaInfo(pCmd, 0)->pMetricMeta;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMetricMeta *pMetricMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMetricMeta;
   int32_t      totalNumOfResults = 1;  // count function only produce one result
-  int32_t      rowLen = tscGetResRowLength(pCmd);
+  int32_t      rowLen = tscGetResRowLength(pQueryInfo);
 
   tscInitResObjForLocalQuery(pSql, totalNumOfResults, rowLen);
 
   int32_t rowIdx = 0;
   for (int32_t i = 0; i < totalNumOfResults; ++i) {
-    for (int32_t k = 0; k < pCmd->fieldsInfo.numOfOutputCols; ++k) {
-      SSqlExpr *pExpr = tscSqlExprGet(pCmd, i);
+    for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
+      SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
 
       if (pExpr->colInfo.colIdx == -1 && pExpr->functionId == TSDB_FUNC_COUNT) {
-        TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, k);
+        TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
-        memcpy(pRes->data + tscFieldInfoGetOffset(pCmd, i) * totalNumOfResults + pField->bytes * rowIdx,
+        memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, i) * totalNumOfResults + pField->bytes * rowIdx,
                &pMetricMeta->numOfMeters, sizeof(pMetricMeta->numOfMeters));
       } else {
         tscError("not support operations");
@@ -358,14 +366,16 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
 static int tscProcessQueryTags(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   
-  SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, 0)->pMeterMeta;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
+  
+  SMeterMeta *pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta;
   if (pMeterMeta == NULL || pMeterMeta->numOfTags == 0 || pMeterMeta->numOfColumns == 0) {
     strcpy(pCmd->payload, "invalid table");
     pSql->res.code = TSDB_CODE_INVALID_TABLE;
     return pSql->res.code;
   }
 
-  SSqlExpr *pExpr = tscSqlExprGet(pCmd, 0);
+  SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, 0);
   if (pExpr->functionId == TSDB_FUNC_COUNT) {
     return tscBuildMetricTagSqlFunctionResult(pSql);
   } else {
@@ -374,7 +384,9 @@ static int tscProcessQueryTags(SSqlObj *pSql) {
 }
 
 static void tscProcessCurrentUser(SSqlObj *pSql) {
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, pSql->pTscObj->user, pExpr->aliasName, TSDB_USER_LEN);
 }
 
@@ -387,19 +399,24 @@ static void tscProcessCurrentDB(SSqlObj *pSql) {
     setNull(db, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN);
   }
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, db, pExpr->aliasName, TSDB_DB_NAME_LEN);
 }
 
 static void tscProcessServerVer(SSqlObj *pSql) {
   const char* v = pSql->pTscObj->sversion;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, v, pExpr->aliasName, tListLen(pSql->pTscObj->sversion));
 }
 
 static void tscProcessClientVer(SSqlObj *pSql) {
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, version, pExpr->aliasName, strlen(version));
 }
 
@@ -417,7 +434,9 @@ static void tscProcessServStatus(SSqlObj *pSql) {
     }
   }
   
-  SSqlExpr* pExpr = tscSqlExprGet(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  
+  SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, 0);
   tscSetLocalQueryResult(pSql, "1", pExpr->aliasName, 2);
 }
 
@@ -426,12 +445,16 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
   SSqlRes *pRes = &pSql->res;
 
   pCmd->numOfCols = 1;
-  pCmd->order.order = TSQL_SO_ASC;
   
-  tscFieldInfoSetValue(&pCmd->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, columnName, valueLength);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+  pQueryInfo->order.order = TSQL_SO_ASC;
+  
+  tscClearFieldInfo(&pQueryInfo->fieldsInfo);
+  
+  tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 0, TSDB_DATA_TYPE_BINARY, columnName, valueLength);
   tscInitResObjForLocalQuery(pSql, 1, valueLength);
 
-  TAOS_FIELD *pField = tscFieldInfoGetField(pCmd, 0);
+  TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
   strncpy(pRes->data, val, pField->bytes);
 }
 

src/client/src/tscPrepare.c

@@ -22,7 +22,7 @@
 #include "tstrbuild.h"
 
 
-int tsParseInsertSql(SSqlObj *pSql, char *sql, char *acct, char *db);
+int tsParseInsertSql(SSqlObj *pSql);
 int taos_query_imp(STscObj* pObj, SSqlObj* pSql);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -385,12 +385,11 @@ static int insertStmtAddBatch(STscStmt* stmt) {
 }
 
 static int insertStmtPrepare(STscStmt* stmt) {
-  STscObj* taos = stmt->taos;
   SSqlObj *pSql = stmt->pSql;
   pSql->cmd.numOfParams = 0;
   pSql->cmd.batchSize = 0;
 
-  return tsParseInsertSql(pSql, pSql->sqlstr, taos->acctId, taos->db);
+  return tsParseInsertSql(pSql);
 }
 
 static int insertStmtReset(STscStmt* pStmt) {
@@ -409,7 +408,7 @@ static int insertStmtReset(STscStmt* pStmt) {
   }
   pCmd->batchSize = 0;
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
   pMeterMetaInfo->vnodeIndex = 0;
   return TSDB_CODE_SUCCESS;
 }
@@ -423,7 +422,8 @@ static int insertStmtExecute(STscStmt* stmt) {
     ++pCmd->batchSize;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
+  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  assert(pCmd->numOfClause == 1);
   
   if (pCmd->pDataBlocks->nSize > 0) {
     // merge according to vgid
@@ -448,6 +448,8 @@ static int insertStmtExecute(STscStmt* stmt) {
   SSqlRes *pRes = &pSql->res;
   pRes->numOfRows = 0;
   pRes->numOfTotal = 0;
+  pRes->numOfTotalInCurrentClause = 0;
+  
   pRes->qhandle = 0;
   pSql->thandle = NULL;