Merge branch 'main' into test/TD-23715

cmake/apr-util_CMakeLists.txt.in

@@ -0,0 +1,19 @@
+# apr-util
+ExternalProject_Add(aprutil-1
+        URL https://dlcdn.apache.org//apr/apr-util-1.6.3.tar.gz
+        URL_HASH SHA256=2b74d8932703826862ca305b094eef2983c27b39d5c9414442e9976a9acf1983
+        DOWNLOAD_NO_PROGRESS 1
+        DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download"
+        #GIT_REPOSITORY https://github.com/apache/apr-util.git
+	#GIT_TAG 1.5.4
+        SOURCE_DIR "${TD_CONTRIB_DIR}/apr-util"
+        #BINARY_DIR ""
+        BUILD_IN_SOURCE TRUE
+        BUILD_ALWAYS 1
+        #UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ./configure --prefix=$ENV{HOME}/.cos-local.1/ --with-apr=$ENV{HOME}/.cos-local.1 
+        #CONFIGURE_COMMAND ./configure --with-apr=/usr/local/apr
+        BUILD_COMMAND make
+        INSTALL_COMMAND make install
+        TEST_COMMAND ""
+)

cmake/apr_CMakeLists.txt.in

@@ -0,0 +1,19 @@
+# apr
+ExternalProject_Add(apr-1
+        URL https://dlcdn.apache.org//apr/apr-1.7.4.tar.gz
+        URL_HASH SHA256=a4137dd82a185076fa50ba54232d920a17c6469c30b0876569e1c2a05ff311d9
+        DOWNLOAD_NO_PROGRESS 1
+        DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download"
+        #GIT_REPOSITORY https://github.com/apache/apr.git
+	#GIT_TAG 1.5.2
+        SOURCE_DIR "${TD_CONTRIB_DIR}/apr"
+        BUILD_IN_SOURCE TRUE
+        UPDATE_DISCONNECTED TRUE
+        BUILD_ALWAYS 1
+        #UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ./configure --prefix=$ENV{HOME}/.cos-local.1/ --enable-shared=no
+        #CONFIGURE_COMMAND ./configure
+        BUILD_COMMAND make
+        INSTALL_COMMAND make install
+        TEST_COMMAND ""
+)

cmake/cmake.define

@@ -77,6 +77,12 @@ ELSE ()
     SET(TD_TAOS_TOOLS TRUE)
 ENDIF ()
 
+IF (${TD_WINDOWS})
+    SET(TAOS_LIB taos_static)
+ELSE ()
+    SET(TAOS_LIB taos)
+ENDIF ()
+
 IF (TD_WINDOWS)
     MESSAGE("${Yellow} set compiler flag for Windows! ${ColourReset}")
     SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi /MTd")

cmake/cmake.options

@@ -125,6 +125,16 @@ option(
     ON
 )
 
+IF(${TD_LINUX})
+
+option(
+    BUILD_WITH_COS
+    "If build with cos"
+    ON
+)
+
+ENDIF ()
+
 option(
     BUILD_WITH_SQLITE
     "If build with sqlite" 

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.1.0.4.alpha")
+  SET(TD_VER_NUMBER "3.1.2.0.alpha")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

cmake/cos_CMakeLists.txt.in

@@ -0,0 +1,12 @@
+# cos
+ExternalProject_Add(cos
+        GIT_REPOSITORY https://github.com/tencentyun/cos-c-sdk-v5.git
+	GIT_TAG v5.0.16
+        SOURCE_DIR "${TD_CONTRIB_DIR}/cos-c-sdk-v5"
+        BINARY_DIR ""
+        #BUILD_IN_SOURCE TRUE
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+)

cmake/curl_CMakeLists.txt.in

@@ -0,0 +1,17 @@
+# curl
+ExternalProject_Add(curl
+        URL  https://curl.se/download/curl-8.2.1.tar.gz
+        DOWNLOAD_NO_PROGRESS 1
+        DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download"
+        #GIT_REPOSITORY https://github.com/curl/curl.git
+        #GIT_TAG curl-7_88_1
+        SOURCE_DIR "${TD_CONTRIB_DIR}/curl"
+        BUILD_IN_SOURCE TRUE
+        BUILD_ALWAYS 1
+        #UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ./configure --prefix=$ENV{HOME}/.cos-local.1 --without-ssl --enable-shared=no --disable-ldap --disable-ldaps --without-brotli --without-zstd
+        #CONFIGURE_COMMAND ./configure --without-ssl
+        BUILD_COMMAND make
+        INSTALL_COMMAND make install
+        TEST_COMMAND ""
+)

cmake/mxml_CMakeLists.txt.in

@@ -0,0 +1,14 @@
+# cos
+ExternalProject_Add(mxml
+        GIT_REPOSITORY https://github.com/michaelrsweet/mxml.git
+	GIT_TAG release-2.12
+        SOURCE_DIR "${TD_CONTRIB_DIR}/mxml"
+        #BINARY_DIR ""
+        BUILD_IN_SOURCE TRUE
+        #UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ./configure --prefix=$ENV{HOME}/.cos-local.1 --enable-shared=no
+        #CONFIGURE_COMMAND ./configure
+        BUILD_COMMAND make
+        INSTALL_COMMAND make install
+        TEST_COMMAND ""
+)

contrib/CMakeLists.txt

@@ -6,6 +6,39 @@ function(cat IN_FILE OUT_FILE)
     file(APPEND ${OUT_FILE} "${CONTENTS}")
 endfunction(cat IN_FILE OUT_FILE)
 
+if(${TD_LINUX})
+
+set(CONTRIB_TMP_FILE3 "${CMAKE_BINARY_DIR}/deps_tmp_CMakeLists.txt.in3")
+configure_file("${TD_SUPPORT_DIR}/deps_CMakeLists.txt.in" ${CONTRIB_TMP_FILE3})
+
+if(${BUILD_WITH_COS})
+    file(MAKE_DIRECTORY $ENV{HOME}/.cos-local.1/)
+    cat("${TD_SUPPORT_DIR}/mxml_CMakeLists.txt.in" ${CONTRIB_TMP_FILE3})
+    cat("${TD_SUPPORT_DIR}/apr_CMakeLists.txt.in" ${CONTRIB_TMP_FILE3})
+    cat("${TD_SUPPORT_DIR}/curl_CMakeLists.txt.in" ${CONTRIB_TMP_FILE3})
+endif(${BUILD_WITH_COS})
+
+configure_file(${CONTRIB_TMP_FILE3} "${TD_CONTRIB_DIR}/deps-download/CMakeLists.txt")
+execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
+        WORKING_DIRECTORY "${TD_CONTRIB_DIR}/deps-download")
+execute_process(COMMAND "${CMAKE_COMMAND}" --build .
+        WORKING_DIRECTORY "${TD_CONTRIB_DIR}/deps-download")
+
+set(CONTRIB_TMP_FILE2 "${CMAKE_BINARY_DIR}/deps_tmp_CMakeLists.txt.in2")
+configure_file("${TD_SUPPORT_DIR}/deps_CMakeLists.txt.in" ${CONTRIB_TMP_FILE2})
+
+if(${BUILD_WITH_COS})
+    cat("${TD_SUPPORT_DIR}/apr-util_CMakeLists.txt.in" ${CONTRIB_TMP_FILE2})
+endif(${BUILD_WITH_COS})
+
+configure_file(${CONTRIB_TMP_FILE2} "${TD_CONTRIB_DIR}/deps-download/CMakeLists.txt")
+execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
+        WORKING_DIRECTORY "${TD_CONTRIB_DIR}/deps-download")
+execute_process(COMMAND "${CMAKE_COMMAND}" --build .
+        WORKING_DIRECTORY "${TD_CONTRIB_DIR}/deps-download")
+
+endif(${TD_LINUX})
+
 set(CONTRIB_TMP_FILE "${CMAKE_BINARY_DIR}/deps_tmp_CMakeLists.txt.in")
 configure_file("${TD_SUPPORT_DIR}/deps_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 
@@ -122,6 +155,16 @@ if(${BUILD_WITH_SQLITE})
     cat("${TD_SUPPORT_DIR}/sqlite_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif(${BUILD_WITH_SQLITE})
 
+# cos
+if(${BUILD_WITH_COS})
+    #cat("${TD_SUPPORT_DIR}/mxml_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    #cat("${TD_SUPPORT_DIR}/apr_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    #cat("${TD_SUPPORT_DIR}/apr-util_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    #cat("${TD_SUPPORT_DIR}/curl_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    cat("${TD_SUPPORT_DIR}/cos_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+    add_definitions(-DUSE_COS)
+endif(${BUILD_WITH_COS})
+
 # lucene
 if(${BUILD_WITH_LUCENE})
     cat("${TD_SUPPORT_DIR}/lucene_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
@@ -347,6 +390,31 @@ if (${BUILD_WITH_ROCKSDB})
     endif()
 endif()
 
+# cos
+if(${BUILD_WITH_COS})
+  if(${TD_LINUX})
+    set(CMAKE_PREFIX_PATH $ENV{HOME}/.cos-local.1)
+    #ADD_DEFINITIONS(-DMINIXML_LIBRARY=${CMAKE_BINARY_DIR}/build/lib/libxml.a)
+    option(ENABLE_TEST "Enable the tests" OFF)
+    INCLUDE_DIRECTORIES($ENV{HOME}/.cos-local.1/include)
+    MESSAGE("$ENV{HOME}/.cos-local.1/include")
+
+    set(CMAKE_BUILD_TYPE debug)
+    set(ORIG_CMAKE_PROJECT_NAME ${CMAKE_PROJECT_NAME})
+    set(CMAKE_PROJECT_NAME cos_c_sdk)
+
+    add_subdirectory(cos-c-sdk-v5 EXCLUDE_FROM_ALL)
+    target_include_directories(
+      cos_c_sdk
+      PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cos-c-sdk-v5/cos_c_sdk>
+      )
+
+    set(CMAKE_PROJECT_NAME ${ORIG_CMAKE_PROJECT_NAME})
+  else()
+
+  endif(${TD_LINUX})
+endif(${BUILD_WITH_COS})
+
 # lucene
 # To support build on ubuntu: sudo apt-get install libboost-all-dev
 if(${BUILD_WITH_LUCENE})

contrib/test/CMakeLists.txt

@@ -3,6 +3,11 @@ if(${BUILD_WITH_ROCKSDB})
     add_subdirectory(rocksdb)
 endif(${BUILD_WITH_ROCKSDB})
 
+# cos
+if(${BUILD_WITH_COS})
+    add_subdirectory(cos)
+endif(${BUILD_WITH_COS})
+
 if(${BUILD_WITH_LUCENE})
     add_subdirectory(lucene)
 endif(${BUILD_WITH_LUCENE})

contrib/test/cos/CMakeLists.txt

@@ -0,0 +1,49 @@
+add_executable(cosTest "")
+target_sources(cosTest
+  PRIVATE
+  "${CMAKE_CURRENT_SOURCE_DIR}/main.c"
+  )
+
+#find_path(APR_INCLUDE_DIR apr-1/apr_time.h)
+#find_path(APR_UTIL_INCLUDE_DIR apr/include/apr-1/apr_md5.h)
+#find_path(MINIXML_INCLUDE_DIR mxml.h)
+#find_path(CURL_INCLUDE_DIR curl/curl.h)
+
+#include_directories (${MINIXML_INCLUDE_DIR})
+#include_directories (${CURL_INCLUDE_DIR})
+FIND_PROGRAM(APR_CONFIG_BIN NAMES apr-config apr-1-config PATHS /usr/bin /usr/local/bin /usr/local/apr/bin/)
+#FIND_PROGRAM(APU_CONFIG_BIN NAMES apu-config apu-1-config PATHS /usr/bin /usr/local/bin /usr/local/apr/bin/)
+
+IF (APR_CONFIG_BIN)
+  EXECUTE_PROCESS(
+    COMMAND ${APR_CONFIG_BIN} --includedir
+    OUTPUT_VARIABLE APR_INCLUDE_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+ENDIF()
+#IF (APU_CONFIG_BIN)
+#  EXECUTE_PROCESS(
+#    COMMAND ${APU_CONFIG_BIN} --includedir
+#    OUTPUT_VARIABLE APR_UTIL_INCLUDE_DIR
+#    OUTPUT_STRIP_TRAILING_WHITESPACE
+#    )
+#ENDIF()
+
+include_directories (${APR_INCLUDE_DIR})
+#include_directories (${APR_UTIL_INCLUDE_DIR})
+
+target_include_directories(
+  cosTest
+  PUBLIC "${TD_SOURCE_DIR}/contrib/cos-c-sdk-v5/cos_c_sdk"
+  )
+
+#find_library(APR_LIBRARY apr-1 PATHS /usr/local/apr/lib/)
+#find_library(APR_UTIL_LIBRARY aprutil-1 PATHS /usr/local/apr/lib/)
+#find_library(MINIXML_LIBRARY mxml)
+#find_library(CURL_LIBRARY curl)
+
+target_link_libraries(cosTest cos_c_sdk)
+target_link_libraries(cosTest apr-1})
+target_link_libraries(cosTest aprutil-1})
+target_link_libraries(cosTest mxml)
+target_link_libraries(cosTest curl)

docs/en/07-develop/07-tmq.mdx

@@ -24,24 +24,19 @@ By subscribing to a topic, a consumer can obtain the latest data in that topic i
 To implement these features, TDengine indexes its write-ahead log (WAL) file for fast random access and provides configurable methods for replacing and retaining this file. You can define a retention period and size for this file. For information, see the CREATE DATABASE statement. In this way, the WAL file is transformed into a persistent storage engine that remembers the order in which events occur. However, note that configuring an overly long retention period for your WAL files makes database compression inefficient. TDengine then uses the WAL file instead of the time-series database as its storage engine for queries in the form of topics. TDengine reads the data from the WAL file; uses a unified query engine instance to perform filtering, transformations, and other operations; and finally pushes the data to consumers.
 
 Tips:(c interface for example)
-- A consumption group consumes all data under the same topic, and different consumption groups are independent of each other;
+1. A consumption group consumes all data under the same topic, and different consumption groups are independent of each other;
-- A consumption group consumes all vgroups of the same topic, which can be composed of multiple consumers, but a vgroup is only consumed by one consumer. If the number of consumers exceeds the number of vgroups, the excess consumers do not consume data;
+2. A consumption group consumes all vgroups of the same topic, which can be composed of multiple consumers, but a vgroup is only consumed by one consumer. If the number of consumers exceeds the number of vgroups, the excess consumers do not consume data;
-- On the server side, only one offset is saved for each vgroup, and the offsets for each vgroup are monotonically increasing, but not necessarily continuous. There is no correlation between the offsets of various vgroups;
+3. On the server side, only one offset is saved for each vgroup, and the offsets for each vgroup are monotonically increasing, but not necessarily continuous. There is no correlation between the offsets of various vgroups;
-- Each poll server will return a result block, which belongs to a vgroup and may contain data from multiple versions of wal. This block can be accessed through tmq_get_vgroup_offset. The offset interface obtains the offset of the first record in the block;
+4. Each poll server will return a result block, which belongs to a vgroup and may contain data from multiple versions of wal. This block can be accessed through tmq_get_vgroup_offset. The offset interface obtains the offset of the first record in the block;
-- If a consumer group has never committed an offset, when its member consumers restart and pull data again, they start consuming from the set value of the parameter auto.offset.reset; In a consumer lifecycle, the client locally records the offset of the most recent pull data and will not pull duplicate data;
+5. If a consumer group has never committed an offset, when its member consumers restart and pull data again, they start consuming from the set value of the parameter auto.offset.reset; In a consumer lifecycle, the client locally records the offset of the most recent pull data and will not pull duplicate data;
-- If a consumer terminates abnormally (without calling tmq_close), they need to wait for about 12 seconds to trigger their consumer group rebalance. The consumer's status on the server will change to LOST, and after about 1 day, the consumer will be automatically deleted; Exit normally, and after exiting, the consumer will be deleted; Add a new consumer, wait for about 2 seconds to trigger Rebalance, and the consumer's status on the server will change to ready;
+6. If a consumer terminates abnormally (without calling tmq_close), they need to wait for about 12 seconds to trigger their consumer group rebalance. The consumer's status on the server will change to LOST, and after about 1 day, the consumer will be automatically deleted; Exit normally, and after exiting, the consumer will be deleted; Add a new consumer, wait for about 2 seconds to trigger Rebalance, and the consumer's status on the server will change to ready;
-- The consumer group Rebalance will reassign Vgroups to all consumer members in the ready state of the group, and consumers can only assign/see/commit/poll operations to the Vgroups they are responsible for;
+7. The consumer group Rebalance will reassign Vgroups to all consumer members in the ready state of the group, and consumers can only assign/see/commit/poll operations to the Vgroups they are responsible for;
-- Consumers can tmq_position to obtain the offset of the current consumption, seek to the specified offset, and consume again;
+8. Consumers can tmq_position to obtain the offset of the current consumption, seek to the specified offset, and consume again;
-- Seek points the position to the specified offset without executing the commit operation. Once the seek is successful, it can poll the specified offset and subsequent data;
+9. Seek points the position to the specified offset without executing the commit operation. Once the seek is successful, it can poll the specified offset and subsequent data;
-- Position is to obtain the current consumption position, which is the position to be taken next time, not the current consumption position
+10. Before the seek operation, tmq must be call tmq_get_topic_assignment, The assignment interface obtains the vgroup ID and offset range of the consumer. The seek operation will detect whether the vgroup ID and offset are legal, and if they are illegal, an error will be reported;
-- Commit is the submission of the consumption location. Without parameters, it is the submission of the current consumption location (the location to be taken next time, not the current consumption location). With parameters, it is the location in the submission parameters (i.e. the location to be taken after the next exit and restart)
+11. Due to the existence of a WAL expiration deletion mechanism, even if the seek operation is successful, it is possible that the offset has expired when polling data. If the offset of poll is less than the WAL minimum version number, it will be consumed from the WAL minimum version number;
-- Seek is to set the consumer's consumption position. Wherever the seek goes, the position will be returned, all of which are the positions to be taken next time
+12. The tmq_get_vgroup_offset interface obtains the offset of the first data in the result block where the record is located. When seeking to this offset, it will consume all the data in this block. Refer to point four;
-- Seek does not affect commit, commit does not affect seek, independent of each other, the two are different concepts
+13. Data subscription is to consume data from the wal. If some wal files are deleted according to WAL retention policy, the deleted data can't be consumed any more. So you need to set a reasonable value for parameter `WAL_RETENTION_PERIOD` or `WAL_RETENTION_SIZE` when creating the database and make sure your application consume the data in a timely way to make sure there is no data loss. This behavior is similar to Kafka and other widely used message queue products.
-- The begin interface is the offset of the first data in wal, and the end interface is the offset+1 of the last data in wal10.
-- Before the seek operation, tmq must be call tmq_get_topic_assignment, The assignment interface obtains the vgroup ID and offset range of the consumer. The seek operation will detect whether the vgroup ID and offset are legal, and if they are illegal, an error will be reported;
-- Due to the existence of a WAL expiration deletion mechanism, even if the seek operation is successful, it is possible that the offset has expired when polling data. If the offset of poll is less than the WAL minimum version number, it will be consumed from the WAL minimum version number;
-- The tmq_get_vgroup_offset interface obtains the offset of the first data in the result block where the record is located. When seeking to this offset, it will consume all the data in this block. Refer to point four;
-- Data subscription is to consume data from the wal. If some wal files are deleted according to WAL retention policy, the deleted data can't be consumed any more. So you need to set a reasonable value for parameter `WAL_RETENTION_PERIOD` or `WAL_RETENTION_SIZE` when creating the database and make sure your application consume the data in a timely way to make sure there is no data loss. This behavior is similar to Kafka and other widely used message queue products.
 
 ## Data Schema and API
 
@@ -104,8 +99,6 @@ The related schemas and APIs in various languages are described as follows:
     DLL_EXPORT const char *tmq_err2str(int32_t code);
 ```
 
-For more information, see [C/C++ Connector](/reference/connector/cpp).
-
 The following example is based on the smart meter table described in Data Models. For complete sample code, see the C language section below.
 
 </TabItem>

docs/en/10-deployment/01-deploy.md

@@ -62,12 +62,13 @@ serverPort            6030
 
 For all the dnodes in a TDengine cluster, the below parameters must be configured exactly the same, any node whose configuration is different from dnodes already in the cluster can't join the cluster.
 
-| **#** | **Parameter**      | **Definition**                                                                    |
+| **#** | **Parameter**    | **Definition**                                                                |
-| ----- | ------------------ | ------------------------------------------- |
+| ----- | ---------------- | ----------------------------------------------------------------------------- |
-| 1     | statusInterval     | The interval by which dnode reports its status to mnode                           |
+| 1     | statusInterval   | The interval by which dnode reports its status to mnode                       |
-| 2     | timezone           | Timezone                                                                          |
+| 2     | timezone         | Timezone                                                                      |
-| 3     | locale             | System region and encoding                       |
+| 3     | locale           | System region and encoding                                                    |
-| 4     | charset            | Character set |
+| 4     | charset          | Character set                                                                 |
+| 5     | ttlChangeOnWrite | Whether the ttl expiration time changes with the table modification operation |
 
 ## Start Cluster
 
@@ -97,7 +98,7 @@ Then, on the first dnode i.e. h1.tdengine.com in our example, use TDengine CLI `
 CREATE DNODE "h2.taos.com:6030";
 ````
 
-This adds the end point of the new dnode (from Step 4) into the end point list of the cluster. In the command "fqdn:port" should be quoted using double quotes. Change `"h2.taos.com:6030"` to the end point of your new dnode. 
+This adds the end point of the new dnode (from Step 4) into the end point list of the cluster. In the command "fqdn:port" should be quoted using double quotes. Change `"h2.taos.com:6030"` to the end point of your new dnode.
 
 Then on the first dnode h1.tdengine.com, execute `show dnodes` in `taos`
 

docs/en/12-taos-sql/01-data-type.md

@@ -43,6 +43,8 @@ In TDengine, the data types below can be used when specifying a column or tag.
 | 15  |       JSON        |              | JSON type can only be used on tags. A tag of json type is excluded with any other tags of any other type.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | 16  |      VARCHAR      | User-defined | Alias of BINARY                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | 17  |      GEOMETRY     | User-defined | Geometry                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| 18  |      VARBINARY     | User-defined | Binary data with variable length
+ 
 :::note
 
 - Each row of the table cannot be longer than 48KB (64KB since version 3.0.5.0) (note that each BINARY/NCHAR/GEOMETRY column takes up an additional 2 bytes of storage space).
@@ -57,7 +59,7 @@ In TDengine, the data types below can be used when specifying a column or tag.
     | 3 | POLYGON((1.0 1.0, 2.0 2.0, 1.0 1.0)) | 13+3*16    | 13+4094*16 | +16                      |
 
 - Numeric values in SQL statements will be determined as integer or float type according to whether there is decimal point or whether scientific notation is used, so attention must be paid to avoid overflow. For example, 9999999999999999999 will be considered as overflow because it exceeds the upper limit of long integer, but 9999999999999999999.0 will be considered as a legal float number.
-
+- VARBINARY is a data type that stores binary data, with a maximum length of 65517 bytes and a maximum length of 16382 bytes for tag columns. Binary data can be written through SQL or schemaless (which needs to be converted to a string starting with \x), or written through stmt (which can directly use binary). Display starting with hexadecimal starting with \x.
 :::
 
 ## Constants

docs/en/12-taos-sql/06-select.md

@@ -9,7 +9,7 @@ description: This document describes how to query data in TDengine.
 ```sql
 SELECT {DATABASE() | CLIENT_VERSION() | SERVER_VERSION() | SERVER_STATUS() | NOW() | TODAY() | TIMEZONE() | CURRENT_USER() | USER() }
 
-SELECT [DISTINCT] select_list
+SELECT [hints] [DISTINCT] select_list
     from_clause
     [WHERE condition]
     [partition_by_clause]
@@ -21,6 +21,11 @@ SELECT [DISTINCT] select_list
     [LIMIT limit_val [OFFSET offset_val]]
     [>> export_file]
 
+hints: /*+ [hint([hint_param_list])] [hint([hint_param_list])] */
+
+hint:
+    BATCH_SCAN | NO_BATCH_SCAN   
+
 select_list:
     select_expr [, select_expr] ...
 
@@ -70,6 +75,29 @@ order_expr:
     {expr | position | c_alias} [DESC | ASC] [NULLS FIRST | NULLS LAST]
 ```
 
+## Hints
+
+Hints are a means of user control over query optimization for individual statements. Hints will be ignore automatically if they are not applicable to the current query statement. The specific instructions are as follows:
+
+- Hints syntax starts with `/*+` and ends with `*/`,  spaces are allowed before or after.
+- Hints syntax can only follow the SELECT keyword.
+- Each hints can contain multiple hint, separated by spaces. When multiple hints conflict or are identical, whichever comes first takes effect.
+- When an error occurs with a hint in hints, the effective hint before the error is still valid, and the current and subsequent hints are ignored.
+- hint_param_list are arguments to each hint, which varies according to each hint.
+
+The list of currently supported Hints is as follows:
+
+|    **Hint**   |    **Params**  |         **Comment**        |       **Scopt**            |  
+| :-----------: | -------------- | -------------------------- | -------------------------- |
+| BATCH_SCAN    | None           | Batch table scan           | JOIN statment for stable   |         
+| NO_BATCH_SCAN | None           | Sequential table scan      | JOIN statment for stable   |         
+
+For example:
+
+```sql
+SELECT /*+ BATCH_SCAN() */ a.ts FROM stable1 a, stable2 b where a.tag0 = b.tag0 and a.ts = b.ts;
+```
+
 ## Lists
 
 A query can be performed on some or all columns. Data and tag columns can all be included in the SELECT list.

docs/en/12-taos-sql/10-function.md

@@ -402,7 +402,7 @@ CAST(expr AS type_name)
 
 **Return value type**: The type specified by parameter `type_name`
 
-**Applicable data types**: All data types except JSON
+**Applicable data types**: All data types except JSON and VARBINARY. If type_name is VARBINARY, expr can only be VARCHAR.
 
 **Nested query**: It can be used in both the outer query and inner query in a nested query.
 
@@ -698,7 +698,7 @@ ELAPSED(ts_primary_key [, time_unit])
 LEASTSQUARES(expr, start_val, step_val)
 ```
 
-**Description**: The linear regression function of the specified column and the timestamp column (primary key), `start_val` is the initial value and `step_val` is the step value.
+**Description**: The linear regression function of a specified column, `start_val` is the initial value and `step_val` is the step value.
 
 **Return value type**: A string in the format of "(slope, intercept)"
 

docs/en/12-taos-sql/14-stream.md

@@ -168,3 +168,11 @@ All [scalar functions](../function/#scalar-functions) are available in stream pr
   - [unique](../function/#unique)
   - [mode](../function/#mode)
 
+## Pause\Resume stream
+1.pause stream
+PAUSE STREAM [IF EXISTS] stream_name;
+If "IF EXISTS" is not specified and the stream does not exist, an error will be reported; If "IF EXISTS" is specified and the stream does not exist, success is returned; If the stream exists, paused all stream tasks.
+
+2.resume stream
+RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name;
+If "IF EXISTS" is not specified and the stream does not exist, an error will be reported. If "IF EXISTS" is specified and the stream does not exist, success is returned; If the stream exists, all of the stream tasks will be resumed. If "IGNORE UntREATED" is specified, data written during the pause period of stream is ignored when resuming stream.

docs/en/14-reference/03-connector/04-java.mdx

@@ -1192,7 +1192,6 @@ public abstract class ConsumerLoop {
         config.setProperty("client.id", "1");
         config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ConsumerLoop$ResultDeserializer");
         config.setProperty("value.deserializer.encoding", "UTF-8");
-        config.setProperty("experimental.snapshot.enable", "true");
 
         this.consumer = new TaosConsumer<>(config);
         this.topics = Collections.singletonList("topic_speed");

docs/en/14-reference/13-schemaless/13-schemaless.md

@@ -32,8 +32,10 @@ All data in tag_set is automatically converted to the NCHAR data type and does n
 
 In the schemaless writing data line protocol, each data item in the field_set needs to be described with its data type. Let's explain in detail:
 
-- If there are English double quotes on both sides, it indicates the VARCHAR(N) type. For example, `"abc"`.
+- If there are English double quotes on both sides, it indicates the VARCHAR type. For example, `"abc"`.
-- If there are double quotes on both sides and an L prefix, it means NCHAR(N) type. For example, `L"error message"`.
+- If there are double quotes on both sides and a L/l prefix, it means NCHAR type. For example, `L"error message"`.
+- If there are double quotes on both sides and a G/g prefix, it means GEOMETRY type. For example `G"Point(4.343 89.342)"`.
+- If there are double quotes on both sides and a B/b prefix, it means VARBINARY type. Hexadecimal start with \x or string can be used in double quotes. For example `B"\x98f46e"` `B"hello"`.
 - Spaces, equals sign (=), comma (,), double quote ("), and backslash (\\) need to be escaped with a backslash (\\) in front. (All refer to the ASCII character). The rules are as follows:
 
 | **Serial number** | **Element**    | **Escape characters**   |
@@ -110,7 +112,7 @@ You can configure smlChildTableName in taos.cfg to specify table names, for exam
    Note: TDengine 3.0.3.0 and later automatically detect whether order is consistent. This parameter is no longer used.
 9. Due to the fact that SQL table names do not support period (.), schemaless has also processed period (.). If there is a period (.) in the table name automatically created by schemaless, it will be automatically replaced with an underscore (\_). If you manually specify a sub table name, if there is a dot (.) in the sub table name, it will also be converted to an underscore (\_)
 10. Taos.cfg adds the configuration of smlTsDefaultName (with a string value), which only works on the client side. After configuration, the time column name of the schemaless automatic table creation can be set through this configuration. If not configured, defaults to _ts.
-
+11. Super table name or child table name are case sensitive.
 :::tip
 All processing logic of schemaless will still follow TDengine's underlying restrictions on data structures, such as the total length of each row of data cannot exceed 48 KB(64 KB since version 3.0.5.0) and the total length of a tag value cannot exceed 16 KB. See [TDengine SQL Boundary Limits](/taos-sql/limit) for specific constraints in this area.
 :::

docs/en/20-third-party/70-seeq.md

@@ -0,0 +1,440 @@
+---
+sidebar_label: Seeq
+title: Seeq
+description: How to use Seeq and TDengine to perform time series data analysis
+---
+
+# How to use Seeq and TDengine to perform time series data analysis
+
+## Introduction
+
+Seeq is an advanced analytics software for the manufacturing industry and the Industrial Internet of Things (IIoT). Seeq supports the use of machine learning innovations within process manufacturing organizations. These capabilities enable organizations to deploy their own or third-party machine learning algorithms into advanced analytics applications used by frontline process engineers and subject matter experts, thus extending the efforts of a single data scientist to many frontline workers.
+
+With the TDengine Java connector, Seeq effortlessly supports querying time series data provided by TDengine and offers functionalities such as data visualization, analysis, and forecasting.
+
+### Install Seeq
+
+Please download Seeq Server and Seeq Data Lab software installation package from the [Seeq official website](https://www.seeq.com/customer-download).
+
+### Install and start Seeq Server
+
+```
+tar xvzf seeq-server-xxx.tar.gz
+cd seeq-server-installer
+sudo ./install
+
+sudo seeq service enable
+sudo seeq start
+```
+
+### Install and start Seeq Data Lab Server
+
+Seeq Data Lab needs to be installed on a separate server from Seeq Server and connected to Seeq Server through configuration. For detailed installation and configuration instructions, please refer to [the official documentation](https://support.seeq.com/space/KB/1034059842).
+
+```
+tar xvf seeq-data-lab-<version>-64bit-linux.tar.gz
+sudo seeq-data-lab-installer/install -f /opt/seeq/seeq-data-lab -g /var/opt/seeq -u seeq
+sudo seeq config set Network/DataLab/Hostname localhost
+sudo seeq config set Network/DataLab/Port 34231 # the port of the Data Lab server (usually 34231)
+sudo seeq config set Network/Hostname <value> # the host IP or URL of the main Seeq Server
+
+# If the main Seeq server is configured to listen over HTTPS
+sudo seeq config set Network/Webserver/SecurePort 443 # the secure port of the main Seeq Server (usually 443)
+
+# If the main Seeq server is NOT configured to listen over HTTPS
+sudo seeq config set Network/Webserver/Port <value>
+
+#On the main Seeq server, open a Seeq Command Prompt and set the hostname of the Data Lab server:
+sudo seeq config set Network/DataLab/Hostname <value> # the host IP (not URL) of the Data Lab server
+sudo seeq config set Network/DataLab/Port 34231 # the port of the Data Lab server (usually 34231
+```
+
+### Install TDengine on-premise instance
+
+See [Quick Install from Package](../../get-started).
+
+### Or use TDengine Cloud
+
+Register for a [TDengine Cloud](https://cloud.tdengine.com) account and log in to your account.
+
+## Make Seeq be able to access TDengine
+
+1. Get data location configuration
+
+```
+sudo seeq config get Folders/Data
+```
+
+2. Download TDengine Java connector from maven.org. Please use the latest version (Current is 3.2.5, https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/3.2.5/taos-jdbcdriver-3.2.5-dist.jar).
+
+3. Restart Seeq server
+
+```
+sudo seeq restart
+```
+
+4. Input License
+
+Use a browser to access ip:34216 and input the license according to the guide.
+
+## How to use Seeq to analyze time-series data that TDengine serves
+
+This chapter demonstrates how to use Seeq software in conjunction with TDengine for time series data analysis.
+
+### Scenario Overview
+
+The example scenario involves a power system where users collect electricity consumption data from metering devices at a power station on a daily basis. This data is stored in a TDengine cluster. The user now wants to predict how the electricity consumption will develop and purchase additional equipment to support it. The electricity consumption varies with monthly orders, and seasonal variations also affect the power consumption. Since the city is located in the Northern Hemisphere, more electricity is consumed during the summer. We will use simulated data to reflect these assumptions.
+
+### Schema
+
+```
+CREATE STABLE meters (ts TIMESTAMP, num INT, temperature FLOAT, goods INT) TAGS (device NCHAR(20));
+CREATE TABLE goods (ts1 TIMESTAMP, ts2 TIMESTAMP, goods FLOAT);
+```
+
+![Seeq demo schema](./seeq/seeq-demo-schema.webp)
+
+### Mock data
+
+```
+python mockdata.py
+taos -s "insert into power.goods select _wstart, _wstart + 10d, avg(goods) from power.meters interval(10d);"
+```
+
+The source code is hosted at [GitHub Repository](https://github.com/sangshuduo/td-forecasting).
+
+### Using Seeq for data analysis
+
+#### Data Source configuration
+
+Please login with Seeq administrator and create a few data sources as following.
+
+- Power
+
+```
+{
+    "QueryDefinitions": [
+        {
+            "Name": "PowerNum",
+            "Type": "SIGNAL",
+            "Sql": "SELECT  ts, num FROM meters",
+            "Enabled": true,
+            "TestMode": false,
+            "TestQueriesDuringSync": true,
+            "InProgressCapsulesEnabled": false,
+            "Variables": null,
+            "Properties": [
+                {
+                    "Name": "Name",
+                    "Value": "Num",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Interpolation Method",
+                    "Value": "linear",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Maximum Interpolation",
+                    "Value": "2day",
+                    "Sql": null,
+                    "Uom": "string"
+                }
+            ],
+            "CapsuleProperties": null
+        }
+    ],
+    "Type": "GENERIC",
+    "Hostname": null,
+    "Port": 0,
+    "DatabaseName": null,
+    "Username": "root",
+    "Password": "taosdata",
+    "InitialSql": null,
+    "TimeZone": null,
+    "PrintRows": false,
+    "UseWindowsAuth": false,
+    "SqlFetchBatchSize": 100000,
+    "UseSSL": false,
+    "JdbcProperties": null,
+    "GenericDatabaseConfig": {
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
+        "ResolutionInNanoseconds": 1000,
+        "ZonedColumnTypes": []
+    }
+}
+```
+
+- Goods
+
+```
+{
+    "QueryDefinitions": [
+        {
+            "Name": "PowerGoods",
+            "Type": "CONDITION",
+            "Sql": "SELECT ts1, ts2, goods FROM power.goods",
+            "Enabled": true,
+            "TestMode": false,
+            "TestQueriesDuringSync": true,
+            "InProgressCapsulesEnabled": false,
+            "Variables": null,
+            "Properties": [
+                {
+                    "Name": "Name",
+                    "Value": "Goods",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Maximum Duration",
+                    "Value": "10days",
+                    "Sql": null,
+                    "Uom": "string"
+                }
+            ],
+            "CapsuleProperties": [
+                {
+                    "Name": "goods",
+                    "Value": "${columnResult}",
+                    "Column": "goods",
+                    "Uom": "string"
+                }
+            ]
+        }
+    ],
+    "Type": "GENERIC",
+    "Hostname": null,
+    "Port": 0,
+    "DatabaseName": null,
+    "Username": "root",
+    "Password": "taosdata",
+    "InitialSql": null,
+    "TimeZone": null,
+    "PrintRows": false,
+    "UseWindowsAuth": false,
+    "SqlFetchBatchSize": 100000,
+    "UseSSL": false,
+    "JdbcProperties": null,
+    "GenericDatabaseConfig": {
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
+        "ResolutionInNanoseconds": 1000,
+        "ZonedColumnTypes": []
+    }
+}
+```
+
+- Temperature
+
+```
+{
+    "QueryDefinitions": [
+        {
+            "Name": "PowerNum",
+            "Type": "SIGNAL",
+            "Sql": "SELECT  ts, temperature FROM meters",
+            "Enabled": true,
+            "TestMode": false,
+            "TestQueriesDuringSync": true,
+            "InProgressCapsulesEnabled": false,
+            "Variables": null,
+            "Properties": [
+                {
+                    "Name": "Name",
+                    "Value": "Temperature",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Interpolation Method",
+                    "Value": "linear",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Maximum Interpolation",
+                    "Value": "2day",
+                    "Sql": null,
+                    "Uom": "string"
+                }
+            ],
+            "CapsuleProperties": null
+        }
+    ],
+    "Type": "GENERIC",
+    "Hostname": null,
+    "Port": 0,
+    "DatabaseName": null,
+    "Username": "root",
+    "Password": "taosdata",
+    "InitialSql": null,
+    "TimeZone": null,
+    "PrintRows": false,
+    "UseWindowsAuth": false,
+    "SqlFetchBatchSize": 100000,
+    "UseSSL": false,
+    "JdbcProperties": null,
+    "GenericDatabaseConfig": {
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
+        "ResolutionInNanoseconds": 1000,
+        "ZonedColumnTypes": []
+    }
+}
+```
+
+#### Launch Seeq Workbench
+
+Please login to Seeq server with IP:port and create a new Seeq Workbench, then select data sources and choose the correct tools to do data visualization and analysis. Please refer to [the official documentation](https://support.seeq.com/space/KB/146440193/Seeq+Workbench) for the details.
+
+![Seeq Workbench](./seeq/seeq-demo-workbench.webp)
+
+#### Use Seeq Data Lab Server for advanced data analysis
+
+Please login to the Seeq service with IP:port and create a new Seeq Data Lab. Then you can use advanced tools including Python environment and machine learning add-ons for more complex analysis.
+
+```Python
+from seeq import spy
+spy.options.compatibility = 189
+import pandas as pd
+import matplotlib
+import matplotlib.pyplot as plt
+import mlforecast
+import lightgbm as lgb
+from mlforecast.target_transforms import Differences
+from sklearn.linear_model import LinearRegression
+
+ds = spy.search({'ID': "8C91A9C7-B6C2-4E18-AAAF-XXXXXXXXX"})
+print(ds)
+
+sig = ds.loc[ds['Name'].isin(['Num'])]
+print(sig)
+
+data = spy.pull(sig, start='2015-01-01', end='2022-12-31', grid=None)
+print("data.info()")
+data.info()
+print(data)
+#data.plot()
+
+print("data[Num].info()")
+data['Num'].info()
+da = data['Num'].index.tolist()
+#print(da)
+
+li = data['Num'].tolist()
+#print(li)
+
+data2 = pd.DataFrame()
+data2['ds'] = da
+print('1st data2 ds info()')
+data2['ds'].info()
+
+#data2['ds'] = pd.to_datetime(data2['ds']).to_timestamp()
+data2['ds'] = pd.to_datetime(data2['ds']).astype('int64')
+data2['y'] = li
+print('2nd data2 ds info()')
+data2['ds'].info()
+print(data2)
+
+data2.insert(0, column = "unique_id", value="unique_id")
+
+print("Forecasting ...")
+
+forecast = mlforecast.MLForecast(
+    models = lgb.LGBMRegressor(),
+    freq = 1,
+    lags=[365],
+    target_transforms=[Differences([365])],
+)
+
+forecast.fit(data2)
+predicts = forecast.predict(365)
+
+pd.concat([data2, predicts]).set_index("ds").plot(title = "current data with forecast")
+plt.show()
+```
+
+Example output:
+
+![Seeq forecast result](./seeq/seeq-forecast-result.webp)
+
+### How to configure Seeq data source to access TDengine Cloud
+
+Configuring a Seeq data source connection to TDengine Cloud or a local installation instance does not have any essential differences. After logging in to TDengine Cloud, select "Programming - Java" and copy the JDBC URL string with the token provided. Then, use this JDBC URL string to fill in the DatabaseJdbcUrl value in the Seeq Data Source configuration.
+
+Please note that when using TDengine Cloud, you need to specify the database name in your SQL commands.
+
+#### The data source of TDengine Cloud example
+
+```
+{
+    "QueryDefinitions": [
+        {
+            "Name": "CloudVoltage",
+            "Type": "SIGNAL",
+            "Sql": "SELECT  ts, voltage FROM test.meters",
+            "Enabled": true,
+            "TestMode": false,
+            "TestQueriesDuringSync": true,
+            "InProgressCapsulesEnabled": false,
+            "Variables": null,
+            "Properties": [
+                {
+                    "Name": "Name",
+                    "Value": "Voltage",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Interpolation Method",
+                    "Value": "linear",
+                    "Sql": null,
+                    "Uom": "string"
+                },
+                {
+                    "Name": "Maximum Interpolation",
+                    "Value": "2day",
+                    "Sql": null,
+                    "Uom": "string"
+                }
+            ],
+            "CapsuleProperties": null
+        }
+    ],
+    "Type": "GENERIC",
+    "Hostname": null,
+    "Port": 0,
+    "DatabaseName": null,
+    "Username": "root",
+    "Password": "taosdata",
+    "InitialSql": null,
+    "TimeZone": null,
+    "PrintRows": false,
+    "UseWindowsAuth": false,
+    "SqlFetchBatchSize": 100000,
+    "UseSSL": false,
+    "JdbcProperties": null,
+    "GenericDatabaseConfig": {
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://gw.cloud.taosdata.com?useSSL=true&token=41ac9d61d641b6b334e8b76f45f5a8XXXXXXXXXX",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
+        "ResolutionInNanoseconds": 1000,
+        "ZonedColumnTypes": []
+    }
+}
+```
+
+#### Seeq Workbench with TDengine Cloud data source example
+
+![Seeq workbench with TDengine Cloud](./seeq/seeq-workbench-with-tdengine-cloud.webp)
+
+## Conclusion
+
+By integrating Seeq and TDengine, it is possible to leverage the efficient storage and querying performance of TDengine while also benefiting from Seeq's powerful data visualization and analysis capabilities provided to users.
+
+This integration allows users to take advantage of TDengine's high-performance time-series data storage and retrieval, ensuring efficient handling of large volumes of data. At the same time, Seeq provides advanced analytics features such as data visualization, anomaly detection, correlation analysis, and predictive modeling, enabling users to gain valuable insights and make data-driven decisions.
+
+Together, Seeq and TDengine provide a comprehensive solution for time series data analysis in diverse industries such as manufacturing, IIoT, and power systems. The combination of efficient data storage and advanced analytics empowers users to unlock the full potential of their time series data, driving operational improvements, and enabling predictive and prescriptive analytics applications.

docs/en/28-releases/01-tdengine.md

@@ -10,6 +10,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://t
 
 import Release from "/components/ReleaseV3";
 
+## 3.1.1.0
+
+<Release type="tdengine" version="3.1.1.0" />
+
 ## 3.1.0.3
 
 <Release type="tdengine" version="3.1.0.3" />

docs/examples/c/async_query_example.c

@@ -78,6 +78,7 @@ int printRow(char *str, TAOS_ROW row, TAOS_FIELD *fields, int numFields) {
       } break;
 
       case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_VARBINARY:
       case TSDB_DATA_TYPE_NCHAR:
       case TSDB_DATA_TYPE_GEOMETRY: {
         int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);

docs/examples/c/query_example.c

@@ -76,6 +76,7 @@ int printRow(char *str, TAOS_ROW row, TAOS_FIELD *fields, int numFields) {
       } break;
 
       case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_VARBINARY:
       case TSDB_DATA_TYPE_NCHAR:
       case TSDB_DATA_TYPE_GEOMETRY: {
         int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);

docs/zh/02-intro.md

@@ -6,7 +6,14 @@ toc_max_heading_level: 2
 
 TDengine 是一款开源、高性能、云原生的[时序数据库](https://tdengine.com/tsdb/)，且针对物联网、车联网、工业互联网、金融、IT 运维等场景进行了优化。TDengine 的代码，包括集群功能，都在 GNU AGPL v3.0 下开源。除核心的时序数据库功能外，TDengine 还提供[缓存](../develop/cache/)、[数据订阅](../develop/tmq)、[流式计算](../develop/stream)等其它功能以降低系统复杂度及研发和运维成本。
 
-本章节介绍 TDengine 的主要功能、竞争优势、适用场景、与其他数据库的对比测试等等，让大家对 TDengine 有个整体的了解。
+本章节介绍 TDengine 的主要产品和功能、竞争优势、适用场景、与其他数据库的对比测试等等，让大家对 TDengine 有个整体的了解。
+
+## 主要产品
+
+TDengine 有三个主要产品：TDengine Pro （即 TDengine 企业版），TDengine Cloud，和 TDengine OSS，关于它们的具体定义请参考 
+- [TDengine 企业版](https://www.taosdata.com/tdengine-pro)
+- [TDengine 云服务](https://cloud.taosdata.com/?utm_source=menu&utm_medium=webcn)
+- [TDengine 开源版](https://www.taosdata.com/tdengine-oss)
 
 ## 主要功能
 

docs/zh/07-develop/07-tmq.mdx

@@ -26,24 +26,19 @@ import CDemo from "./_sub_c.mdx";
 本文档不对消息队列本身的基础知识做介绍，如果需要了解，请自行搜索。
 
 说明（以c接口为例）：
-- 一个消费组消费同一个topic下的所有数据，不同消费组之间相互独立；
+1. 一个消费组消费同一个topic下的所有数据，不同消费组之间相互独立；
-- 一个消费组消费同一个topic所有的vgroup，消费组可由多个消费者组成，但一个vgroup仅被一个消费者消费，如果消费者数量超过了vgroup数量，多余的消费者不消费数据；
+2. 一个消费组消费同一个topic所有的vgroup，消费组可由多个消费者组成，但一个vgroup仅被一个消费者消费，如果消费者数量超过了vgroup数量，多余的消费者不消费数据；
-- 在服务端每个vgroup仅保存一个offset，每个vgroup的offset是单调递增的，但不一定连续。各个vgroup的offset之间没有关联；
+3. 在服务端每个vgroup仅保存一个offset，每个vgroup的offset是单调递增的，但不一定连续。各个vgroup的offset之间没有关联；
-- 每次poll服务端会返回一个结果block，该block属于一个vgroup，可能包含多个wal版本的数据，可以通过 tmq_get_vgroup_offset 接口获得是该block第一条记录的offset；
+4. 每次poll服务端会返回一个结果block，该block属于一个vgroup，可能包含多个wal版本的数据，可以通过 tmq_get_vgroup_offset 接口获得是该block第一条记录的offset；
-- 一个消费组如果从未commit过offset，当其成员消费者重启重新拉取数据时，均从参数auto.offset.reset设定值开始消费；在一个消费者生命周期中，客户端本地记录了最近一次拉取数据的offset，不会拉取重复数据；
+5. 一个消费组如果从未commit过offset，当其成员消费者重启重新拉取数据时，均从参数auto.offset.reset设定值开始消费；在一个消费者生命周期中，客户端本地记录了最近一次拉取数据的offset，不会拉取重复数据；
-- 消费者如果异常终止（没有调用tmq_close），需等约12秒后触发其所属消费组rebalance，该消费者在服务端状态变为LOST，约1天后该消费者自动被删除；正常退出，退出后就会删除消费者；新增消费者，需等约2秒触发rebalance，该消费者在服务端状态变为ready；
+6. 消费者如果异常终止（没有调用tmq_close），需等约12秒后触发其所属消费组rebalance，该消费者在服务端状态变为LOST，约1天后该消费者自动被删除；正常退出，退出后就会删除消费者；新增消费者，需等约2秒触发rebalance，该消费者在服务端状态变为ready；
-- 消费组rebalance会对该组所有ready状态的消费者成员重新进行vgroup分配，消费者仅能对自己负责的vgroup进行assignment/seek/commit/poll操作；
+7. 消费组rebalance会对该组所有ready状态的消费者成员重新进行vgroup分配，消费者仅能对自己负责的vgroup进行assignment/seek/commit/poll操作；
-- 消费者可利用 tmq_position 获得当前消费的offset，并seek到指定offset，重新消费；
+8. 消费者可利用 tmq_position 获得当前消费的offset，并seek到指定offset，重新消费；
-- seek将position指向指定offset，不执行commit操作，一旦seek成功，可poll拉取指定offset及以后的数据；
+9. seek将position指向指定offset，不执行commit操作，一旦seek成功，可poll拉取指定offset及以后的数据；
-- seek 操作之前须调用 tmq_get_topic_assignment 接口获取该consumer的vgroup ID和offset范围。seek 操作会检测vgroup ID 和 offset是否合法，如非法将报错；
+10. seek 操作之前须调用 tmq_get_topic_assignment 接口获取该consumer的vgroup ID和offset范围。seek 操作会检测vgroup ID 和 offset是否合法，如非法将报错；
-- position是获取当前的消费位置，是下次要取的位置，不是当前消费到的位置
+11. tmq_get_vgroup_offset接口获取的是记录所在结果block块里的第一条数据的offset，当seek至该offset时，将消费到这个block里的全部数据。参见第四点；
-- commit是提交消费位置，不带参数的话，是提交当前消费位置（下次要取的位置，不是当前消费到的位置），带参数的话，是提交参数里的位置（也即下次退出重启后要取的位置）
+12. 由于存在 WAL 过期删除机制，即使seek 操作成功，poll数据时有可能offset已失效。如果poll 的offset 小于 WAL 最小版本号，将会从WAL最小版本号消费；
-- seek是设置consumer消费位置，seek到哪，position就返回哪，都是下次要取的位置
+13. 数据订阅是从 WAL 消费数据，如果一些 WAL 文件被基于 WAL 保留策略删除，则已经删除的 WAL 文件中的数据就无法再消费到。需要根据业务需要在创建数据库时合理设置 `WAL_RETENTION_PERIOD` 或 `WAL_RETENTION_SIZE` ，并确保应用及时消费数据，这样才不会产生数据丢失的现象。数据订阅的行为与 Kafka 等广泛使用的消息队列类产品的行为相似；
-- seek不会影响commit，commit不影响seek，相互独立，两个是不同的概念
-- begin接口为wal 第一条数据的offset，end 接口为wal 最后一条数据的offset + 1
-- tmq_get_vgroup_offset接口获取的是记录所在结果block块里的第一条数据的offset，当seek至该offset时，将消费到这个block里的全部数据。参见第四点；
-- 由于存在 WAL 过期删除机制，即使seek 操作成功，poll数据时有可能offset已失效。如果poll 的offset 小于 WAL 最小版本号，将会从WAL最小版本号消费；
-- 数据订阅是从 WAL 消费数据，如果一些 WAL 文件被基于 WAL 保留策略删除，则已经删除的 WAL 文件中的数据就无法再消费到。需要根据业务需要在创建数据库时合理设置 `WAL_RETENTION_PERIOD` 或 `WAL_RETENTION_SIZE` ，并确保应用及时消费数据，这样才不会产生数据丢失的现象。数据订阅的行为与 Kafka 等广泛使用的消息队列类产品的行为相似；
 
 ## 主要数据结构和 API
 
@@ -60,17 +55,17 @@ import CDemo from "./_sub_c.mdx";
     typedef void(tmq_commit_cb(tmq_t *tmq, int32_t code, void *param));
 
     typedef enum tmq_conf_res_t {
-        TMQ_CONF_UNKNOWN = -2,
+    TMQ_CONF_UNKNOWN = -2,
-        TMQ_CONF_INVALID = -1,
+    TMQ_CONF_INVALID = -1,
-        TMQ_CONF_OK = 0,
+    TMQ_CONF_OK = 0,
-    } tmq_conf_res_t;
+} tmq_conf_res_t;
 
     typedef struct tmq_topic_assignment {
-        int32_t vgId;
+    int32_t vgId;
-        int64_t currentOffset;
+    int64_t currentOffset;
-        int64_t begin;
+    int64_t begin;
-        int64_t end;  // The last version of wal + 1
+    int64_t end;
-    } tmq_topic_assignment;
+} tmq_topic_assignment;
 
     DLL_EXPORT tmq_conf_t    *tmq_conf_new();
     DLL_EXPORT tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const char *value);
@@ -89,24 +84,24 @@ import CDemo from "./_sub_c.mdx";
     DLL_EXPORT int32_t   tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
     DLL_EXPORT TAOS_RES *tmq_consumer_poll(tmq_t *tmq, int64_t timeout);
     DLL_EXPORT int32_t   tmq_consumer_close(tmq_t *tmq);
-    DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg); //Commit the msg’s offset + 1
+    DLL_EXPORT int32_t   tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg);
     DLL_EXPORT void      tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param);
     DLL_EXPORT int32_t   tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
     DLL_EXPORT void      tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param);
     DLL_EXPORT int32_t   tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,int32_t *numOfAssignment);
     DLL_EXPORT void      tmq_free_assignment(tmq_topic_assignment* pAssignment);
     DLL_EXPORT int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
-    DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);  // The current offset is the offset of the last consumed message + 1
+    DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);
     DLL_EXPORT int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId);
 
     DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
     DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
     DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
-    DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);  // Get current offset of the result
+    DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);
-    DLL_EXPORT const char *tmq_err2str(int32_t code);
+    DLL_EXPORT const char *tmq_err2str(int32_t code);DLL_EXPORT void           tmq_conf_set_auto_commit_cb(tmq_conf_t *conf, tmq_commit_cb *cb, void *param);
 ```
 
-这些 API 的文档请见 [C/C++ Connector](../../connector/cpp)，下面介绍一下它们的具体用法（超级表和子表结构请参考“数据建模”一节），完整的示例代码请见下面 C 语言的示例代码。
+下面介绍一下它们的具体用法（超级表和子表结构请参考“数据建模”一节），完整的示例代码请见下面 C 语言的示例代码。
 
 </TabItem>
 <TabItem value="java" label="Java">

docs/zh/08-connector/45-php.mdx

@@ -143,6 +143,7 @@ phpize && ./configure --enable-swoole && make -j && make install
 | `TDengine\TSDB_DATA_TYPE_FLOAT` | float |
 | `TDengine\TSDB_DATA_TYPE_DOUBLE` | double |
 | `TDengine\TSDB_DATA_TYPE_BINARY` | binary |
+| `TDengine\TSDB_DATA_TYPE_VARBINARY` | varbinary |
 | `TDengine\TSDB_DATA_TYPE_TIMESTAMP` | timestamp |
 | `TDengine\TSDB_DATA_TYPE_NCHAR` | nchar |
 | `TDengine\TSDB_DATA_TYPE_UTINYINT` | utinyint |

docs/zh/10-deployment/01-deploy.md

@@ -62,12 +62,13 @@ serverPort            6030
 
 加入到集群中的数据节点 dnode，下表中涉及集群相关的参数必须完全相同，否则不能成功加入到集群中。
 
-| **#** | **配置参数名称**   | **含义**                                    |
+| **#** | **配置参数名称** | **含义**                             |
-| ----- | ------------------ | ------------------------------------------- |
+| ----- | ---------------- | ------------------------------------ |
-| 1     | statusInterval     | dnode 向 mnode 报告状态时长                 |
+| 1     | statusInterval   | dnode 向 mnode 报告状态时长          |
-| 2     | timezone           | 时区                                        |
+| 2     | timezone         | 时区                                 |
-| 3     | locale             | 系统区位信息及编码格式                       |
+| 3     | locale           | 系统区位信息及编码格式               |
-| 4     | charset            | 字符集编码                                 |
+| 4     | charset          | 字符集编码                           |
+| 5     | ttlChangeOnWrite | ttl 到期时间是否伴随表的修改操作改变 |
 
 ## 启动集群
 
@@ -196,10 +197,10 @@ dnodeID 是集群自动分配的，不得人工指定。它在生成时是递增
 1、建立集群时使用 CREATE DNODE 增加新节点后，新节点始终显示 offline 状态？
 ```sql
   1）首先要检查增加的新节点上的 taosd 服务是否已经正常启动
-  
+
   2）如果已经启动，再检查到新节点的网络是否通畅，可以使用 ping fqdn 验证下
-  
+
   3）如果前面两步都没有问题，这一步要检查新节点做为独立集群在运行了，可以使用 taos -h fqdn 连接上后，show dnodes; 命令查看.
-    如果显示的列表与你主节点上显示的不一致，说明此节点自己单独成立了一个集群，解决的方法是停止新节点上的服务，然后清空新节点上 
+    如果显示的列表与你主节点上显示的不一致，说明此节点自己单独成立了一个集群，解决的方法是停止新节点上的服务，然后清空新节点上
     taos.cfg 中配置的 dataDir 目录下的所有文件，重新启动新节点服务即可解决。
-```  
+```

docs/zh/12-taos-sql/01-data-type.md

@@ -42,11 +42,12 @@ CREATE DATABASE db_name PRECISION 'ns';
 | 14  |       NCHAR       | 自定义    | 记录包含多字节字符在内的字符串，如中文字符。每个 NCHAR 字符占用 4 字节的存储空间。字符串两端使用单引号引用，字符串内的单引号需用转义字符 `\'`。NCHAR 使用时须指定字符串大小，类型为 NCHAR(10) 的列表示此列的字符串最多存储 10 个 NCHAR 字符。如果用户字符串长度超出声明长度，将会报错。 |
 | 15  |       JSON        |           | JSON 数据类型， 只有 Tag 可以是 JSON 格式                                                                                                                                                                                                                                                                         |
 | 16  |      VARCHAR      | 自定义    | BINARY 类型的别名                                                                                                                                                                                                                                                                                                 |
-| 17  |      GEOMETRY     | 自定义    | 几何类型                                                                                                                                                                                                                                                                                                 |
+| 17  |      GEOMETRY     | 自定义    | 几何类型
+| 18  |      VARBINARY     | 自定义    | 可变长的二进制数据|
 
 :::note
 
-- 表的每行长度不能超过 48KB（从 3.0.5.0 版本开始为 64KB）（注意：每个 BINARY/NCHAR/GEOMETRY 类型的列还会额外占用 2 个字节的存储位置）。
+- 表的每行长度不能超过 48KB（从 3.0.5.0 版本开始为 64KB）（注意：每个 BINARY/NCHAR/GEOMETRY/VARBINARY 类型的列还会额外占用 2 个字节的存储位置）。
 - 虽然 BINARY 类型在底层存储上支持字节型的二进制字符，但不同编程语言对二进制数据的处理方式并不保证一致，因此建议在 BINARY 类型中只存储 ASCII 可见字符，而避免存储不可见字符。多字节的数据，例如中文字符，则需要使用 NCHAR 类型进行保存。如果强行使用 BINARY 类型保存中文字符，虽然有时也能正常读写，但并不带有字符集信息，很容易出现数据乱码甚至数据损坏等情况。
 - BINARY 类型理论上最长可以有 16,374（从 3.0.5.0 版本开始，数据列为 65,517，标签列为 16,382） 字节。BINARY 仅支持字符串输入，字符串两端需使用单引号引用。使用时须指定大小，如 BINARY(20) 定义了最长为 20 个单字节字符的字符串，每个字符占 1 字节的存储空间，总共固定占用 20 字节的空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\'`。
 - GEOMETRY 类型数据列为最大长度为 65,517 字节，标签列最大长度为 16,382 字节。支持 2D 的 POINT、LINESTRING 和 POLYGON 子类型数据。长度计算方式如下表所示：
@@ -58,6 +59,7 @@ CREATE DATABASE db_name PRECISION 'ns';
     | 3 | POLYGON((1.0 1.0, 2.0 2.0, 1.0 1.0)) | 13+3*16  | 13+4094*16 | +16          |
 
 - SQL 语句中的数值类型将依据是否存在小数点，或使用科学计数法表示，来判断数值类型是否为整型或者浮点型，因此在使用时要注意相应类型越界的情况。例如，9999999999999999999 会认为超过长整型的上边界而溢出，而 9999999999999999999.0 会被认为是有效的浮点数。
+- VARBINARY 是一种存储二进制数据的数据类型，最大长度为 65,517 字节，标签列最大长度为 16,382 字节。可以通过sql或schemaless方式写入二进制数据（需要转换为\x开头的字符串写入），也可以通过stmt方式写入（可以直接使用二进制）。显示时通过16进制\x开头。
 
 :::
 

docs/zh/12-taos-sql/06-select.md

@@ -9,7 +9,7 @@ description: 查询数据的详细语法
 ```sql
 SELECT {DATABASE() | CLIENT_VERSION() | SERVER_VERSION() | SERVER_STATUS() | NOW() | TODAY() | TIMEZONE() | CURRENT_USER() | USER() }
 
-SELECT [DISTINCT] select_list
+SELECT [hints] [DISTINCT] select_list
     from_clause
     [WHERE condition]
     [partition_by_clause]
@@ -21,6 +21,11 @@ SELECT [DISTINCT] select_list
     [LIMIT limit_val [OFFSET offset_val]]
     [>> export_file]
 
+hints: /*+ [hint([hint_param_list])] [hint([hint_param_list])] */
+
+hint:
+    BATCH_SCAN | NO_BATCH_SCAN   
+
 select_list:
     select_expr [, select_expr] ...
 
@@ -70,6 +75,29 @@ order_expr:
     {expr | position | c_alias} [DESC | ASC] [NULLS FIRST | NULLS LAST]
 ```
 
+## Hints
+
+Hints 是用户控制单个语句查询优化的一种手段，当 Hint 不适用于当前的查询语句时会被自动忽略，具体说明如下：
+
+- Hints 语法以`/*+`开始，终于`*/`，前后可有空格。
+- Hints 语法只能跟随在 SELECT 关键字后。
+- 每个 Hints 可以包含多个 Hint，Hint 间以空格分开，当多个 Hint 冲突或相同时以先出现的为准。
+- 当 Hints 中某个 Hint 出现错误时，错误出现之前的有效 Hint 仍然有效，当前及之后的 Hint 被忽略。
+- hint_param_list 是每个 Hint 的参数，根据每个 Hint 的不同而不同。
+
+目前支持的 Hints 列表如下：
+
+|    **Hint**   |    **参数**    |         **说明**           |       **适用范围**         |  
+| :-----------: | -------------- | -------------------------- | -------------------------- |
+| BATCH_SCAN    | 无             | 采用批量读表的方式         | 超级表 JOIN 语句           |         
+| NO_BATCH_SCAN | 无             | 采用顺序读表的方式         | 超级表 JOIN 语句           |         
+
+举例： 
+
+```sql
+SELECT /*+ BATCH_SCAN() */ a.ts FROM stable1 a, stable2 b where a.tag0 = b.tag0 and a.ts = b.ts;
+```
+
 ## 列表
 
 查询语句可以指定部分或全部列作为返回结果。数据列和标签列都可以出现在列表中。

docs/zh/12-taos-sql/10-function.md

@@ -402,7 +402,7 @@ CAST(expr AS type_name)
 
 **返回结果类型**：CAST 中指定的类型（type_name)。
 
-**适用数据类型**：输入参数 expression 的类型可以是除JSON外的所有类型。
+**适用数据类型**：输入参数 expr 的类型可以是除JSON和VARBINARY外的所有类型。如果 type_name 为 VARBINARY，则 expr 只能是 VARCHAR 类型。
 
 **嵌套子查询支持**：适用于内层查询和外层查询。
 
@@ -700,7 +700,7 @@ ELAPSED(ts_primary_key [, time_unit])
 LEASTSQUARES(expr, start_val, step_val)
 ```
 
-**功能说明**：统计表中某列的值是主键（时间戳）的拟合直线方程。start_val 是自变量初始值，step_val 是自变量的步长值。
+**功能说明**：统计表中某列的值的拟合直线方程。start_val 是自变量初始值，step_val 是自变量的步长值。
 
 **返回数据类型**：字符串表达式（斜率, 截距）。
 

docs/zh/12-taos-sql/14-stream.md

@@ -201,7 +201,6 @@ TDengine 对于修改数据提供两种处理方式，由 IGNORE UPDATE 选项
 对于已经存在的超级表，检查列的schema信息
 1. 检查列的schema信息是否匹配，对于不匹配的，则自动进行类型转换，当前只有数据长度大于4096byte时才报错，其余场景都能进行类型转换。
 2. 检查列的个数是否相同，如果不同，需要显示的指定超级表与subquery的列的对应关系，否则报错；如果相同，可以指定对应关系，也可以不指定，不指定则按位置顺序对应。
-3. 至少自定义一个tag，否则报错。详见 自定义TAG
 
 ## 自定义TAG
 
@@ -249,3 +248,12 @@ T = 最新事件时间 - DELETE_MARK
 - [unique](../function/#unique)
 - [mode](../function/#mode)
 
+## 暂停、恢复流计算
+1.流计算暂停计算任务
+PAUSE STREAM [IF EXISTS] stream_name;
+没有指定IF EXISTS，如果该stream不存在，则报错；如果存在，则暂停流计算。指定了IF EXISTS，如果该stream不存在，则返回成功；如果存在，则暂停流计算
+
+2.流计算恢复计算任务
+RESUME STREAM [IF EXISTS] [IGNORE UNTREATED] stream_name;
+没有指定IF EXISTS，如果该stream不存在，则报错，如果存在，则恢复流计算；指定了IF EXISTS，如果stream不存在，则返回成功；如果存在，则恢复流计算。如果指定IGNORE UNTREATED，则恢复流计算时，忽略流计算暂停期间写入的数据。
+

docs/zh/12-taos-sql/25-grant.md

@@ -1,138 +0,0 @@
----
-sidebar_label: 权限管理
-title: 权限管理
-description: 企业版中才具有的权限管理功能
----
-
-本节讲述如何在 TDengine 中进行权限管理的相关操作。权限管理是 TDengine 企业版的特有功能，本节只列举了一些基本的权限管理功能作为示例，更丰富的权限管理请联系 TDengine 销售或市场团队。
-
-## 创建用户
-
-```sql
-CREATE USER use_name PASS 'password' [SYSINFO {1|0}];
-```
-
-创建用户。
-
-use_name 最长为 23 字节。
-
-password 最长为 31 字节，合法字符包括"a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/"，不可以出现单双引号、撇号、反斜杠和空格，且不可以为空。
-
-SYSINFO 表示用户是否可以查看系统信息。1 表示可以查看，0 表示不可以查看。系统信息包括服务端配置信息、服务端各种节点信息（如 DNODE、QNODE等）、存储相关的信息等。默认为可以查看系统信息。
-
-例如，创建密码为123456且可以查看系统信息的用户test如下：
-
-```sql
-taos> create user test pass '123456' sysinfo 1;
-Query OK, 0 of 0 rows affected (0.001254s)
-```
-
-## 查看用户
-
-```sql
-SHOW USERS;
-```
-
-查看用户信息。
-
-```sql
-taos> show users;
-           name           | super | enable | sysinfo |       create_time       |
-================================================================================
- test                     |     0 |      1 |       1 | 2022-08-29 15:10:27.315 |
- root                     |     1 |      1 |       1 | 2022-08-29 15:03:34.710 |
-Query OK, 2 rows in database (0.001657s)
-```
-
-也可以通过查询INFORMATION_SCHEMA.INS_USERS系统表来查看用户信息，例如：
-
-```sql
-taos> select * from information_schema.ins_users;
-           name           | super | enable | sysinfo |       create_time       |
-================================================================================
- test                     |     0 |      1 |       1 | 2022-08-29 15:10:27.315 |
- root                     |     1 |      1 |       1 | 2022-08-29 15:03:34.710 |
-Query OK, 2 rows in database (0.001953s)
-```
-
-## 删除用户
-
-```sql
-DROP USER user_name;
-```
-
-## 修改用户信息
-
-```sql
-ALTER USER user_name alter_user_clause
- 
-alter_user_clause: {
-    PASS 'literal'
-  | ENABLE value
-  | SYSINFO value
-}
-```
-
-- PASS：修改用户密码。
-- ENABLE：修改用户是否启用。1 表示启用此用户，0 表示禁用此用户。
-- SYSINFO：修改用户是否可查看系统信息。1 表示可以查看系统信息，0 表示不可以查看系统信息。
-
-例如，禁用 test 用户：
-
-```sql
-taos> alter user test enable 0;
-Query OK, 0 of 0 rows affected (0.001160s)
-```
-
-## 授权
-
-```sql
-GRANT privileges ON priv_level TO user_name
- 
-privileges : {
-    ALL
-  | priv_type [, priv_type] ...
-}
- 
-priv_type : {
-    READ
-  | WRITE
-}
- 
-priv_level : {
-    dbname.*
-  | *.*
-}
-```
-
-对用户授权。授权功能只包含在企业版中。
-
-授权级别支持到DATABASE，权限有READ和WRITE两种。
-
-TDengine 有超级用户和普通用户两类用户。超级用户缺省创建为root，拥有所有权限。使用超级用户创建出来的用户为普通用户。在未授权的情况下，普通用户可以创建DATABASE，并拥有自己创建的DATABASE的所有权限，包括删除数据库、修改数据库、查询时序数据和写入时序数据。超级用户可以给普通用户授予其他DATABASE的读写权限，使其可以在此DATABASE上读写数据，但不能对其进行删除和修改数据库的操作。
-
-对于非DATABASE的对象，如USER、DNODE、UDF、QNODE等，普通用户只有读权限（一般为SHOW命令），不能创建和修改。
-
-## 撤销授权
-
-```sql
-REVOKE privileges ON priv_level FROM user_name
- 
-privileges : {
-    ALL
-  | priv_type [, priv_type] ...
-}
- 
-priv_type : {
-    READ
-  | WRITE
-}
- 
-priv_level : {
-    dbname.*
-  | *.*
-}
-
-```
-
-收回对用户的授权。授权功能只包含在企业版中。

docs/zh/14-reference/05-taosbenchmark.md

@@ -11,7 +11,11 @@ taosBenchmark (曾用名 taosdemo ) 是一个用于测试 TDengine 产品性能
 
 ## 安装
 
-- 安装 TDengine 官方安装包的同时会自动安装 taosBenchmark
+taosBenchmark 有两种安装方式:
+
+- 安装 TDengine 官方安装包的同时会自动安装 taosBenchmark, 详情请参考[ TDengine 安装](../../operation/pkg-install)。
+
+- 单独编译 taos-tools 并安装, 详情请参考 [taos-tools](https://github.com/taosdata/taos-tools) 仓库。
 
 ## 运行
 

docs/zh/14-reference/13-schemaless/13-schemaless.md

@@ -33,8 +33,10 @@ tag_set 中的所有的数据自动转化为 nchar 数据类型，并不需要
 
 在无模式写入数据行协议中，field_set 中的每个数据项都需要对自身的数据类型进行描述。具体来说：
 
-- 如果两边有英文双引号，表示 VARCHAR(N) 类型。例如 `"abc"`。
+- 如果两边有英文双引号，表示 VARCHAR 类型。例如 `"abc"`。
-- 如果两边有英文双引号而且带有 L 前缀，表示 NCHAR(N) 类型。例如 `L"报错信息"`。
+- 如果两边有英文双引号而且带有 L或l 前缀，表示 NCHAR 类型。例如 `L"报错信息"`。
+- 如果两边有英文双引号而且带有 G或g 前缀，表示 GEOMETRY 类型。例如 `G"Point(4.343 89.342)"`。
+- 如果两边有英文双引号而且带有 B或b 前缀，表示 VARBINARY 类型，双引号内可以为\x开头的16进制或者字符串。例如 `B"\x98f46e"` `B"hello"`。
 - 对空格、等号（=）、逗号（,）、双引号（"）、反斜杠（\），前面需要使用反斜杠（\）进行转义。（都指的是英文半角符号）。具体转义规则如下：
 
 | **序号**  | **域**      | **需转义字符**                  |
@@ -106,6 +108,7 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
 8. 为了提高写入的效率，默认假设同一个超级表中 field_set 的顺序是一样的（第一条数据包含所有的 field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数 smlDataFormat 为 false，否则，数据写入按照相同顺序写入，库中数据会异常，从3.0.3.0开始，自动检测顺序是否一致，该配置废弃。
 9. 由于sql建表表名不支持点号（.），所以schemaless也对点号（.）做了处理，如果schemaless自动建表的表名如果有点号（.），会自动替换为下划线（\_）。如果手动指定子表名的话，子表名里有点号（.），同样转化为下划线（\_）。
 10. taos.cfg 增加 smlTsDefaultName 配置（值为字符串），只在client端起作用，配置后，schemaless自动建表的时间列名字可以通过该配置设置。不配置的话，默认为 _ts
+11. 无模式写入的数据超级表或子表名区分大小写
    
 :::tip
 无模式所有的处理逻辑，仍会遵循 TDengine 对数据结构的底层限制，例如每行数据的总长度不能超过

docs/zh/14-reference/14-taosKeeper.md

@@ -13,7 +13,12 @@ taosKeeper 是 TDengine 3.0 版本监控指标的导出工具，通过简单的
 
 ## 安装
 
-- 安装 TDengine 官方安装包的同时会自动安装 taosKeeper
+taosKeeper 有两种安装方式：
+taosKeeper 安装方式：
+
+- 安装 TDengine 官方安装包的同时会自动安装 taosKeeper, 详情请参考[ TDengine 安装](../../operation/pkg-install)。
+
+- 单独编译 taosKeeper 并安装，详情请参考 [taosKeeper](https://github.com/taosdata/taoskeeper) 仓库。
 
 ## 配置和运行方式
 

docs/zh/20-third-party/11-kafka.md

@@ -23,7 +23,7 @@ TDengine Source Connector 用于把数据实时地从 TDengine 读出来发送
 1. Linux 操作系统
 2. 已安装 Java 8 和 Maven
 3. 已安装 Git、curl、vi
-4. 已安装并启动 TDengine。
+4. 已安装并启动 TDengine。如果还没有可参考[安装和卸载](../../operation/pkg-install)
 
 ## 安装 Kafka
 

docs/zh/20-third-party/70-seeq.md

@@ -14,7 +14,7 @@ Seeq 是制造业和工业互联网（IIOT）高级分析软件。Seeq 支持在
 
 ### Seeq 安装方法
 
-从 (Seeq 官网)[https://www.seeq.com/customer-download]下载相关软件，例如 Seeq Server 和 Seeq Data Lab 等。
+从 [Seeq 官网](https://www.seeq.com/customer-download)下载相关软件，例如 Seeq Server 和 Seeq Data Lab 等。
 
 ### Seeq Server 安装和启动
 
@@ -29,7 +29,7 @@ sudo seeq start
 
 ### Seeq Data Lab Server 安装和启动
 
-Seeq Data Lab 需要安装在和 Seeq Server 不同的服务器上，并通过配置和 Seeq Server 互联。详细安装配置指令参见(Seeq 官方文档)[https://support.seeq.com/space/KB/1034059842]。
+Seeq Data Lab 需要安装在和 Seeq Server 不同的服务器上，并通过配置和 Seeq Server 互联。详细安装配置指令参见[Seeq 官方文档](https://support.seeq.com/space/KB/1034059842)。
 
 ```
 tar xvf seeq-data-lab-<version>-64bit-linux.tar.gz
@@ -51,7 +51,7 @@ sudo seeq config set Network/DataLab/Port 34231 # the port of the Data Lab serve
 
 ## TDengine 本地实例安装方法
 
-请参考(官网文档)[https://docs.taosdata.com/get-started/package/]。 
+请参考[官网文档](../../get-started)。 
 
 ## TDengine Cloud 访问方法
 如果使用 Seeq 连接 TDengine Cloud，请在 https://cloud.taosdata.com 申请帐号并登录查看如何访问 TDengine Cloud。
@@ -64,7 +64,7 @@ sudo seeq config set Network/DataLab/Port 34231 # the port of the Data Lab serve
 sudo seeq config get Folders/Data
 ```
 
-2. 从 maven.org 下载 TDengine Java connector 包，目前最新版本为(3.2.4)[https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/3.2.4/taos-jdbcdriver-3.2.4-dist.jar]，并拷贝至 data 存储位置的 plugins\lib 中。
+2. 从 maven.org 下载 TDengine Java connector 包，目前最新版本为[3.2.5](https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/3.2.5/taos-jdbcdriver-3.2.5-dist.jar)，并拷贝至 data 存储位置的 plugins\lib 中。
 
 3. 重新启动 seeq server
 
@@ -91,7 +91,7 @@ CREATE STABLE meters (ts TIMESTAMP, num INT, temperature FLOAT, goods INT) TAGS
 CREATE TABLE goods (ts1 TIMESTAMP, ts2 TIMESTAMP, goods FLOAT);
 ```
 
-!(Seeq demo schema)[./seeq/seeq-demo-schema.webp]
+![Seeq demo schema](./seeq/seeq-demo-schema.webp)
 
 ### 构造数据方法
 
@@ -99,7 +99,8 @@ CREATE TABLE goods (ts1 TIMESTAMP, ts2 TIMESTAMP, goods FLOAT);
 python mockdata.py
 taos -s "insert into power.goods select _wstart, _wstart + 10d, avg(goods) from power.meters interval(10d);"
 ```
-源代码托管在(github 仓库)[https://github.com/sangshuduo/td-forecasting]。
+
+源代码托管在[GitHub 仓库](https://github.com/sangshuduo/td-forecasting)。
 
 ### 使用 Seeq 进行数据分析
 
@@ -287,9 +288,9 @@ taos -s "insert into power.goods select _wstart, _wstart + 10d, avg(goods) from
 
 #### 使用 Seeq Workbench
 
-登录 Seeq 服务页面并新建 Seeq Workbench，通过选择数据源搜索结果和根据需要选择不同的工具，可以进行数据展现或预测，详细使用方法参见(官方知识库)[https://support.seeq.com/space/KB/146440193/Seeq+Workbench]。
+登录 Seeq 服务页面并新建 Seeq Workbench，通过选择数据源搜索结果和根据需要选择不同的工具，可以进行数据展现或预测，详细使用方法参见[官方知识库](https://support.seeq.com/space/KB/146440193/Seeq+Workbench)。
 
-!(Seeq Workbench)[./seeq/seeq-demo-workbench.webp]
+![Seeq Workbench](./seeq/seeq-demo-workbench.webp)
 
 #### 用 Seeq Data Lab Server 进行进一步的数据分析
 
@@ -358,7 +359,7 @@ plt.show()
 
 运行程序输出结果：
 
-!(Seeq forecast result)[./seeq/seeq-forecast-result.webp]
+![Seeq forecast result](./seeq/seeq-forecast-result.webp)
 
 ### 配置 Seeq 数据源连接 TDengine Cloud
 
@@ -426,7 +427,7 @@ plt.show()
 
 #### TDengine Cloud 作为数据源的 Seeq Workbench 界面示例
 
-!(Seeq workbench with TDengine cloud)[./seeq/seeq-workbench-with-tdengine-cloud.webp]
+![Seeq workbench with TDengine cloud](./seeq/seeq-workbench-with-tdengine-cloud.webp)
 
 ## 方案总结
 

docs/zh/28-releases/01-tdengine.md

@@ -10,6 +10,10 @@ TDengine 2.x 各版本安装包请访问[这里](https://www.taosdata.com/all-do
 
 import Release from "/components/ReleaseV3";
 
+## 3.1.1.0
+
+<Release type="tdengine" version="3.1.1.0" />
+
 ## 3.1.0.3
 
 <Release type="tdengine" version="3.1.0.3" />

examples/c/prepare.c

@@ -43,7 +43,7 @@ int main(int argc, char *argv[])
   taos_free_result(result);
 
   // create table
-  const char* sql = "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))";
+  const char* sql = "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10), varbin varbinary(16))";
   result = taos_query(taos, sql);
   code = taos_errno(result);
   if (code != 0) {
@@ -68,6 +68,7 @@ int main(int argc, char *argv[])
       double f8;
       char bin[40];
       char blob[80];
+      int8_t varbin[16];
   } v = {0};
 
   int32_t boolLen = sizeof(int8_t);
@@ -80,7 +81,7 @@ int main(int argc, char *argv[])
   int32_t ncharLen = 30;
 
   stmt = taos_stmt_init(taos);
-  TAOS_MULTI_BIND params[10];
+  TAOS_MULTI_BIND params[11];
   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
   params[0].buffer_length = sizeof(v.ts);
   params[0].buffer = &v.ts;
@@ -152,9 +153,19 @@ int main(int argc, char *argv[])
   params[9].is_null = NULL;
   params[9].num = 1;
 
+  int8_t tmp[16] = {'a', 0, 1, 13, '1'};
+  int32_t vbinLen = 5;
+  memcpy(v.varbin, tmp, sizeof(v.varbin));
+  params[10].buffer_type = TSDB_DATA_TYPE_VARBINARY;
+  params[10].buffer_length = sizeof(v.varbin);
+  params[10].buffer = v.varbin;
+  params[10].length = &vbinLen;
+  params[10].is_null = NULL;
+  params[10].num = 1;
+
   char is_null = 1;
 
-  sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?)";
+  sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?,?)";
   code = taos_stmt_prepare(stmt, sql, 0);
   if (code != 0){
     printf("failed to execute taos_stmt_prepare. code:0x%x\n", code);
@@ -162,7 +173,7 @@ int main(int argc, char *argv[])
   v.ts = 1591060628000;
   for (int i = 0; i < 10; ++i) {
     v.ts += 1;
-    for (int j = 1; j < 10; ++j) {
+    for (int j = 1; j < 11; ++j) {
       params[j].is_null = ((i == j) ? &is_null : 0);
     }
     v.b = (int8_t)i % 2;
@@ -216,7 +227,7 @@ int main(int argc, char *argv[])
     printf("expect two rows, but %d rows are fetched\n", rows);
   }
 
-  taos_free_result(result);
+//  taos_free_result(result);
   taos_stmt_close(stmt);
 
   return 0;

examples/c/tmq.c

@@ -280,7 +280,7 @@ void consume_repeatly(tmq_t* tmq) {
 
     code = tmq_offset_seek(tmq, topic_name, p->vgId, p->begin);
     if (code != 0) {
-      fprintf(stderr, "failed to seek to %ld, reason:%s", p->begin, tmq_err2str(code));
+      fprintf(stderr, "failed to seek to %d, reason:%s", (int)p->begin, tmq_err2str(code));
     }
   }
 

include/client/taos.h

@@ -272,7 +272,7 @@ typedef struct tmq_topic_assignment {
   int32_t vgId;
   int64_t currentOffset;
   int64_t begin;
-  int64_t end;  // The last invalidate version of wal + 1
+  int64_t end;
 } tmq_topic_assignment;
 
 DLL_EXPORT tmq_conf_t    *tmq_conf_new();
@@ -305,7 +305,7 @@ DLL_EXPORT int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t v
 DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
 DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
 DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
-DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);  // Get current offset of the result
+DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);
 DLL_EXPORT const char *tmq_err2str(int32_t code);
 
 /* ------------------------------ TAOSX -----------------------------------*/

include/common/tdatablock.h

@@ -179,6 +179,8 @@ int32_t getJsonValueLen(const char* data);
 int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull);
 int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData);
 int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows, bool trimValue);
+int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
+                            uint32_t numOfRows, bool isNull);
 int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
                         const SColumnInfoData* pSource, int32_t numOfRow2);
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,
@@ -241,7 +243,7 @@ int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols);
 const char* blockDecode(SSDataBlock* pBlock, const char* pData);
 
 // for debug
-char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf);
+char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf, const char* taskIdStr);
 
 int32_t buildSubmitReqFromDataBlock(SSubmitReq2** pReq, const SSDataBlock* pDataBlocks, const STSchema* pTSchema, int64_t uid, int32_t vgId,
                                     tb_uid_t suid);

include/common/tglobal.h

@@ -102,6 +102,11 @@ extern uint16_t tsMonitorPort;
 extern int32_t  tsMonitorMaxLogs;
 extern bool     tsMonitorComp;
 
+// audit
+extern bool     tsEnableAudit;
+extern char     tsAuditFqdn[];
+extern uint16_t tsAuditPort;
+
 // telem
 extern bool     tsEnableTelem;
 extern int32_t  tsTelemInterval;
@@ -130,6 +135,7 @@ extern bool    tsKeepColumnName;
 extern bool    tsEnableQueryHb;
 extern bool    tsEnableScience;
 extern bool    tsTtlChangeOnWrite;
+extern int32_t tsTtlFlushThreshold;
 extern int32_t tsRedirectPeriod;
 extern int32_t tsRedirectFactor;
 extern int32_t tsRedirectMaxPeriod;
@@ -161,6 +167,7 @@ extern char     tsCompressor[];
 // tfs
 extern int32_t  tsDiskCfgNum;
 extern SDiskCfg tsDiskCfg[];
+extern int64_t  tsMinDiskFreeSize;
 
 // udf
 extern bool tsStartUdfd;
@@ -184,8 +191,11 @@ extern int64_t tsWalFsyncDataSizeLimit;
 extern int32_t tsTransPullupInterval;
 extern int32_t tsMqRebalanceInterval;
 extern int32_t tsStreamCheckpointTickInterval;
+extern int32_t tsStreamNodeCheckInterval;
 extern int32_t tsTtlUnit;
-extern int32_t tsTtlPushInterval;
+extern int32_t tsTtlPushIntervalSec;
+extern int32_t tsTtlBatchDropNum;
+extern int32_t tsTrimVDbIntervalSec;
 extern int32_t tsGrantHBInterval;
 extern int32_t tsUptimeInterval;
 
@@ -194,7 +204,6 @@ extern int32_t tsRpcRetryInterval;
 
 extern bool    tsDisableStream;
 extern int64_t tsStreamBufferSize;
-extern int64_t tsCheckpointInterval;
 extern bool    tsFilterScalarMode;
 extern int32_t tsKeepTimeOffset;
 extern int32_t tsMaxStreamBackendCache;

include/common/tmisce.h

@@ -28,6 +28,22 @@ typedef struct SCorEpSet {
 } SCorEpSet;
 
 #define GET_ACTIVE_EP(_eps) (&((_eps)->eps[(_eps)->inUse]))
+
+#define EPSET_TO_STR(_eps, tbuf)                                                                                       \
+  do {                                                                                                                 \
+    int len = snprintf((tbuf), sizeof(tbuf), "epset:{");                                                               \
+    for (int _i = 0; _i < (_eps)->numOfEps; _i++) {                                                                    \
+      if (_i == (_eps)->numOfEps - 1) {                                                                                \
+        len +=                                                                                                         \
+            snprintf((tbuf) + len, sizeof(tbuf) - len, "%d. %s:%d", _i, (_eps)->eps[_i].fqdn, (_eps)->eps[_i].port);   \
+      } else {                                                                                                         \
+        len +=                                                                                                         \
+            snprintf((tbuf) + len, sizeof(tbuf) - len, "%d. %s:%d, ", _i, (_eps)->eps[_i].fqdn, (_eps)->eps[_i].port); \
+      }                                                                                                                \
+    }                                                                                                                  \
+    len += snprintf((tbuf) + len, sizeof(tbuf) - len, "}, inUse:%d", (_eps)->inUse);                                   \
+  } while (0);
+
 int32_t taosGetFqdnPortFromEp(const char* ep, SEp* pEp);
 void    addEpIntoEpSet(SEpSet* pEpSet, const char* fqdn, uint16_t port);
 

include/common/tmsg.h

@@ -77,7 +77,8 @@ static inline bool tmsgIsValid(tmsg_t type) {
 }
 static inline bool vnodeIsMsgBlock(tmsg_t type) {
   return (type == TDMT_VND_CREATE_TABLE) || (type == TDMT_VND_ALTER_TABLE) || (type == TDMT_VND_DROP_TABLE) ||
-         (type == TDMT_VND_UPDATE_TAG_VAL) || (type == TDMT_VND_ALTER_CONFIRM) || (type == TDMT_VND_COMMIT);
+         (type == TDMT_VND_UPDATE_TAG_VAL) || (type == TDMT_VND_ALTER_CONFIRM) || (type == TDMT_VND_COMMIT) ||
+         (type == TDMT_SYNC_CONFIG_CHANGE);
 }
 
 static inline bool syncUtilUserCommit(tmsg_t msgType) {
@@ -212,6 +213,215 @@ typedef enum _mgmt_table {
 #define TD_REQ_FROM_APP  0
 #define TD_REQ_FROM_TAOX 1
 
+typedef enum ENodeType {
+  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN,
+  // VALUE, OPERATOR, FUNCTION and so on.
+  QUERY_NODE_COLUMN = 1,
+  QUERY_NODE_VALUE,
+  QUERY_NODE_OPERATOR,
+  QUERY_NODE_LOGIC_CONDITION,
+  QUERY_NODE_FUNCTION,
+  QUERY_NODE_REAL_TABLE,
+  QUERY_NODE_TEMP_TABLE,
+  QUERY_NODE_JOIN_TABLE,
+  QUERY_NODE_GROUPING_SET,
+  QUERY_NODE_ORDER_BY_EXPR,
+  QUERY_NODE_LIMIT,
+  QUERY_NODE_STATE_WINDOW,
+  QUERY_NODE_SESSION_WINDOW,
+  QUERY_NODE_INTERVAL_WINDOW,
+  QUERY_NODE_NODE_LIST,
+  QUERY_NODE_FILL,
+  QUERY_NODE_RAW_EXPR,  // Only be used in parser module.
+  QUERY_NODE_TARGET,
+  QUERY_NODE_DATABLOCK_DESC,
+  QUERY_NODE_SLOT_DESC,
+  QUERY_NODE_COLUMN_DEF,
+  QUERY_NODE_DOWNSTREAM_SOURCE,
+  QUERY_NODE_DATABASE_OPTIONS,
+  QUERY_NODE_TABLE_OPTIONS,
+  QUERY_NODE_INDEX_OPTIONS,
+  QUERY_NODE_EXPLAIN_OPTIONS,
+  QUERY_NODE_STREAM_OPTIONS,
+  QUERY_NODE_LEFT_VALUE,
+  QUERY_NODE_COLUMN_REF,
+  QUERY_NODE_WHEN_THEN,
+  QUERY_NODE_CASE_WHEN,
+  QUERY_NODE_EVENT_WINDOW,
+  QUERY_NODE_HINT,
+
+  // Statement nodes are used in parser and planner module.
+  QUERY_NODE_SET_OPERATOR = 100,
+  QUERY_NODE_SELECT_STMT,
+  QUERY_NODE_VNODE_MODIFY_STMT,
+  QUERY_NODE_CREATE_DATABASE_STMT,
+  QUERY_NODE_DROP_DATABASE_STMT,
+  QUERY_NODE_ALTER_DATABASE_STMT,
+  QUERY_NODE_FLUSH_DATABASE_STMT,
+  QUERY_NODE_TRIM_DATABASE_STMT,
+  QUERY_NODE_CREATE_TABLE_STMT,
+  QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
+  QUERY_NODE_CREATE_MULTI_TABLES_STMT,
+  QUERY_NODE_DROP_TABLE_CLAUSE,
+  QUERY_NODE_DROP_TABLE_STMT,
+  QUERY_NODE_DROP_SUPER_TABLE_STMT,
+  QUERY_NODE_ALTER_TABLE_STMT,
+  QUERY_NODE_ALTER_SUPER_TABLE_STMT,
+  QUERY_NODE_CREATE_USER_STMT,
+  QUERY_NODE_ALTER_USER_STMT,
+  QUERY_NODE_DROP_USER_STMT,
+  QUERY_NODE_USE_DATABASE_STMT,
+  QUERY_NODE_CREATE_DNODE_STMT,
+  QUERY_NODE_DROP_DNODE_STMT,
+  QUERY_NODE_ALTER_DNODE_STMT,
+  QUERY_NODE_CREATE_INDEX_STMT,
+  QUERY_NODE_DROP_INDEX_STMT,
+  QUERY_NODE_CREATE_QNODE_STMT,
+  QUERY_NODE_DROP_QNODE_STMT,
+  QUERY_NODE_CREATE_BNODE_STMT,
+  QUERY_NODE_DROP_BNODE_STMT,
+  QUERY_NODE_CREATE_SNODE_STMT,
+  QUERY_NODE_DROP_SNODE_STMT,
+  QUERY_NODE_CREATE_MNODE_STMT,
+  QUERY_NODE_DROP_MNODE_STMT,
+  QUERY_NODE_CREATE_TOPIC_STMT,
+  QUERY_NODE_DROP_TOPIC_STMT,
+  QUERY_NODE_DROP_CGROUP_STMT,
+  QUERY_NODE_ALTER_LOCAL_STMT,
+  QUERY_NODE_EXPLAIN_STMT,
+  QUERY_NODE_DESCRIBE_STMT,
+  QUERY_NODE_RESET_QUERY_CACHE_STMT,
+  QUERY_NODE_COMPACT_DATABASE_STMT,
+  QUERY_NODE_CREATE_FUNCTION_STMT,
+  QUERY_NODE_DROP_FUNCTION_STMT,
+  QUERY_NODE_CREATE_STREAM_STMT,
+  QUERY_NODE_DROP_STREAM_STMT,
+  QUERY_NODE_BALANCE_VGROUP_STMT,
+  QUERY_NODE_MERGE_VGROUP_STMT,
+  QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
+  QUERY_NODE_SPLIT_VGROUP_STMT,
+  QUERY_NODE_SYNCDB_STMT,
+  QUERY_NODE_GRANT_STMT,
+  QUERY_NODE_REVOKE_STMT,
+  QUERY_NODE_SHOW_DNODES_STMT,
+  QUERY_NODE_SHOW_MNODES_STMT,
+  QUERY_NODE_SHOW_MODULES_STMT,
+  QUERY_NODE_SHOW_QNODES_STMT,
+  QUERY_NODE_SHOW_SNODES_STMT,
+  QUERY_NODE_SHOW_BNODES_STMT,
+  QUERY_NODE_SHOW_CLUSTER_STMT,
+  QUERY_NODE_SHOW_DATABASES_STMT,
+  QUERY_NODE_SHOW_FUNCTIONS_STMT,
+  QUERY_NODE_SHOW_INDEXES_STMT,
+  QUERY_NODE_SHOW_STABLES_STMT,
+  QUERY_NODE_SHOW_STREAMS_STMT,
+  QUERY_NODE_SHOW_TABLES_STMT,
+  QUERY_NODE_SHOW_TAGS_STMT,
+  QUERY_NODE_SHOW_USERS_STMT,
+  QUERY_NODE_SHOW_LICENCES_STMT,
+  QUERY_NODE_SHOW_VGROUPS_STMT,
+  QUERY_NODE_SHOW_TOPICS_STMT,
+  QUERY_NODE_SHOW_CONSUMERS_STMT,
+  QUERY_NODE_SHOW_CONNECTIONS_STMT,
+  QUERY_NODE_SHOW_QUERIES_STMT,
+  QUERY_NODE_SHOW_APPS_STMT,
+  QUERY_NODE_SHOW_VARIABLES_STMT,
+  QUERY_NODE_SHOW_DNODE_VARIABLES_STMT,
+  QUERY_NODE_SHOW_TRANSACTIONS_STMT,
+  QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT,
+  QUERY_NODE_SHOW_VNODES_STMT,
+  QUERY_NODE_SHOW_USER_PRIVILEGES_STMT,
+  QUERY_NODE_SHOW_CREATE_DATABASE_STMT,
+  QUERY_NODE_SHOW_CREATE_TABLE_STMT,
+  QUERY_NODE_SHOW_CREATE_STABLE_STMT,
+  QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT,
+  QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT,
+  QUERY_NODE_SHOW_SCORES_STMT,
+  QUERY_NODE_SHOW_TABLE_TAGS_STMT,
+  QUERY_NODE_KILL_CONNECTION_STMT,
+  QUERY_NODE_KILL_QUERY_STMT,
+  QUERY_NODE_KILL_TRANSACTION_STMT,
+  QUERY_NODE_DELETE_STMT,
+  QUERY_NODE_INSERT_STMT,
+  QUERY_NODE_QUERY,
+  QUERY_NODE_SHOW_DB_ALIVE_STMT,
+  QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT,
+  QUERY_NODE_BALANCE_VGROUP_LEADER_STMT,
+  QUERY_NODE_RESTORE_DNODE_STMT,
+  QUERY_NODE_RESTORE_QNODE_STMT,
+  QUERY_NODE_RESTORE_MNODE_STMT,
+  QUERY_NODE_RESTORE_VNODE_STMT,
+  QUERY_NODE_PAUSE_STREAM_STMT,
+  QUERY_NODE_RESUME_STREAM_STMT,
+
+  // logic plan node
+  QUERY_NODE_LOGIC_PLAN_SCAN = 1000,
+  QUERY_NODE_LOGIC_PLAN_JOIN,
+  QUERY_NODE_LOGIC_PLAN_AGG,
+  QUERY_NODE_LOGIC_PLAN_PROJECT,
+  QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY,
+  QUERY_NODE_LOGIC_PLAN_EXCHANGE,
+  QUERY_NODE_LOGIC_PLAN_MERGE,
+  QUERY_NODE_LOGIC_PLAN_WINDOW,
+  QUERY_NODE_LOGIC_PLAN_FILL,
+  QUERY_NODE_LOGIC_PLAN_SORT,
+  QUERY_NODE_LOGIC_PLAN_PARTITION,
+  QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC,
+  QUERY_NODE_LOGIC_PLAN_INTERP_FUNC,
+  QUERY_NODE_LOGIC_SUBPLAN,
+  QUERY_NODE_LOGIC_PLAN,
+  QUERY_NODE_LOGIC_PLAN_GROUP_CACHE,
+  QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL,
+
+  // physical plan node
+  QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
+  QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE,
+  QUERY_NODE_PHYSICAL_PLAN_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL,
+  QUERY_NODE_PHYSICAL_PLAN_FILL,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE,
+  QUERY_NODE_PHYSICAL_PLAN_PARTITION,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION,
+  QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC,
+  QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
+  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
+  QUERY_NODE_PHYSICAL_PLAN_INSERT,
+  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
+  QUERY_NODE_PHYSICAL_PLAN_DELETE,
+  QUERY_NODE_PHYSICAL_SUBPLAN,
+  QUERY_NODE_PHYSICAL_PLAN,
+  QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN,
+  QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT,
+  QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT,
+  QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN,
+  QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE,
+  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL  
+} ENodeType;
+
+
 typedef struct {
   int32_t vgId;
   char*   dbFName;
@@ -741,6 +951,10 @@ typedef struct STimeWindow {
   TSKEY ekey;
 } STimeWindow;
 
+typedef struct SQueryHint {
+  bool batchScan;
+} SQueryHint;
+
 typedef struct {
   int32_t tsOffset;       // offset value in current msg body, NOTE: ts list is compressed
   int32_t tsLen;          // total length of ts comp block
@@ -759,12 +973,18 @@ typedef struct {
   int64_t offset;
 } SInterval;
 
-typedef struct {
+
-  int32_t code;
+typedef struct STbVerInfo {
   char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
   int32_t tversion;
+} STbVerInfo;
+
+
+typedef struct {
+  int32_t code;
   int64_t affectedRows;
+  SArray* tbVerInfo;  // STbVerInfo
 } SQueryTableRsp;
 
 int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
@@ -939,6 +1159,9 @@ int32_t tDeserializeSVTrimDbReq(void* buf, int32_t bufLen, SVTrimDbReq* pReq);
 
 typedef struct {
   int32_t timestampSec;
+  int32_t ttlDropMaxCount;
+  int32_t nUids;
+  SArray* pTbUids;
 } SVDropTtlTableReq;
 
 int32_t tSerializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq* pReq);
@@ -1163,6 +1386,9 @@ typedef struct {
   int32_t vgId;
   int8_t  syncState;
   int8_t  syncRestore;
+  int64_t syncTerm;
+  int64_t roleTimeMs;
+  int64_t startTimeMs;
   int8_t  syncCanRead;
   int64_t cacheUsage;
   int64_t numOfTables;
@@ -1176,12 +1402,13 @@ typedef struct {
   int64_t numOfBatchInsertReqs;
   int64_t numOfBatchInsertSuccessReqs;
   int32_t numOfCachedTables;
+  int32_t learnerProgress; // use one reservered
 } SVnodeLoad;
 
 typedef struct {
-  int8_t syncState;
+  int8_t  syncState;
-  int8_t syncRestore;
   int64_t syncTerm;
+  int8_t  syncRestore;
   int64_t roleTimeMs;
 } SMnodeLoad;
 
@@ -1191,6 +1418,7 @@ typedef struct {
   int64_t numOfProcessedCQuery;
   int64_t numOfProcessedFetch;
   int64_t numOfProcessedDrop;
+  int64_t numOfProcessedNotify;
   int64_t numOfProcessedHb;
   int64_t numOfProcessedDelete;
   int64_t cacheDataSize;
@@ -1317,6 +1545,7 @@ typedef struct {
   int8_t   learnerReplica;
   int8_t   learnerSelfIndex;
   SReplica learnerReplicas[TSDB_MAX_LEARNER_REPLICA];
+  int32_t  changeVersion;
 } SCreateVnodeReq;
 
 int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
@@ -1391,7 +1620,8 @@ typedef struct {
   int8_t   learnerSelfIndex;
   int8_t   learnerReplica;
   SReplica learnerReplicas[TSDB_MAX_LEARNER_REPLICA];
-} SAlterVnodeReplicaReq, SAlterVnodeTypeReq;
+  int32_t  changeVersion;
+} SAlterVnodeReplicaReq, SAlterVnodeTypeReq, SCheckLearnCatchupReq;
 
 int32_t tSerializeSAlterVnodeReplicaReq(void* buf, int32_t bufLen, SAlterVnodeReplicaReq* pReq);
 int32_t tDeserializeSAlterVnodeReplicaReq(void* buf, int32_t bufLen, SAlterVnodeReplicaReq* pReq);
@@ -1409,7 +1639,8 @@ typedef struct {
   int32_t  dstVgId;
   uint32_t hashBegin;
   uint32_t hashEnd;
-  int64_t  reserved;
+  int32_t  changeVersion;
+  int32_t  reserved;
 } SAlterVnodeHashRangeReq;
 
 int32_t tSerializeSAlterVnodeHashRangeReq(void* buf, int32_t bufLen, SAlterVnodeHashRangeReq* pReq);
@@ -1831,12 +2062,26 @@ typedef struct {
   int32_t tversion;
 } SResReadyRsp;
 
+
+typedef struct SOperatorParam {
+  int32_t             opType;
+  int32_t             downstreamIdx;
+  void*               value;
+  SArray*             pChildren; //SArray<SOperatorParam*>
+} SOperatorParam;
+
+typedef struct STableScanOperatorParam {
+  bool                tableSeq;
+  SArray*             pUidList;
+} STableScanOperatorParam;
+
 typedef struct {
-  SMsgHead header;
+  SMsgHead        header;
-  uint64_t sId;
+  uint64_t        sId;
-  uint64_t queryId;
+  uint64_t        queryId;
-  uint64_t taskId;
+  uint64_t        taskId;
-  int32_t  execId;
+  int32_t         execId;
+  SOperatorParam* pOpParam;
 } SResFetchReq;
 
 int32_t tSerializeSResFetchReq(void* buf, int32_t bufLen, SResFetchReq* pReq);
@@ -1915,8 +2160,24 @@ typedef struct {
 
 int32_t tSerializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
 int32_t tDeserializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
-int32_t tSerializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
+
-int32_t tDeserializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
+
+typedef enum {
+  TASK_NOTIFY_FINISHED = 1,
+} ETaskNotifyType;
+
+typedef struct {
+  SMsgHead        header;
+  uint64_t        sId;
+  uint64_t        queryId;
+  uint64_t        taskId;
+  int64_t         refId;
+  int32_t         execId;
+  ETaskNotifyType type;
+} STaskNotifyReq;
+
+int32_t tSerializeSTaskNotifyReq(void* buf, int32_t bufLen, STaskNotifyReq* pReq);
+int32_t tDeserializeSTaskNotifyReq(void* buf, int32_t bufLen, STaskNotifyReq* pReq);
 
 int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
 int32_t tDeserializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);

include/common/tmsgdef.h

@@ -65,7 +65,7 @@ enum {
 #define TD_NEW_MSG_SEG(TYPE) TYPE = ((TYPE##_SEG_CODE) << 8),
 #define TD_DEF_MSG_TYPE(TYPE, MSG, REQ, RSP) TYPE, TYPE##_RSP,
 
-enum {
+enum { // WARN: new msg should be appended to segment tail
 #endif
   TD_NEW_MSG_SEG(TDMT_DND_MSG)
   TD_DEF_MSG_TYPE(TDMT_DND_CREATE_MNODE, "dnode-create-mnode", NULL, NULL)
@@ -85,18 +85,19 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_DND_MAX_MSG, "dnd-max", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_ALTER_MNODE_TYPE, "dnode-alter-mnode-type", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_ALTER_VNODE_TYPE, "dnode-alter-vnode-type", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_CHECK_VNODE_LEARNER_CATCHUP, "dnode-check-vnode-learner-catchup", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_MND_MSG)
   TD_DEF_MSG_TYPE(TDMT_MND_CONNECT, "connect", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_ACCT, "create-acct", NULL, NULL)	
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_ACCT, "create-acct", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_ACCT, "alter-acct", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_ACCT, "drop-acct", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_USER, "create-user", NULL, NULL)	
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_USER, "create-user", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_USER, "alter-user", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_DROP_USER, "drop-user", NULL, NULL) 
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_USER, "drop-user", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_GET_USER_AUTH, "get-user-auth", NULL, NULL) 
+  TD_DEF_MSG_TYPE(TDMT_MND_GET_USER_AUTH, "get-user-auth", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_DNODE, "create-dnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_CONFIG_DNODE, "config-dnode", NULL, NULL) 
+  TD_DEF_MSG_TYPE(TDMT_MND_CONFIG_DNODE, "config-dnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_DNODE, "drop-dnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_MNODE, "create-mnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_MNODE, "alter-mnode", NULL, NULL)
@@ -156,6 +157,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_TRANS_TIMER, "trans-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TTL_TIMER, "ttl-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GRANT_HB_TIMER, "grant-hb-tmr", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_NODECHECK_TIMER, "node-check-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_TRANS, "kill-trans", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_QUERY, "kill-query", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_CONN, "kill-conn", NULL, NULL)
@@ -174,13 +176,17 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_SERVER_VERSION, "server-version", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_UPTIME_TIMER, "uptime-timer", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, "lost-consumer-clear", NULL, NULL)
-  // TD_DEF_MSG_TYPE(TDMT_MND_STREAM_CHECKPOINT_TIMER, "stream-checkpoint-tmr", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_HEARTBEAT, "stream-heartbeat", NULL, NULL)
-  // TD_DEF_MSG_TYPE(TDMT_MND_STREAM_BEGIN_CHECKPOINT, "stream-begin-checkpoint", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", NULL, NULL)
+
   TD_DEF_MSG_TYPE(TDMT_MND_BALANCE_VGROUP_LEADER, "balance-vgroup-leader", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_RESTORE_DNODE, "restore-dnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_PAUSE_STREAM, "pause-stream", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_RESUME_STREAM, "resume-stream", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_CHECKPOINT_TIMER, "stream-checkpoint-tmr", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_BEGIN_CHECKPOINT, "stream-begin-checkpoint", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_STREAM_NODECHANGE_CHECK, "stream-nodechange-check", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TRIM_DB_TIMER, "trim-db-tmr", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_VND_MSG)
   TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT, "submit", SSubmitReq, SSubmitRsp)
@@ -242,6 +248,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_SCH_DROP_TASK, "drop-task", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_SCH_EXPLAIN, "explain", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "link-broken", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_SCH_TASK_NOTIFY, "task-notify", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_SCH_MAX_MSG, "sch-max", NULL, NULL)
 
 
@@ -252,15 +259,13 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_DISPATCH, "stream-task-dispatch", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_UNUSED1, "stream-unused1", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_RETRIEVE, "stream-retrieve", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_SCAN_HISTORY, "stream-scan-history", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_CHECKPOINT_READY, "stream-checkpoint-ready", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_SCAN_HISTORY_FINISH, "stream-scan-history-finish", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_CHECK, "stream-task-check", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_CHECKPOINT, "stream-checkpoint", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_REPORT_CHECKPOINT, "stream-report-checkpoint", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_RESTORE_CHECKPOINT, "stream-restore-checkpoint", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_STREAM_MAX_MSG, "stream-max", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_PAUSE, "stream-task-pause", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_RESUME, "stream-task-resume", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_STOP, "stream-task-stop", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_STREAM_MAX_MSG, "stream-max", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_MON_MSG)
   TD_DEF_MSG_TYPE(TDMT_MON_MAX_MSG, "monitor-max", NULL, NULL)
@@ -295,11 +300,14 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_SYNC_PRE_SNAPSHOT_REPLY, "sync-pre-snapshot-reply", NULL, NULL) // no longer used
   TD_DEF_MSG_TYPE(TDMT_SYNC_MAX_MSG, "sync-max", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_SYNC_FORCE_FOLLOWER, "sync-force-become-follower", NULL, NULL)
-  
+
   TD_NEW_MSG_SEG(TDMT_VND_STREAM_MSG)
-  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
+//  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_STREAM_SCAN_HISTORY, "vnode-stream-scan-history", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_SCAN_HISTORY_FINISH, "vnode-stream-scan-history-finish", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_STREAM_CHECK_POINT_SOURCE, "vnode-stream-checkpoint-source", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TASK_UPDATE, "vnode-stream-update", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TASK_CHECK, "vnode-stream-task-check", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_STREAM_MAX_MSG, "vnd-stream-max", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_VND_TMQ_MSG)

include/common/ttokendef.h

@@ -276,91 +276,96 @@
 #define TK_JOIN                           258
 #define TK_INNER                          259
 #define TK_SELECT                         260
-#define TK_DISTINCT                       261
+#define TK_NK_HINT                        261
-#define TK_WHERE                          262
+#define TK_DISTINCT                       262
-#define TK_PARTITION                      263
+#define TK_WHERE                          263
-#define TK_BY                             264
+#define TK_PARTITION                      264
-#define TK_SESSION                        265
+#define TK_BY                             265
-#define TK_STATE_WINDOW                   266
+#define TK_SESSION                        266
-#define TK_EVENT_WINDOW                   267
+#define TK_STATE_WINDOW                   267
-#define TK_SLIDING                        268
+#define TK_EVENT_WINDOW                   268
-#define TK_FILL                           269
+#define TK_SLIDING                        269
-#define TK_VALUE                          270
+#define TK_FILL                           270
-#define TK_VALUE_F                        271
+#define TK_VALUE                          271
-#define TK_NONE                           272
+#define TK_VALUE_F                        272
-#define TK_PREV                           273
+#define TK_NONE                           273
-#define TK_NULL_F                         274
+#define TK_PREV                           274
-#define TK_LINEAR                         275
+#define TK_NULL_F                         275
-#define TK_NEXT                           276
+#define TK_LINEAR                         276
-#define TK_HAVING                         277
+#define TK_NEXT                           277
-#define TK_RANGE                          278
+#define TK_HAVING                         278
-#define TK_EVERY                          279
+#define TK_RANGE                          279
-#define TK_ORDER                          280
+#define TK_EVERY                          280
-#define TK_SLIMIT                         281
+#define TK_ORDER                          281
-#define TK_SOFFSET                        282
+#define TK_SLIMIT                         282
-#define TK_LIMIT                          283
+#define TK_SOFFSET                        283
-#define TK_OFFSET                         284
+#define TK_LIMIT                          284
-#define TK_ASC                            285
+#define TK_OFFSET                         285
-#define TK_NULLS                          286
+#define TK_ASC                            286
-#define TK_ABORT                          287
+#define TK_NULLS                          287
-#define TK_AFTER                          288
+#define TK_ABORT                          288
-#define TK_ATTACH                         289
+#define TK_AFTER                          289
-#define TK_BEFORE                         290
+#define TK_ATTACH                         290
-#define TK_BEGIN                          291
+#define TK_BEFORE                         291
-#define TK_BITAND                         292
+#define TK_BEGIN                          292
-#define TK_BITNOT                         293
+#define TK_BITAND                         293
-#define TK_BITOR                          294
+#define TK_BITNOT                         294
-#define TK_BLOCKS                         295
+#define TK_BITOR                          295
-#define TK_CHANGE                         296
+#define TK_BLOCKS                         296
-#define TK_COMMA                          297
+#define TK_CHANGE                         297
-#define TK_CONCAT                         298
+#define TK_COMMA                          298
-#define TK_CONFLICT                       299
+#define TK_CONCAT                         299
-#define TK_COPY                           300
+#define TK_CONFLICT                       300
-#define TK_DEFERRED                       301
+#define TK_COPY                           301
-#define TK_DELIMITERS                     302
+#define TK_DEFERRED                       302
-#define TK_DETACH                         303
+#define TK_DELIMITERS                     303
-#define TK_DIVIDE                         304
+#define TK_DETACH                         304
-#define TK_DOT                            305
+#define TK_DIVIDE                         305
-#define TK_EACH                           306
+#define TK_DOT                            306
-#define TK_FAIL                           307
+#define TK_EACH                           307
-#define TK_FILE                           308
+#define TK_FAIL                           308
-#define TK_FOR                            309
+#define TK_FILE                           309
-#define TK_GLOB                           310
+#define TK_FOR                            310
-#define TK_ID                             311
+#define TK_GLOB                           311
-#define TK_IMMEDIATE                      312
+#define TK_ID                             312
-#define TK_IMPORT                         313
+#define TK_IMMEDIATE                      313
-#define TK_INITIALLY                      314
+#define TK_IMPORT                         314
-#define TK_INSTEAD                        315
+#define TK_INITIALLY                      315
-#define TK_ISNULL                         316
+#define TK_INSTEAD                        316
-#define TK_KEY                            317
+#define TK_ISNULL                         317
-#define TK_MODULES                        318
+#define TK_KEY                            318
-#define TK_NK_BITNOT                      319
+#define TK_MODULES                        319
-#define TK_NK_SEMI                        320
+#define TK_NK_BITNOT                      320
-#define TK_NOTNULL                        321
+#define TK_NK_SEMI                        321
-#define TK_OF                             322
+#define TK_NOTNULL                        322
-#define TK_PLUS                           323
+#define TK_OF                             323
-#define TK_PRIVILEGE                      324
+#define TK_PLUS                           324
-#define TK_RAISE                          325
+#define TK_PRIVILEGE                      325
-#define TK_RESTRICT                       326
+#define TK_RAISE                          326
-#define TK_ROW                            327
+#define TK_RESTRICT                       327
-#define TK_SEMI                           328
+#define TK_ROW                            328
-#define TK_STAR                           329
+#define TK_SEMI                           329
-#define TK_STATEMENT                      330
+#define TK_STAR                           330
-#define TK_STRICT                         331
+#define TK_STATEMENT                      331
-#define TK_STRING                         332
+#define TK_STRICT                         332
-#define TK_TIMES                          333
+#define TK_STRING                         333
-#define TK_VALUES                         334
+#define TK_TIMES                          334
-#define TK_VARIABLE                       335
+#define TK_VALUES                         335
-#define TK_VIEW                           336
+#define TK_VARIABLE                       336
-#define TK_WAL                            337
+#define TK_VIEW                           337
+#define TK_WAL                            338
 
 
-#define TK_NK_SPACE   600
+
-#define TK_NK_COMMENT 601
+#define TK_NK_SPACE         600
-#define TK_NK_ILLEGAL 602
+#define TK_NK_COMMENT       601
-#define TK_NK_HEX     603  // hex number  0x123
+#define TK_NK_ILLEGAL       602
-#define TK_NK_OCT     604  // oct number
+#define TK_NK_HEX           603  // hex number  0x123
-#define TK_NK_BIN     605  // bin format data 0b111
+#define TK_NK_OCT           604  // oct number
+#define TK_NK_BIN           605  // bin format data 0b111
+#define TK_BATCH_SCAN       606
+#define TK_NO_BATCH_SCAN    607
+
 
 #define TK_NK_NIL 65535
 

include/common/ttypes.h

@@ -269,8 +269,8 @@ typedef struct {
   (IS_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL) || (_t) == (TSDB_DATA_TYPE_TIMESTAMP))
 
 #define IS_VAR_DATA_TYPE(t) \
-  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
+  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
-#define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR))
+#define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 #define IS_VALID_TINYINT(_t)   ((_t) >= INT8_MIN && (_t) <= INT8_MAX)
 #define IS_VALID_SMALLINT(_t)  ((_t) >= INT16_MIN && (_t) <= INT16_MAX)

include/libs/audit/audit.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_AUDIT_H_
+#define _TD_AUDIT_H_
+
+#include "tarray.h"
+#include "tdef.h"
+#include "tlog.h"
+#include "tmsg.h"
+#include "tjson.h"
+#include "tmsgcb.h"
+#include "trpc.h"
+#include "mnode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define AUDIT_DETAIL_MAX 16000
+
+typedef struct {
+  const char *server;
+  uint16_t    port;
+  bool        comp;
+} SAuditCfg;
+
+int32_t auditInit(const SAuditCfg *pCfg);
+void    auditSend(SJson *pJson);
+void    auditRecord(SRpcMsg *pReq, int64_t clusterId, char *operation, char *target1, char *target2, char *detail);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MONITOR_H_*/

include/libs/executor/dataSinkMgt.h

@@ -97,6 +97,8 @@ int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pC
 
 void dsEndPut(DataSinkHandle handle, uint64_t useconds);
 
+void dsReset(DataSinkHandle handle);
+
 /**
  * Get the length of the data returned by the next call to dsGetDataBlock.
  * @param handle

include/libs/executor/executor.h

@@ -41,23 +41,21 @@ typedef struct {
 } SLocalFetch;
 
 typedef struct {
-  void*   tqReader;
+  void*       tqReader;  // todo remove it
-  void*   config;
+  void*       vnode;
-  void*   vnode;
+  void*       mnd;
-  void*   mnd;
+  SMsgCb*     pMsgCb;
-  SMsgCb* pMsgCb;
+  int64_t     version;
-  int64_t version;
+  uint64_t    checkpointId;
-  bool    initMetaReader;
+  bool        initTableReader;
-  bool    initTableReader;
+  bool        initTqReader;
-  bool    initTqReader;
+  int32_t     numOfVgroups;
-  int32_t numOfVgroups;
+  void*       sContext;  // SSnapContext*
-  void*   sContext;  // SSnapContext*
+  void*       pStateBackend;
+  int8_t      fillHistory;
+  STimeWindow winRange;
 
-  void*   pStateBackend;
   struct SStorageAPI api;
-
-  int8_t        fillHistory;
-  STimeWindow   winRange;
 } SReadHandle;
 
 // in queue mode, data streams are seperated by msg
@@ -97,9 +95,6 @@ void qSetTaskId(qTaskInfo_t tinfo, uint64_t taskId, uint64_t queryId);
 
 int32_t qSetStreamOpOpen(qTaskInfo_t tinfo);
 
-// todo refactor
-void qGetCheckpointVersion(qTaskInfo_t tinfo, int64_t* dataVer, int64_t* ckId);
-
 /**
  * Set multiple input data blocks for the stream scan.
  * @param tinfo
@@ -130,6 +125,10 @@ int32_t qSetSMAInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks,
  */
 int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd);
 
+bool   qIsDynamicExecTask(qTaskInfo_t tinfo);
+
+void   qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam);
+
 /**
  * Create the exec task object according to task json
  * @param readHandle
@@ -150,7 +149,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
  * @return
  */
 int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                    int32_t* tversion);
+                                    int32_t* tversion, int32_t idx);
 
 /**
  * The main task execution function, including query on both table and multiple tables,

include/libs/executor/storageapi.h

@@ -98,6 +98,18 @@ typedef struct SMTbCursor {
   int8_t      paused;
 } SMTbCursor;
 
+typedef struct SMCtbCursor {
+  SMeta   *pMeta;
+  void    *pCur;
+  tb_uid_t suid;
+  void    *pKey;
+  void    *pVal;
+  int      kLen;
+  int      vLen;
+  int8_t     paused;
+  int      lock;
+} SMCtbCursor;
+
 typedef struct SRowBuffPos {
   void* pRowBuff;
   void* pKey;
@@ -278,13 +290,17 @@ typedef struct SStoreMeta {
   void (*getBasicInfo)(void* pVnode, const char** dbname, int32_t* vgId, int64_t* numOfTables,
                        int64_t* numOfNormalTables);  // vnodeGetInfo(void *pVnode, const char **dbname, int32_t *vgId) &
                                                      // metaGetTbNum(SMeta *pMeta) & metaGetNtbNum(SMeta *pMeta);
-
   int64_t (*getNumOfRowsInMem)(void* pVnode);
   /**
 int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list);
 int32_t vnodeGetCtbIdListByFilter(void *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg), void *arg);
 int32_t vnodeGetStbIdList(void *pVnode, int64_t suid, SArray *list);
  */
+  SMCtbCursor* (*openCtbCursor)(void *pVnode, tb_uid_t uid, int lock);
+  int32_t      (*resumeCtbCursor)(SMCtbCursor* pCtbCur, int8_t first);
+  void         (*pauseCtbCursor)(SMCtbCursor* pCtbCur);
+  void         (*closeCtbCursor)(SMCtbCursor *pCtbCur);
+  tb_uid_t     (*ctbCursorNext)(SMCtbCursor* pCur);
 } SStoreMeta;
 
 typedef struct SStoreMetaReader {
@@ -363,7 +379,7 @@ typedef struct SStateStore {
                                            state_key_cmpr_fn fn, void** pVal, int32_t* pVLen);
   int32_t (*streamStateSessionGetKeyByRange)(SStreamState* pState, const SSessionKey* range, SSessionKey* curKey);
 
-  SUpdateInfo* (*updateInfoInit)(int64_t interval, int32_t precision, int64_t watermark);
+  SUpdateInfo* (*updateInfoInit)(int64_t interval, int32_t precision, int64_t watermark, bool igUp);
   TSKEY (*updateInfoFillBlockData)(SUpdateInfo* pInfo, SSDataBlock* pBlock, int32_t primaryTsCol);
   bool (*updateInfoIsUpdated)(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts);
   bool (*updateInfoIsTableInserted)(SUpdateInfo* pInfo, int64_t tbUid);
@@ -371,7 +387,7 @@ typedef struct SStateStore {
   void (*windowSBfDelete)(SUpdateInfo *pInfo, uint64_t count);
   void (*windowSBfAdd)(SUpdateInfo *pInfo, uint64_t count);
 
-  SUpdateInfo* (*updateInfoInitP)(SInterval* pInterval, int64_t watermark);
+  SUpdateInfo* (*updateInfoInitP)(SInterval* pInterval, int64_t watermark, bool igUp);
   void (*updateInfoAddCloseWindowSBF)(SUpdateInfo* pInfo);
   void (*updateInfoDestoryColseWinSBF)(SUpdateInfo* pInfo);
   int32_t (*updateInfoSerialize)(void* buf, int32_t bufLen, const SUpdateInfo* pInfo);
@@ -382,7 +398,8 @@ typedef struct SStateStore {
   SStreamStateCur* (*streamStateSessionSeekKeyCurrentNext)(SStreamState* pState, const SSessionKey* key);
 
   struct SStreamFileState* (*streamFileStateInit)(int64_t memSize, uint32_t keySize, uint32_t rowSize,
-                                                  uint32_t selectRowSize, GetTsFun fp, void* pFile, TSKEY delMark, const char*id);
+                                                  uint32_t selectRowSize, GetTsFun fp, void* pFile, TSKEY delMark,
+                                                  const char* id, int64_t ckId);
 
   void (*streamFileStateDestroy)(struct SStreamFileState* pFileState);
   void (*streamFileStateClear)(struct SStreamFileState* pFileState);

include/libs/function/functionMgt.h

@@ -122,6 +122,8 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_IROWTS,
   FUNCTION_TYPE_ISFILLED,
   FUNCTION_TYPE_TAGS,
+  FUNCTION_TYPE_TBUID,
+  FUNCTION_TYPE_VGID,
 
   // internal function
   FUNCTION_TYPE_SELECT_VALUE = 3750,
@@ -157,6 +159,8 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_AVG_MERGE,
   FUNCTION_TYPE_STDDEV_PARTIAL,
   FUNCTION_TYPE_STDDEV_MERGE,
+  FUNCTION_TYPE_IRATE_PARTIAL,
+  FUNCTION_TYPE_IRATE_MERGE,
 
   // geometry functions
   FUNCTION_TYPE_GEOM_FROM_TEXT = 4250,
@@ -231,6 +235,7 @@ bool fmIsCumulativeFunc(int32_t funcId);
 bool fmIsInterpPseudoColumnFunc(int32_t funcId);
 bool fmIsGroupKeyFunc(int32_t funcId);
 bool fmIsBlockDistFunc(int32_t funcId);
+bool fmIsConstantResFunc(SFunctionNode* pFunc);
 
 void getLastCacheDataType(SDataType* pType);
 SFunctionNode* createFunction(const char* pName, SNodeList* pParameterList);

include/libs/function/taosudf.h

@@ -109,8 +109,8 @@ typedef uint16_t VarDataLenT;  // maxVarDataLen: 65535
 #define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
 #define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT)(_len))
 #define IS_VAR_DATA_TYPE(t) \
-  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
+  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
-#define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR))
+#define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 static FORCE_INLINE char *udfColDataGetData(const SUdfColumn *pColumn, int32_t row) {
   if (IS_VAR_DATA_TYPE(pColumn->colMeta.type)) {

include/libs/nodes/nodes.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tdef.h"
+#include "tmsg.h"
 
 #define nodeType(nodeptr)              (((const SNode*)(nodeptr))->type)
 #define setNodeType(nodeptr, nodetype) (((SNode*)(nodeptr))->type = (nodetype))
@@ -78,208 +79,6 @@ extern "C" {
     (list) = NULL;             \
   } while (0)
 
-typedef enum ENodeType {
-  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN,
-  // VALUE, OPERATOR, FUNCTION and so on.
-  QUERY_NODE_COLUMN = 1,
-  QUERY_NODE_VALUE,
-  QUERY_NODE_OPERATOR,
-  QUERY_NODE_LOGIC_CONDITION,
-  QUERY_NODE_FUNCTION,
-  QUERY_NODE_REAL_TABLE,
-  QUERY_NODE_TEMP_TABLE,
-  QUERY_NODE_JOIN_TABLE,
-  QUERY_NODE_GROUPING_SET,
-  QUERY_NODE_ORDER_BY_EXPR,
-  QUERY_NODE_LIMIT,
-  QUERY_NODE_STATE_WINDOW,
-  QUERY_NODE_SESSION_WINDOW,
-  QUERY_NODE_INTERVAL_WINDOW,
-  QUERY_NODE_NODE_LIST,
-  QUERY_NODE_FILL,
-  QUERY_NODE_RAW_EXPR,  // Only be used in parser module.
-  QUERY_NODE_TARGET,
-  QUERY_NODE_DATABLOCK_DESC,
-  QUERY_NODE_SLOT_DESC,
-  QUERY_NODE_COLUMN_DEF,
-  QUERY_NODE_DOWNSTREAM_SOURCE,
-  QUERY_NODE_DATABASE_OPTIONS,
-  QUERY_NODE_TABLE_OPTIONS,
-  QUERY_NODE_INDEX_OPTIONS,
-  QUERY_NODE_EXPLAIN_OPTIONS,
-  QUERY_NODE_STREAM_OPTIONS,
-  QUERY_NODE_LEFT_VALUE,
-  QUERY_NODE_COLUMN_REF,
-  QUERY_NODE_WHEN_THEN,
-  QUERY_NODE_CASE_WHEN,
-  QUERY_NODE_EVENT_WINDOW,
-
-  // Statement nodes are used in parser and planner module.
-  QUERY_NODE_SET_OPERATOR = 100,
-  QUERY_NODE_SELECT_STMT,
-  QUERY_NODE_VNODE_MODIFY_STMT,
-  QUERY_NODE_CREATE_DATABASE_STMT,
-  QUERY_NODE_DROP_DATABASE_STMT,
-  QUERY_NODE_ALTER_DATABASE_STMT,
-  QUERY_NODE_FLUSH_DATABASE_STMT,
-  QUERY_NODE_TRIM_DATABASE_STMT,
-  QUERY_NODE_CREATE_TABLE_STMT,
-  QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
-  QUERY_NODE_CREATE_MULTI_TABLES_STMT,
-  QUERY_NODE_DROP_TABLE_CLAUSE,
-  QUERY_NODE_DROP_TABLE_STMT,
-  QUERY_NODE_DROP_SUPER_TABLE_STMT,
-  QUERY_NODE_ALTER_TABLE_STMT,
-  QUERY_NODE_ALTER_SUPER_TABLE_STMT,
-  QUERY_NODE_CREATE_USER_STMT,
-  QUERY_NODE_ALTER_USER_STMT,
-  QUERY_NODE_DROP_USER_STMT,
-  QUERY_NODE_USE_DATABASE_STMT,
-  QUERY_NODE_CREATE_DNODE_STMT,
-  QUERY_NODE_DROP_DNODE_STMT,
-  QUERY_NODE_ALTER_DNODE_STMT,
-  QUERY_NODE_CREATE_INDEX_STMT,
-  QUERY_NODE_DROP_INDEX_STMT,
-  QUERY_NODE_CREATE_QNODE_STMT,
-  QUERY_NODE_DROP_QNODE_STMT,
-  QUERY_NODE_CREATE_BNODE_STMT,
-  QUERY_NODE_DROP_BNODE_STMT,
-  QUERY_NODE_CREATE_SNODE_STMT,
-  QUERY_NODE_DROP_SNODE_STMT,
-  QUERY_NODE_CREATE_MNODE_STMT,
-  QUERY_NODE_DROP_MNODE_STMT,
-  QUERY_NODE_CREATE_TOPIC_STMT,
-  QUERY_NODE_DROP_TOPIC_STMT,
-  QUERY_NODE_DROP_CGROUP_STMT,
-  QUERY_NODE_ALTER_LOCAL_STMT,
-  QUERY_NODE_EXPLAIN_STMT,
-  QUERY_NODE_DESCRIBE_STMT,
-  QUERY_NODE_RESET_QUERY_CACHE_STMT,
-  QUERY_NODE_COMPACT_DATABASE_STMT,
-  QUERY_NODE_CREATE_FUNCTION_STMT,
-  QUERY_NODE_DROP_FUNCTION_STMT,
-  QUERY_NODE_CREATE_STREAM_STMT,
-  QUERY_NODE_DROP_STREAM_STMT,
-  QUERY_NODE_BALANCE_VGROUP_STMT,
-  QUERY_NODE_MERGE_VGROUP_STMT,
-  QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
-  QUERY_NODE_SPLIT_VGROUP_STMT,
-  QUERY_NODE_SYNCDB_STMT,
-  QUERY_NODE_GRANT_STMT,
-  QUERY_NODE_REVOKE_STMT,
-  QUERY_NODE_SHOW_DNODES_STMT,
-  QUERY_NODE_SHOW_MNODES_STMT,
-  QUERY_NODE_SHOW_MODULES_STMT,
-  QUERY_NODE_SHOW_QNODES_STMT,
-  QUERY_NODE_SHOW_SNODES_STMT,
-  QUERY_NODE_SHOW_BNODES_STMT,
-  QUERY_NODE_SHOW_CLUSTER_STMT,
-  QUERY_NODE_SHOW_DATABASES_STMT,
-  QUERY_NODE_SHOW_FUNCTIONS_STMT,
-  QUERY_NODE_SHOW_INDEXES_STMT,
-  QUERY_NODE_SHOW_STABLES_STMT,
-  QUERY_NODE_SHOW_STREAMS_STMT,
-  QUERY_NODE_SHOW_TABLES_STMT,
-  QUERY_NODE_SHOW_TAGS_STMT,
-  QUERY_NODE_SHOW_USERS_STMT,
-  QUERY_NODE_SHOW_LICENCES_STMT,
-  QUERY_NODE_SHOW_VGROUPS_STMT,
-  QUERY_NODE_SHOW_TOPICS_STMT,
-  QUERY_NODE_SHOW_CONSUMERS_STMT,
-  QUERY_NODE_SHOW_CONNECTIONS_STMT,
-  QUERY_NODE_SHOW_QUERIES_STMT,
-  QUERY_NODE_SHOW_APPS_STMT,
-  QUERY_NODE_SHOW_VARIABLES_STMT,
-  QUERY_NODE_SHOW_DNODE_VARIABLES_STMT,
-  QUERY_NODE_SHOW_TRANSACTIONS_STMT,
-  QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT,
-  QUERY_NODE_SHOW_VNODES_STMT,
-  QUERY_NODE_SHOW_USER_PRIVILEGES_STMT,
-  QUERY_NODE_SHOW_CREATE_DATABASE_STMT,
-  QUERY_NODE_SHOW_CREATE_TABLE_STMT,
-  QUERY_NODE_SHOW_CREATE_STABLE_STMT,
-  QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT,
-  QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT,
-  QUERY_NODE_SHOW_SCORES_STMT,
-  QUERY_NODE_SHOW_TABLE_TAGS_STMT,
-  QUERY_NODE_KILL_CONNECTION_STMT,
-  QUERY_NODE_KILL_QUERY_STMT,
-  QUERY_NODE_KILL_TRANSACTION_STMT,
-  QUERY_NODE_DELETE_STMT,
-  QUERY_NODE_INSERT_STMT,
-  QUERY_NODE_QUERY,
-  QUERY_NODE_SHOW_DB_ALIVE_STMT,
-  QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT,
-  QUERY_NODE_BALANCE_VGROUP_LEADER_STMT,
-  QUERY_NODE_RESTORE_DNODE_STMT,
-  QUERY_NODE_RESTORE_QNODE_STMT,
-  QUERY_NODE_RESTORE_MNODE_STMT,
-  QUERY_NODE_RESTORE_VNODE_STMT,
-  QUERY_NODE_PAUSE_STREAM_STMT,
-  QUERY_NODE_RESUME_STREAM_STMT,
-
-  // logic plan node
-  QUERY_NODE_LOGIC_PLAN_SCAN = 1000,
-  QUERY_NODE_LOGIC_PLAN_JOIN,
-  QUERY_NODE_LOGIC_PLAN_AGG,
-  QUERY_NODE_LOGIC_PLAN_PROJECT,
-  QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY,
-  QUERY_NODE_LOGIC_PLAN_EXCHANGE,
-  QUERY_NODE_LOGIC_PLAN_MERGE,
-  QUERY_NODE_LOGIC_PLAN_WINDOW,
-  QUERY_NODE_LOGIC_PLAN_FILL,
-  QUERY_NODE_LOGIC_PLAN_SORT,
-  QUERY_NODE_LOGIC_PLAN_PARTITION,
-  QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC,
-  QUERY_NODE_LOGIC_PLAN_INTERP_FUNC,
-  QUERY_NODE_LOGIC_SUBPLAN,
-  QUERY_NODE_LOGIC_PLAN,
-
-  // physical plan node
-  QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN = 1100,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_PROJECT,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN,
-  QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
-  QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE,
-  QUERY_NODE_PHYSICAL_PLAN_SORT,
-  QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT,
-  QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL,
-  QUERY_NODE_PHYSICAL_PLAN_FILL,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE,
-  QUERY_NODE_PHYSICAL_PLAN_PARTITION,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION,
-  QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC,
-  QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
-  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
-  QUERY_NODE_PHYSICAL_PLAN_INSERT,
-  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
-  QUERY_NODE_PHYSICAL_PLAN_DELETE,
-  QUERY_NODE_PHYSICAL_SUBPLAN,
-  QUERY_NODE_PHYSICAL_PLAN,
-  QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN,
-  QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT,
-  QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT
-} ENodeType;
-
 /**
  * The first field of a node of any type is guaranteed to be the ENodeType.
  * Hence the type of any node can be gotten by casting it to SNode.

include/libs/nodes/plannodes.h

@@ -42,10 +42,13 @@ typedef enum EGroupAction {
 
 typedef struct SLogicNode {
   ENodeType          type;
+  bool               dynamicOp;
+  bool               stmtRoot;
   SNodeList*         pTargets;  // SColumnNode
   SNode*             pConditions;
   SNodeList*         pChildren;
   struct SLogicNode* pParent;
+  SNodeList*         pHint;
   int32_t            optimizedFlag;
   uint8_t            precision;
   SNode*             pLimit;
@@ -107,15 +110,21 @@ typedef struct SScanLogicNode {
   bool          sortPrimaryKey;
   bool          igLastNull;
   bool          groupOrderScan;
+  bool          onlyMetaCtbIdx; // for tag scan with no tbname
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
-  SLogicNode node;
+  SLogicNode     node;
-  EJoinType  joinType;
+  EJoinType      joinType;
-  SNode*     pMergeCondition;
+  EJoinAlgorithm joinAlgo;
-  SNode*     pOnConditions;
+  SNode*         pPrimKeyEqCond;
-  bool       isSingleTableJoin;
+  SNode*         pColEqCond;
-  SNode*     pColEqualOnConditions;
+  SNode*         pTagEqCond;
+  SNode*         pTagOnCond;
+  SNode*         pOtherOnCond;
+  bool           isSingleTableJoin;
+  bool           hasSubQuery;
+  bool           isLowLevelJoin;
 } SJoinLogicNode;
 
 typedef struct SAggLogicNode {
@@ -154,6 +163,28 @@ typedef struct SInterpFuncLogicNode {
   SNode*      pTimeSeries;  // SColumnNode
 } SInterpFuncLogicNode;
 
+typedef struct SGroupCacheLogicNode {
+  SLogicNode  node;
+  bool        grpColsMayBeNull;  
+  bool        grpByUid;
+  bool        globalGrp;
+  bool        batchFetch;
+  SNodeList*  pGroupCols;
+} SGroupCacheLogicNode;
+
+typedef struct SDynQueryCtrlStbJoin {
+  bool          batchFetch;
+  SNodeList*    pVgList;
+  SNodeList*    pUidList;
+  bool          srcScan[2];
+} SDynQueryCtrlStbJoin;
+
+typedef struct SDynQueryCtrlLogicNode {
+  SLogicNode           node;
+  EDynQueryType        qType;
+  SDynQueryCtrlStbJoin stbJoin;
+} SDynQueryCtrlLogicNode;
+
 typedef enum EModifyTableType { MODIFY_TABLE_TYPE_INSERT = 1, MODIFY_TABLE_TYPE_DELETE } EModifyTableType;
 
 typedef struct SVnodeModifyLogicNode {
@@ -312,6 +343,7 @@ typedef struct SDataBlockDescNode {
 
 typedef struct SPhysiNode {
   ENodeType           type;
+  bool                dynamicOp;
   EOrder              inputTsOrder;
   EOrder              outputTsOrder;
   SDataBlockDescNode* pOutputDataBlockDesc;
@@ -334,7 +366,11 @@ typedef struct SScanPhysiNode {
   bool       groupOrderScan;
 } SScanPhysiNode;
 
-typedef SScanPhysiNode STagScanPhysiNode;
+typedef struct STagScanPhysiNode {
+  SScanPhysiNode scan;
+  bool       onlyMetaCtbIdx; //no tbname, tag index not used.
+} STagScanPhysiNode;
+
 typedef SScanPhysiNode SBlockDistScanPhysiNode;
 
 typedef struct SLastRowScanPhysiNode {
@@ -409,12 +445,50 @@ typedef struct SInterpFuncPhysiNode {
 typedef struct SSortMergeJoinPhysiNode {
   SPhysiNode node;
   EJoinType  joinType;
-  SNode*     pMergeCondition;
+  SNode*     pPrimKeyCond;
-  SNode*     pOnConditions;
+  SNode*     pColEqCond;
+  SNode*     pOtherOnCond;
   SNodeList* pTargets;
-  SNode*     pColEqualOnConditions;
 } SSortMergeJoinPhysiNode;
 
+typedef struct SHashJoinPhysiNode {
+  SPhysiNode node;
+  EJoinType  joinType;
+  SNodeList* pOnLeft;
+  SNodeList* pOnRight;
+  SNode*     pFilterConditions;
+  SNodeList* pTargets;
+  SQueryStat inputStat[2];
+
+  SNode*     pPrimKeyCond;
+  SNode*     pColEqCond;
+  SNode*     pTagEqCond;  
+} SHashJoinPhysiNode;
+
+typedef struct SGroupCachePhysiNode {
+  SPhysiNode node;
+  bool       grpColsMayBeNull;
+  bool       grpByUid;
+  bool       globalGrp;
+  bool       batchFetch;
+  SNodeList* pGroupCols;
+} SGroupCachePhysiNode;
+
+typedef struct SStbJoinDynCtrlBasic {
+  bool     batchFetch;
+  int32_t  vgSlot[2];
+  int32_t  uidSlot[2];
+  bool     srcScan[2];
+} SStbJoinDynCtrlBasic;
+
+typedef struct SDynQueryCtrlPhysiNode {
+  SPhysiNode    node;
+  EDynQueryType qType;
+  union {
+    SStbJoinDynCtrlBasic stbJoin;
+  };
+} SDynQueryCtrlPhysiNode;
+
 typedef struct SAggPhysiNode {
   SPhysiNode node;
   SNodeList* pExprs;  // these are expression list of group_by_clause and parameter expression of aggregate function
@@ -603,6 +677,8 @@ typedef struct SSubplan {
   SNode*         pTagCond;
   SNode*         pTagIndexCond;
   bool           showRewrite;
+  int32_t        rowsThreshold;
+  bool           dynamicRowThreshold;
 } SSubplan;
 
 typedef enum EExplainMode { EXPLAIN_MODE_DISABLE = 1, EXPLAIN_MODE_STATIC, EXPLAIN_MODE_ANALYZE } EExplainMode;

include/libs/nodes/querynodes.h

@@ -116,6 +116,17 @@ typedef struct SLeftValueNode {
   ENodeType type;
 } SLeftValueNode;
 
+typedef enum EHintOption {
+  HINT_NO_BATCH_SCAN = 1,
+  HINT_BATCH_SCAN,
+} EHintOption;
+
+typedef struct SHintNode {
+  ENodeType   type;
+  EHintOption option;
+  void*       value;
+} SHintNode;
+
 typedef struct SOperatorNode {
   SExprNode     node;  // QUERY_NODE_OPERATOR
   EOperatorType opType;
@@ -169,11 +180,27 @@ typedef struct STempTableNode {
   SNode*     pSubquery;
 } STempTableNode;
 
-typedef enum EJoinType { JOIN_TYPE_INNER = 1 } EJoinType;
+typedef enum EJoinType { 
+  JOIN_TYPE_INNER = 1,
+  JOIN_TYPE_LEFT,
+  JOIN_TYPE_RIGHT,
+} EJoinType;
+
+typedef enum EJoinAlgorithm { 
+  JOIN_ALGO_UNKNOWN = 0,
+  JOIN_ALGO_MERGE,
+  JOIN_ALGO_HASH,
+} EJoinAlgorithm;
+
+typedef enum EDynQueryType {
+  DYN_QTYPE_STB_HASH = 1,
+} EDynQueryType;
 
 typedef struct SJoinTableNode {
   STableNode table;  // QUERY_NODE_JOIN_TABLE
   EJoinType  joinType;
+  bool       hasSubQuery;
+  bool       isLowLevelJoin;
   SNode*     pLeft;
   SNode*     pRight;
   SNode*     pOnCond;
@@ -289,6 +316,7 @@ typedef struct SSelectStmt {
   SLimitNode*   pLimit;
   SLimitNode*   pSlimit;
   STimeWindow   timeRange;
+  SNodeList*    pHint;
   char          stmtName[TSDB_TABLE_NAME_LEN];
   uint8_t       precision;
   int32_t       selectFuncNum;
@@ -470,7 +498,7 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
 int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols);
 
 typedef bool (*FFuncClassifier)(int32_t funcId);
-int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs);
+int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
 
 int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes);
 

include/libs/parser/parser.h

@@ -114,6 +114,7 @@ int32_t        smlBuildRow(STableDataCxt* pTableCxt);
 int32_t        smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* kv, int32_t index);
 STableDataCxt* smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta);
 
+void    clearColValArraySml(SArray* pCols);
 int32_t smlBindData(SQuery* handle, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,
                     STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl,
                     char* msgBuf, int32_t msgBufLen);

include/libs/qcom/query.h

@@ -90,11 +90,6 @@ typedef struct SExecResult {
   void*    res;
 } SExecResult;
 
-typedef struct STbVerInfo {
-  char    tbFName[TSDB_TABLE_FNAME_LEN];
-  int32_t sversion;
-  int32_t tversion;
-} STbVerInfo;
 
 #pragma pack(push, 1) 
 typedef struct SCTableMeta {
@@ -212,6 +207,11 @@ typedef struct SQueryNodeStat {
   int32_t tableNum;  // vg table number, unit is TSDB_TABLE_NUM_UNIT
 } SQueryNodeStat;
 
+typedef struct SQueryStat {
+  int64_t inputRowNum;
+  int32_t inputRowSize;
+} SQueryStat;
+
 int32_t initTaskQueue();
 int32_t cleanupTaskQueue();
 

include/libs/qworker/qworker.h

@@ -45,6 +45,7 @@ typedef struct {
   uint64_t cqueryProcessed;
   uint64_t fetchProcessed;
   uint64_t dropProcessed;
+  uint64_t notifyProcessed;
   uint64_t hbProcessed;
   uint64_t deleteProcessed;
 
@@ -90,6 +91,8 @@ int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in
 
 int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
 
+int32_t qWorkerProcessNotifyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
+
 int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
 
 int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SDeleteRes *pRes);

include/libs/scalar/scalar.h

@@ -95,6 +95,8 @@ int32_t qStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
 int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qTbUidFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qVgIdFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 /* Aggregation functions */
 int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);

include/libs/stream/streamSnapshot.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _STREAM_BACKEDN_SNAPSHOT_H_
+#define _STREAM_BACKEDN_SNAPSHOT_H_
+#include "tcommon.h"
+
+#define STREAM_STATE_TRANSFER "stream-state-transfer"
+
+typedef struct SStreamSnapReader SStreamSnapReader;
+typedef struct SStreamSnapWriter SStreamSnapWriter;
+
+typedef struct SStreamSnapHandle   SStreamSnapHandle;
+typedef struct SStreamSnapBlockHdr SStreamSnapBlockHdr;
+
+int32_t streamSnapReaderOpen(void* pMeta, int64_t sver, int64_t ever, char* path, SStreamSnapReader** ppReader);
+int32_t streamSnapReaderClose(SStreamSnapReader* pReader);
+int32_t streamSnapRead(SStreamSnapReader* pReader, uint8_t** ppData, int64_t* size);
+
+// SMetaSnapWriter ========================================
+int32_t streamSnapWriterOpen(void* pMeta, int64_t sver, int64_t ever, char* path, SStreamSnapWriter** ppWriter);
+int32_t streamSnapWrite(SStreamSnapWriter* pWriter, uint8_t* pData, uint32_t nData);
+int32_t streamSnapWriterClose(SStreamSnapWriter* ppWriter, int8_t rollback);
+
+#endif

include/libs/stream/tstream.h

@@ -20,6 +20,7 @@
 #include "tmsg.h"
 #include "tmsgcb.h"
 #include "tqueue.h"
+#include "ttimer.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,7 +31,7 @@ extern "C" {
 
 typedef struct SStreamTask SStreamTask;
 
-#define SSTREAM_TASK_VER 1
+#define SSTREAM_TASK_VER 2
 enum {
   STREAM_STATUS__NORMAL = 0,
   STREAM_STATUS__STOP,
@@ -48,6 +49,7 @@ enum {
   TASK_STATUS__SCAN_HISTORY,  // stream task scan history data by using tsdbread in the stream scanner
   TASK_STATUS__HALT,          // pause, but not be manipulated by user command
   TASK_STATUS__PAUSE,         // pause
+  TASK_STATUS__CK,            // stream task is in checkpoint status, no data are allowed to put into inputQ anymore
 };
 
 enum {
@@ -61,15 +63,12 @@ enum {
 enum {
   TASK_INPUT_STATUS__NORMAL = 1,
   TASK_INPUT_STATUS__BLOCKED,
-  TASK_INPUT_STATUS__RECOVER,
-  TASK_INPUT_STATUS__STOP,
   TASK_INPUT_STATUS__FAILED,
 };
 
 enum {
   TASK_OUTPUT_STATUS__NORMAL = 1,
   TASK_OUTPUT_STATUS__WAIT,
-  TASK_OUTPUT_STATUS__BLOCKED,
 };
 
 enum {
@@ -97,11 +96,16 @@ enum {
   STREAM_QUEUE__PROCESSING,
 };
 
+enum {
+  STREAM_META_WILL_STOP = 1,
+  STREAM_META_OK_TO_STOP = 2,
+};
+
 typedef struct {
   int8_t type;
 } SStreamQueueItem;
 
-typedef void    FTbSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data);
+typedef void    FTbSink(SStreamTask* pTask, void* vnode, void* data);
 typedef int32_t FTaskExpand(void* ahandle, SStreamTask* pTask, int64_t ver);
 
 typedef struct {
@@ -119,14 +123,13 @@ typedef struct {
 } SStreamMergedSubmit;
 
 typedef struct {
-  int8_t type;
+  int8_t  type;
-
+  int64_t nodeId;  // nodeId, from SStreamMeta
   int32_t srcVgId;
   int32_t srcTaskId;
   int32_t childId;
   int64_t sourceVer;
   int64_t reqId;
-
   SArray* blocks;  // SArray<SSDataBlock>
 } SStreamDataBlock;
 
@@ -136,10 +139,6 @@ typedef struct {
   SSDataBlock* pBlock;
 } SStreamRefDataBlock;
 
-typedef struct {
-  int8_t type;
-} SStreamCheckpoint;
-
 typedef struct {
   int8_t       type;
   SSDataBlock* pBlock;
@@ -179,7 +178,7 @@ SStreamQueueRes streamQueueGetRes(SStreamQueue1* pQueue);
 #endif
 
 typedef struct {
-  STaosQueue* queue;
+  STaosQueue* pQueue;
   STaosQall*  qall;
   void*       qItem;
   int8_t      status;
@@ -190,19 +189,9 @@ void    streamCleanUp();
 
 SStreamQueue* streamQueueOpen(int64_t cap);
 void          streamQueueClose(SStreamQueue* pQueue, int32_t taskId);
-
+void          streamQueueProcessSuccess(SStreamQueue* queue);
-static FORCE_INLINE void streamQueueProcessSuccess(SStreamQueue* queue) {
+void          streamQueueProcessFail(SStreamQueue* queue);
-  ASSERT(atomic_load_8(&queue->status) == STREAM_QUEUE__PROCESSING);
+void*         streamQueueNextItem(SStreamQueue* pQueue);
-  queue->qItem = NULL;
-  atomic_store_8(&queue->status, STREAM_QUEUE__SUCESS);
-}
-
-static FORCE_INLINE void streamQueueProcessFail(SStreamQueue* queue) {
-  ASSERT(atomic_load_8(&queue->status) == STREAM_QUEUE__PROCESSING);
-  atomic_store_8(&queue->status, STREAM_QUEUE__FAILED);
-}
-
-void* streamQueueNextItem(SStreamQueue* pQueue);
 
 SStreamDataSubmit* streamDataSubmitNew(SPackedData* pData, int32_t type);
 void               streamDataSubmitDestroy(SStreamDataSubmit* pDataSubmit);
@@ -252,20 +241,26 @@ typedef struct SStreamChildEpInfo {
   int32_t nodeId;
   int32_t childId;
   int32_t taskId;
-  int8_t  dataAllowed;
   SEpSet  epSet;
+  bool    dataAllowed;  // denote if the data from this upstream task is allowed to put into inputQ, not serialize it
+  int64_t stage;  // upstream task stage value, to denote if the upstream node has restart/replica changed/transfer
 } SStreamChildEpInfo;
 
-typedef struct SStreamId {
+typedef struct SStreamTaskKey {
+  int64_t streamId;
+  int32_t taskId;
+} SStreamTaskKey;
+
+typedef struct SStreamTaskId {
   int64_t     streamId;
   int32_t     taskId;
   const char* idStr;
-} SStreamId;
+} SStreamTaskId;
 
 typedef struct SCheckpointInfo {
-  int64_t id;
+  int64_t checkpointId;
-  int64_t version;     // offset in WAL
+  int64_t checkpointVer;  // latest checkpointId version
-  int64_t currentVer;  // current offset in WAL, not serialize it
+  int64_t currentVer;     // current offset in WAL, not serialize it
 } SCheckpointInfo;
 
 typedef struct SStreamStatus {
@@ -273,24 +268,25 @@ typedef struct SStreamStatus {
   int8_t downstreamReady;  // downstream tasks are all ready now, if this flag is set
   int8_t schedStatus;
   int8_t keepTaskStatus;
-  bool   transferState;
   bool   appendTranstateBlock;  // has append the transfer state data block already, todo: remove it
-  int8_t timerActive;   // timer is active
+  int8_t timerActive;           // timer is active
-  int8_t pauseAllowed;  // allowed task status to be set to be paused
+  int8_t pauseAllowed;          // allowed task status to be set to be paused
 } SStreamStatus;
 
-typedef struct SHistDataRange {
+typedef struct SDataRange {
   SVersionRange range;
   STimeWindow   window;
-} SHistDataRange;
+} SDataRange;
 
 typedef struct SSTaskBasicInfo {
   int32_t nodeId;  // vgroup id or snode id
   SEpSet  epSet;
+  SEpSet  mnodeEpset;  // mnode epset for send heartbeat
   int32_t selfChildId;
   int32_t totalLevel;
   int8_t  taskLevel;
   int8_t  fillHistory;  // is fill history task or not
+  int64_t triggerParam; // in msec
 } SSTaskBasicInfo;
 
 typedef struct SDispatchMsgInfo {
@@ -300,12 +296,22 @@ typedef struct SDispatchMsgInfo {
   int64_t blockingTs;  // output blocking timestamp
 } SDispatchMsgInfo;
 
-typedef struct {
+typedef struct STaskOutputInfo {
   int8_t        type;
   int8_t        status;
   SStreamQueue* queue;
 } STaskOutputInfo;
 
+typedef struct STaskInputInfo {
+  int8_t status;
+  SStreamQueue* queue;
+} STaskInputInfo;
+
+typedef struct STaskSchedInfo {
+  int8_t  status;
+  void*   pTimer;
+} STaskSchedInfo;
+
 typedef struct {
   int64_t init;
   int64_t step1Start;
@@ -314,20 +320,23 @@ typedef struct {
 
 struct SStreamTask {
   int64_t          ver;
-  SStreamId        id;
+  SStreamTaskId    id;
   SSTaskBasicInfo  info;
   STaskOutputInfo  outputInfo;
+  STaskInputInfo   inputInfo;
+  STaskSchedInfo   schedInfo;
   SDispatchMsgInfo msgInfo;
   SStreamStatus    status;
   SCheckpointInfo  chkInfo;
   STaskExec        exec;
-  SHistDataRange   dataRange;
+  SDataRange       dataRange;
-  SStreamId        historyTaskId;
+  SStreamTaskId    historyTaskId;
-  SStreamId        streamTaskId;
+  SStreamTaskId    streamTaskId;
-  SArray*          pUpstreamEpInfoList;  // SArray<SStreamChildEpInfo*>, // children info
-  int32_t          nextCheckId;
-  SArray*          checkpointInfo;  // SArray<SStreamCheckpointInfo>
   STaskTimestamp   tsInfo;
+  SArray*          pReadyMsgList;  // SArray<SStreamChkptReadyInfo*>
+  TdThreadMutex    lock;           // secure the operation of set task status and puting data into inputQ
+  SArray*          pUpstreamInfoList;
+
   // output
   union {
     STaskDispatcherFixedEp fixedEpDispatcher;
@@ -337,18 +346,10 @@ struct SStreamTask {
     STaskSinkFetch         fetchSink;
   };
 
-  int8_t        inputStatus;
-  SStreamQueue* inputQueue;
-
-  // trigger
-  int8_t        triggerStatus;
-  int64_t       triggerParam;
-  void*         schedTimer;
   void*         launchTaskTimer;
   SMsgCb*       pMsgCb;  // msg handle
   SStreamState* pState;  // state backend
   SArray*       pRspMsgList;
-  TdThreadMutex lock;
 
   // the followings attributes don't be serialized
   int32_t             notReadyTasks;
@@ -358,11 +359,19 @@ struct SStreamTask {
   int32_t             refCnt;
   int64_t             checkpointingId;
   int32_t             checkpointAlignCnt;
+  int32_t             checkpointNotReadyTasks;
   int32_t             transferStateAlignCnt;
   struct SStreamMeta* pMeta;
   SSHashObj*          pNameMap;
+  char                reserve[256];
 };
 
+typedef struct SMetaHbInfo {
+  tmr_h   hbTmr;
+  int32_t stopFlag;
+  int32_t tickCounter;
+} SMetaHbInfo;
+
 // meta
 typedef struct SStreamMeta {
   char*         path;
@@ -375,12 +384,25 @@ typedef struct SStreamMeta {
   TXN*          txn;
   FTaskExpand*  expandFunc;
   int32_t       vgId;
+  int64_t       stage;
   SRWLatch      lock;
   int32_t       walScanCounter;
   void*         streamBackend;
   int64_t       streamBackendRid;
   SHashObj*     pTaskBackendUnique;
   TdThreadMutex backendMutex;
+  SMetaHbInfo   hbInfo;
+  int32_t       closedTask;
+  int32_t       totalTasks;  // this value should be increased when a new task is added into the meta
+  int32_t       chkptNotReadyTasks;
+  int64_t       rid;
+
+  int64_t  chkpId;
+  SArray*  chkpSaved;
+  SArray*  chkpInUse;
+  int32_t  chkpCap;
+  SRWLatch chkpDirLock;
+  int32_t  pauseTaskNum;
 } SStreamMeta;
 
 int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo);
@@ -391,8 +413,14 @@ SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, int8_t fillHisto
 int32_t      tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask);
 int32_t      tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask);
 void         tFreeStreamTask(SStreamTask* pTask);
-int32_t      tAppendDataToInputQueue(SStreamTask* pTask, SStreamQueueItem* pItem);
+int32_t      streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, int64_t ver);
-bool         tInputQueueIsFull(const SStreamTask* pTask);
+
+int32_t tDecodeStreamTaskChkInfo(SDecoder* pDecoder, SCheckpointInfo* pChkpInfo);
+int32_t tDecodeStreamTaskId(SDecoder* pDecoder, SStreamTaskId* pTaskId);
+
+int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem);
+int32_t streamTaskPutTranstateIntoInputQ(SStreamTask* pTask);
+bool    streamQueueIsFull(const STaosQueue* pQueue);
 
 typedef struct {
   SMsgHead head;
@@ -401,8 +429,9 @@ typedef struct {
 } SStreamTaskRunReq;
 
 typedef struct {
-  int64_t streamId;
   int32_t type;
+  int64_t stage;  // nodeId from upstream task
+  int64_t streamId;
   int32_t taskId;
   int32_t srcVgId;
   int32_t upstreamTaskId;
@@ -443,6 +472,7 @@ typedef struct {
 
 typedef struct {
   int64_t reqId;
+  int64_t stage;
   int64_t streamId;
   int32_t upstreamNodeId;
   int32_t upstreamTaskId;
@@ -459,6 +489,7 @@ typedef struct {
   int32_t downstreamNodeId;
   int32_t downstreamTaskId;
   int32_t childId;
+  int32_t oldStage;
   int8_t  status;
 } SStreamTaskCheckRsp;
 
@@ -485,6 +516,8 @@ typedef struct {
   int64_t checkpointId;
   int32_t taskId;
   int32_t nodeId;
+  SEpSet  mgmtEps;
+  int32_t mnodeId;
   int64_t expireTime;
 } SStreamCheckpointSourceReq;
 
@@ -493,14 +526,16 @@ typedef struct {
   int64_t checkpointId;
   int32_t taskId;
   int32_t nodeId;
+  int32_t mnodeId;
   int64_t expireTime;
+  int8_t  success;
 } SStreamCheckpointSourceRsp;
 
-int32_t tEncodeSStreamCheckpointSourceReq(SEncoder* pEncoder, const SStreamCheckpointSourceReq* pReq);
+int32_t tEncodeStreamCheckpointSourceReq(SEncoder* pEncoder, const SStreamCheckpointSourceReq* pReq);
-int32_t tDecodeSStreamCheckpointSourceReq(SDecoder* pDecoder, SStreamCheckpointSourceReq* pReq);
+int32_t tDecodeStreamCheckpointSourceReq(SDecoder* pDecoder, SStreamCheckpointSourceReq* pReq);
 
-int32_t tEncodeSStreamCheckpointSourceRsp(SEncoder* pEncoder, const SStreamCheckpointSourceRsp* pRsp);
+int32_t tEncodeStreamCheckpointSourceRsp(SEncoder* pEncoder, const SStreamCheckpointSourceRsp* pRsp);
-int32_t tDecodeSStreamCheckpointSourceRsp(SDecoder* pDecoder, SStreamCheckpointSourceRsp* pRsp);
+int32_t tDecodeStreamCheckpointSourceRsp(SDecoder* pDecoder, SStreamCheckpointSourceRsp* pRsp);
 
 typedef struct {
   SMsgHead msgHead;
@@ -511,28 +546,25 @@ typedef struct {
   int32_t  upstreamTaskId;
   int32_t  upstreamNodeId;
   int32_t  childId;
-  int64_t  expireTime;
+} SStreamCheckpointReadyMsg;
-  int8_t   taskLevel;
-} SStreamCheckpointReq;
 
-typedef struct {
+int32_t tEncodeStreamCheckpointReadyMsg(SEncoder* pEncoder, const SStreamCheckpointReadyMsg* pRsp);
-  SMsgHead msgHead;
+int32_t tDecodeStreamCheckpointReadyMsg(SDecoder* pDecoder, SStreamCheckpointReadyMsg* pRsp);
-  int64_t  streamId;
-  int64_t  checkpointId;
-  int32_t  downstreamTaskId;
-  int32_t  downstreamNodeId;
-  int32_t  upstreamTaskId;
-  int32_t  upstreamNodeId;
-  int32_t  childId;
-  int64_t  expireTime;
-  int8_t   taskLevel;
-} SStreamCheckpointRsp;
 
-int32_t tEncodeSStreamCheckpointReq(SEncoder* pEncoder, const SStreamCheckpointReq* pReq);
+typedef struct STaskStatusEntry {
-int32_t tDecodeSStreamCheckpointReq(SDecoder* pDecoder, SStreamCheckpointReq* pReq);
+  int64_t streamId;
+  int32_t taskId;
+  int32_t status;
+} STaskStatusEntry;
 
-int32_t tEncodeSStreamCheckpointRsp(SEncoder* pEncoder, const SStreamCheckpointRsp* pRsp);
+typedef struct SStreamHbMsg {
-int32_t tDecodeSStreamCheckpointRsp(SDecoder* pDecoder, SStreamCheckpointRsp* pRsp);
+  int32_t vgId;
+  int32_t numOfTasks;
+  SArray* pTaskStatus;  // SArray<SStreamTaskStatusEntry>
+} SStreamHbMsg;
+
+int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pRsp);
+int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pRsp);
 
 typedef struct {
   int64_t streamId;
@@ -545,6 +577,21 @@ typedef struct {
 int32_t tEncodeCompleteHistoryDataMsg(SEncoder* pEncoder, const SStreamCompleteHistoryMsg* pReq);
 int32_t tDecodeCompleteHistoryDataMsg(SDecoder* pDecoder, SStreamCompleteHistoryMsg* pReq);
 
+typedef struct SNodeUpdateInfo {
+  int32_t nodeId;
+  SEpSet  prevEp;
+  SEpSet  newEp;
+} SNodeUpdateInfo;
+
+typedef struct SStreamTaskNodeUpdateMsg {
+  int64_t streamId;
+  int32_t taskId;
+  SArray* pNodeList;  // SArray<SNodeUpdateInfo>
+} SStreamTaskNodeUpdateMsg;
+
+int32_t tEncodeStreamTaskUpdateMsg(SEncoder* pEncoder, const SStreamTaskNodeUpdateMsg* pMsg);
+int32_t tDecodeStreamTaskUpdateMsg(SDecoder* pDecoder, SStreamTaskNodeUpdateMsg* pMsg);
+
 typedef struct {
   int64_t streamId;
   int32_t downstreamTaskId;
@@ -564,16 +611,11 @@ int32_t tDecodeStreamTaskCheckReq(SDecoder* pDecoder, SStreamTaskCheckReq* pReq)
 int32_t tEncodeStreamTaskCheckRsp(SEncoder* pEncoder, const SStreamTaskCheckRsp* pRsp);
 int32_t tDecodeStreamTaskCheckRsp(SDecoder* pDecoder, SStreamTaskCheckRsp* pRsp);
 
-int32_t tEncodeSStreamTaskScanHistoryReq(SEncoder* pEncoder, const SStreamRecoverDownstreamReq* pReq);
+int32_t tEncodeStreamDispatchReq(SEncoder* pEncoder, const SStreamDispatchReq* pReq);
-int32_t tDecodeSStreamTaskScanHistoryReq(SDecoder* pDecoder, SStreamRecoverDownstreamReq* pReq);
-
-int32_t tEncodeSStreamTaskRecoverRsp(SEncoder* pEncoder, const SStreamRecoverDownstreamRsp* pRsp);
-int32_t tDecodeSStreamTaskRecoverRsp(SDecoder* pDecoder, SStreamRecoverDownstreamRsp* pRsp);
-
 int32_t tDecodeStreamDispatchReq(SDecoder* pDecoder, SStreamDispatchReq* pReq);
+
 int32_t tDecodeStreamRetrieveReq(SDecoder* pDecoder, SStreamRetrieveReq* pReq);
 void    tDeleteStreamRetrieveReq(SStreamRetrieveReq* pReq);
-
 void    tDeleteStreamDispatchReq(SStreamDispatchReq* pReq);
 
 int32_t streamSetupScheduleTrigger(SStreamTask* pTask);
@@ -581,10 +623,9 @@ int32_t streamSetupScheduleTrigger(SStreamTask* pTask);
 int32_t streamProcessRunReq(SStreamTask* pTask);
 int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pMsg, bool exec);
 int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code);
-void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId);
-void streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 
-int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pMsg);
+int32_t             streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, SRpcMsg* pMsg);
+SStreamChildEpInfo* streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId);
 
 void    streamTaskInputFail(SStreamTask* pTask);
 int32_t streamTryExec(SStreamTask* pTask);
@@ -594,16 +635,19 @@ bool    streamTaskShouldStop(const SStreamStatus* pStatus);
 bool    streamTaskShouldPause(const SStreamStatus* pStatus);
 bool    streamTaskIsIdle(const SStreamTask* pTask);
 
-SStreamChildEpInfo* streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId);
+int32_t streamScanExec(SStreamTask* pTask, int32_t batchSize);
-int32_t             streamScanExec(SStreamTask* pTask, int32_t batchSize);
+void    initRpcMsg(SRpcMsg* pMsg, int32_t msgType, void* pCont, int32_t contLen);
 
 char* createStreamTaskIdStr(int64_t streamId, int32_t taskId);
 
 // recover and fill history
-void    streamTaskCheckDownstreamTasks(SStreamTask* pTask);
+void    streamTaskCheckDownstream(SStreamTask* pTask);
-int32_t streamTaskDoCheckDownstreamTasks(SStreamTask* pTask);
 int32_t streamTaskLaunchScanHistory(SStreamTask* pTask);
-int32_t streamTaskCheckStatus(SStreamTask* pTask);
+int32_t streamTaskCheckStatus(SStreamTask* pTask, int32_t upstreamTaskId, int32_t vgId, int64_t stage);
+int32_t streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList);
+void    streamTaskResetUpstreamStageInfo(SStreamTask* pTask);
+
+int32_t streamTaskStop(SStreamTask* pTask);
 int32_t streamSendCheckRsp(const SStreamMeta* pMeta, const SStreamTaskCheckReq* pReq, SStreamTaskCheckRsp* pRsp,
                            SRpcHandleInfo* pRpcInfo, int32_t taskId);
 int32_t streamProcessCheckRsp(SStreamTask* pTask, const SStreamTaskCheckRsp* pRsp);
@@ -611,17 +655,26 @@ int32_t streamLaunchFillHistoryTask(SStreamTask* pTask);
 int32_t streamTaskScanHistoryDataComplete(SStreamTask* pTask);
 int32_t streamStartScanHistoryAsync(SStreamTask* pTask, int8_t igUntreated);
 bool    streamHistoryTaskSetVerRangeStep2(SStreamTask* pTask, int64_t latestVer);
+int32_t streamTaskGetInputQItems(const SStreamTask* pTask);
 
 // common
 int32_t     streamRestoreParam(SStreamTask* pTask);
 int32_t     streamSetStatusNormal(SStreamTask* pTask);
 const char* streamGetTaskStatusStr(int32_t status);
-void        streamTaskPause(SStreamTask* pTask);
+void        streamTaskPause(SStreamTask* pTask, SStreamMeta* pMeta);
-void        streamTaskResume(SStreamTask* pTask);
+void        streamTaskResume(SStreamTask* pTask, SStreamMeta* pMeta);
 void        streamTaskHalt(SStreamTask* pTask);
 void        streamTaskResumeFromHalt(SStreamTask* pTask);
 void        streamTaskDisablePause(SStreamTask* pTask);
 void        streamTaskEnablePause(SStreamTask* pTask);
+int32_t     streamTaskSetUpstreamInfo(SStreamTask* pTask, const SStreamTask* pUpstreamTask);
+void        streamTaskUpdateUpstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpSet* pEpSet);
+void        streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpSet* pEpSet);
+void        streamTaskSetFixedDownstreamInfo(SStreamTask* pTask, const SStreamTask* pDownstreamTask);
+int32_t     streamTaskReleaseState(SStreamTask* pTask);
+int32_t     streamTaskReloadState(SStreamTask* pTask);
+void        streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId);
+void        streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 
 // source level
 int32_t streamSetParamForStreamScannerStep1(SStreamTask* pTask, SVersionRange* pVerRange, STimeWindow* pWindow);
@@ -629,8 +682,6 @@ int32_t streamSetParamForStreamScannerStep2(SStreamTask* pTask, SVersionRange* p
 int32_t streamSourceScanHistoryData(SStreamTask* pTask);
 int32_t streamDispatchScanHistoryFinishMsg(SStreamTask* pTask);
 
-int32_t appendTranstateIntoInputQ(SStreamTask* pTask);
-
 // agg level
 int32_t streamTaskScanHistoryPrepare(SStreamTask* pTask);
 int32_t streamProcessScanHistoryFinishReq(SStreamTask* pTask, SStreamScanHistoryFinishReq* pReq,
@@ -640,31 +691,32 @@ int32_t streamProcessScanHistoryFinishRsp(SStreamTask* pTask);
 // stream task meta
 void         streamMetaInit();
 void         streamMetaCleanup();
-SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId);
+SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId, int64_t stage);
 void         streamMetaClose(SStreamMeta* streamMeta);
-
+int32_t      streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask);  // save to stream meta store
-// save to b-tree meta store
+int32_t      streamMetaRemoveTask(SStreamMeta* pMeta, int64_t* pKey);
-int32_t      streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask);
-int32_t      streamMetaRemoveTask(SStreamMeta* pMeta, int32_t taskId);
 int32_t      streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTask, bool* pAdded);
 int32_t      streamMetaUnregisterTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId);
-int32_t      streamMetaGetNumOfTasks(SStreamMeta* pMeta);  // todo remove it
+int32_t      streamMetaGetNumOfTasks(SStreamMeta* pMeta);
+int32_t      streamMetaGetNumOfStreamTasks(SStreamMeta* pMeta);
 SStreamTask* streamMetaAcquireTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId);
 void         streamMetaReleaseTask(SStreamMeta* pMeta, SStreamTask* pTask);
-
+int32_t      streamMetaReopen(SStreamMeta* pMeta, int64_t chkpId);
-int32_t streamMetaBegin(SStreamMeta* pMeta);
+int32_t      streamMetaCommit(SStreamMeta* pMeta);
-int32_t streamMetaCommit(SStreamMeta* pMeta);
+int32_t      streamMetaLoadAllTasks(SStreamMeta* pMeta);
-int32_t streamLoadTasks(SStreamMeta* pMeta, int64_t ver);
+void         streamMetaNotifyClose(SStreamMeta* pMeta);
 
 // checkpoint
-int32_t streamProcessCheckpointSourceReq(SStreamMeta* pMeta, SStreamTask* pTask, SStreamCheckpointSourceReq* pReq);
+int32_t streamProcessCheckpointSourceReq(SStreamTask* pTask, SStreamCheckpointSourceReq* pReq);
-int32_t streamProcessCheckpointReq(SStreamMeta* pMeta, SStreamTask* pTask, SStreamCheckpointReq* pReq);
+int32_t streamProcessCheckpointReadyMsg(SStreamTask* pTask);
-int32_t streamProcessCheckpointRsp(SStreamMeta* pMeta, SStreamTask* pTask, SStreamCheckpointRsp* pRsp);
 
-int32_t streamTaskReleaseState(SStreamTask* pTask);
-int32_t streamTaskReloadState(SStreamTask* pTask);
 int32_t streamAlignTransferState(SStreamTask* pTask);
 
+int32_t streamAddCheckpointSourceRspMsg(SStreamCheckpointSourceReq* pReq, SRpcHandleInfo* pRpcInfo, SStreamTask* pTask,
+                                        int8_t isSucceed);
+int32_t buildCheckpointSourceRsp(SStreamCheckpointSourceReq* pReq, SRpcHandleInfo* pRpcInfo, SRpcMsg* pMsg,
+                                 int8_t isSucceed);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/stream/tstreamFileState.h

@@ -31,7 +31,8 @@ typedef struct SStreamFileState SStreamFileState;
 typedef SList SStreamSnapshot;
 
 SStreamFileState* streamFileStateInit(int64_t memSize, uint32_t keySize, uint32_t rowSize, uint32_t selectRowSize,
-                                      GetTsFun fp, void* pFile, TSKEY delMark, const char* id);
+                                      GetTsFun fp, void* pFile, TSKEY delMark, const char* taskId,
+                                      int64_t checkpointId);
 void              streamFileStateDestroy(SStreamFileState* pFileState);
 void              streamFileStateClear(SStreamFileState* pFileState);
 bool              needClearDiskBuff(SStreamFileState* pFileState);
@@ -44,7 +45,7 @@ bool    hasRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen);
 
 SStreamSnapshot* getSnapshot(SStreamFileState* pFileState);
 int32_t          flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, bool flushState);
-int32_t          recoverSnapshot(SStreamFileState* pFileState);
+int32_t          recoverSnapshot(SStreamFileState* pFileState, int64_t ckId);
 
 int32_t getSnapshotIdList(SStreamFileState* pFileState, SArray* list);
 int32_t deleteExpiredCheckPoint(SStreamFileState* pFileState, TSKEY mark);

include/libs/stream/tstreamUpdate.h

@@ -43,8 +43,8 @@ typedef struct SUpdateKey {
 //  uint64_t     maxDataVersion;
 //} SUpdateInfo;
 
-SUpdateInfo *updateInfoInitP(SInterval *pInterval, int64_t watermark);
+SUpdateInfo *updateInfoInitP(SInterval *pInterval, int64_t watermark, bool igUp);
-SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t watermark);
+SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, bool igUp);
 TSKEY        updateInfoFillBlockData(SUpdateInfo *pInfo, SSDataBlock *pBlock, int32_t primaryTsCol);
 bool         updateInfoIsUpdated(SUpdateInfo *pInfo, uint64_t tableId, TSKEY ts);
 bool         updateInfoIsTableInserted(SUpdateInfo *pInfo, int64_t tbUid);

include/libs/sync/sync.h

@@ -101,6 +101,7 @@ typedef struct SSyncCfg {
   int32_t   myIndex;
   SNodeInfo nodeInfo[TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA];
   SyncIndex lastIndex;
+  int32_t   changeVersion;
 } SSyncCfg;
 
 typedef struct SFsmCbMeta {
@@ -239,19 +240,22 @@ typedef struct SSyncState {
   ESyncState state;
   bool       restored;
   bool       canRead;
+  int32_t    progress;
   SyncTerm   term;
   int64_t    roleTimeMs;
+  int64_t    startTimeMs;
 } SSyncState;
 
-int32_t   syncInit();
+int32_t syncInit();
-void      syncCleanUp();
+void    syncCleanUp();
-int64_t   syncOpen(SSyncInfo* pSyncInfo);
+int64_t syncOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion);
-int32_t   syncStart(int64_t rid);
+int32_t syncStart(int64_t rid);
-void      syncStop(int64_t rid);
+void    syncStop(int64_t rid);
-void      syncPreStop(int64_t rid);
+void    syncPreStop(int64_t rid);
-void      syncPostStop(int64_t rid);
+void    syncPostStop(int64_t rid);
-int32_t   syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak, int64_t* seq);
+int32_t syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak, int64_t* seq);
-int32_t   syncIsCatchUp(int64_t rid);
+int32_t syncCheckMember(int64_t rid);
+int32_t syncIsCatchUp(int64_t rid);
 ESyncRole syncGetRole(int64_t rid);
 int32_t   syncProcessMsg(int64_t rid, SRpcMsg* pMsg);
 int32_t   syncReconfig(int64_t rid, SSyncCfg* pCfg);
@@ -269,6 +273,8 @@ SSyncState  syncGetState(int64_t rid);
 void        syncGetRetryEpSet(int64_t rid, SEpSet* pEpSet);
 const char* syncStr(ESyncState state);
 
+int32_t    syncNodeGetConfig(int64_t rid, SSyncCfg *cfg);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/tfs/tfs.h

@@ -300,6 +300,25 @@ void tfsClosedir(STfsDir *pDir);
  */
 int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo);
 
+/**
+ * @brief Check if disk space available at level
+ *
+ * @param pTfs The fs object.
+ * #param level the level
+ * @return bool
+ */
+bool tfsDiskSpaceAvailable(STfs *pTfs, int32_t level);
+
+/**
+ * @brief Check if disk space sufficient at disk of level
+ *
+ * @param pTfs The fs object.
+ * @param level the level
+ * @param disk the disk
+ * @return bool
+ */
+bool tfsDiskSpaceSufficient(STfs *pTfs, int32_t level, int32_t disk);
+
 #ifdef __cplusplus
 }
 #endif

include/os/osFile.h

@@ -76,7 +76,7 @@ int32_t taosUnLockFile(TdFilePtr pFile);
 
 int32_t taosUmaskFile(int32_t maskVal);
 
-int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime);
+int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime, int32_t *atime);
 int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno);
 int32_t taosFStatFile(TdFilePtr pFile, int64_t *size, int32_t *mtime);
 bool    taosCheckExistFile(const char *pathname);

include/os/osRand.h

@@ -32,6 +32,8 @@ void     taosSeedRand(uint32_t seed);
 uint32_t taosRand(void);
 uint32_t taosRandR(uint32_t* pSeed);
 void     taosRandStr(char* str, int32_t size);
+void     taosRandStr2(char* str, int32_t size);
+
 uint32_t taosSafeRand(void);
 
 #ifdef __cplusplus

include/os/osString.h

@@ -90,6 +90,11 @@ int8_t   taosStr2Int8(const char *str, char **pEnd, int32_t radix);
 uint8_t  taosStr2UInt8(const char *str, char **pEnd, int32_t radix);
 double   taosStr2Double(const char *str, char **pEnd);
 float    taosStr2Float(const char *str, char **pEnd);
+int32_t  taosHex2Ascii(const char *z, uint32_t n, void** data, uint32_t* size);
+int32_t  taosAscii2Hex(const char *z, uint32_t n, void** data, uint32_t* size);
+//int32_t  taosBin2Ascii(const char *z, uint32_t n, void** data, uint32_t* size);
+bool isHex(const char* z, uint32_t n);
+bool isValidateHex(const char* z, uint32_t n);
 
 #ifdef __cplusplus
 }

include/os/osTime.h

@@ -95,6 +95,8 @@ struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf);
 struct tm *taosLocalTimeNolock(struct tm *result, const time_t *timep, int dst);
 time_t     taosTime(time_t *t);
 time_t     taosMktime(struct tm *timep);
+int64_t    user_mktime64(const uint32_t year, const uint32_t mon, const uint32_t day, const uint32_t hour,
+                         const uint32_t min, const uint32_t sec, int64_t time_zone);
 
 #ifdef __cplusplus
 }

include/util/taoserror.h

@@ -191,6 +191,7 @@ int32_t* taosGetErrno();
 // #define TSDB_CODE_MND_FAILED_TO_CREATE_DIR   TAOS_DEF_ERROR_CODE(0, 0x0313) // 2.x
 // #define TSDB_CODE_MND_FAILED_TO_INIT_STEP    TAOS_DEF_ERROR_CODE(0, 0x0314) // 2.x
 #define TSDB_CODE_MND_USER_DISABLED             TAOS_DEF_ERROR_CODE(0, 0x0315)
+#define TSDB_CODE_MND_INVALID_PLATFORM          TAOS_DEF_ERROR_CODE(0, 0x0316)
 
 // mnode-sdb
 #define TSDB_CODE_SDB_OBJ_ALREADY_THERE         TAOS_DEF_ERROR_CODE(0, 0x0320) // internal
@@ -517,6 +518,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_JOB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x072F)
 #define TSDB_CODE_QRY_QWORKER_QUIT              TAOS_DEF_ERROR_CODE(0, 0x0730)
 #define TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0731)
+#define TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR   TAOS_DEF_ERROR_CODE(0, 0x0732)
 
 // grant
 #define TSDB_CODE_GRANT_EXPIRED                 TAOS_DEF_ERROR_CODE(0, 0x0800)
@@ -707,12 +709,14 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_OPTR_USAGE        TAOS_DEF_ERROR_CODE(0, 0x2667)
 #define TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC TAOS_DEF_ERROR_CODE(0, 0x2668)
 #define TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED      TAOS_DEF_ERROR_CODE(0, 0x2669)
+#define TSDB_CODE_PAR_INVALID_VARBINARY         TAOS_DEF_ERROR_CODE(0, 0x266A)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x26FF)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
 #define TSDB_CODE_PLAN_EXPECTED_TS_EQUAL        TAOS_DEF_ERROR_CODE(0, 0x2701)
 #define TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN   TAOS_DEF_ERROR_CODE(0, 0x2702)
+#define TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND    TAOS_DEF_ERROR_CODE(0, 0x2703)
 
 //function
 #define TSDB_CODE_FUNC_FUNTION_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2800)

include/util/tarray.h

@@ -200,8 +200,11 @@ void taosArrayClear(SArray* pArray);
  * @param pArray
  * @param fp
  */
+
 void taosArrayClearEx(SArray* pArray, void (*fp)(void*));
 
+void taosArrayClearP(SArray* pArray, void (*fp)(void*));
+
 void* taosArrayDestroy(SArray* pArray);
 
 void taosArrayDestroyP(SArray* pArray, FDelete fp);

include/util/tcompare.h

@@ -102,6 +102,7 @@ int32_t compareUint64ValDesc(const void *pLeft, const void *pRight);
 
 int32_t compareLenPrefixedStrDesc(const void *pLeft, const void *pRight);
 int32_t compareLenPrefixedWStrDesc(const void *pLeft, const void *pRight);
+int32_t compareLenBinaryValDesc(const void *pLeft, const void *pRight);
 
 int32_t comparestrPatternMatch(const void *pLeft, const void *pRight);
 int32_t comparestrPatternNMatch(const void *pLeft, const void *pRight);
@@ -202,7 +203,6 @@ int32_t compareUint64Uint32(const void *pLeft, const void *pRight);
 
 __compar_fn_t getComparFunc(int32_t type, int32_t optr);
 __compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order);
-int32_t       doCompare(const char *a, const char *b, int32_t type, size_t size);
 
 #ifdef __cplusplus
 }

include/util/tdef.h

@@ -201,7 +201,7 @@ typedef enum ELogicConditionType {
 #define TSDB_STREAM_NAME_LEN          193                                // it is a null-terminated string
 #define TSDB_DB_NAME_LEN              65
 #define TSDB_DB_FNAME_LEN             (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
-#define TSDB_PRIVILEDGE_CONDITION_LEN 48*1024
+#define TSDB_PRIVILEDGE_CONDITION_LEN 48 * 1024
 
 #define TSDB_FUNC_NAME_LEN       65
 #define TSDB_FUNC_COMMENT_LEN    1024 * 1024
@@ -378,12 +378,12 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_STT_TRIGGER     1
 #define TSDB_DEFAULT_SST_TRIGGER 1
 #endif
-#define TSDB_MIN_HASH_PREFIX            (2 - TSDB_TABLE_NAME_LEN)
+#define TSDB_MIN_HASH_PREFIX     (2 - TSDB_TABLE_NAME_LEN)
-#define TSDB_MAX_HASH_PREFIX            (TSDB_TABLE_NAME_LEN - 2)
+#define TSDB_MAX_HASH_PREFIX     (TSDB_TABLE_NAME_LEN - 2)
-#define TSDB_DEFAULT_HASH_PREFIX        0
+#define TSDB_DEFAULT_HASH_PREFIX 0
-#define TSDB_MIN_HASH_SUFFIX            (2 - TSDB_TABLE_NAME_LEN)
+#define TSDB_MIN_HASH_SUFFIX     (2 - TSDB_TABLE_NAME_LEN)
-#define TSDB_MAX_HASH_SUFFIX            (TSDB_TABLE_NAME_LEN - 2)
+#define TSDB_MAX_HASH_SUFFIX     (TSDB_TABLE_NAME_LEN - 2)
-#define TSDB_DEFAULT_HASH_SUFFIX        0
+#define TSDB_DEFAULT_HASH_SUFFIX 0
 
 #define TSDB_DB_MIN_WAL_RETENTION_PERIOD -1
 #define TSDB_REP_DEF_DB_WAL_RET_PERIOD   3600
@@ -418,9 +418,10 @@ typedef enum ELogicConditionType {
 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY_PLAN"
 
 #define TSDB_MAX_FIELD_LEN    65519               // 16384:65519
-#define TSDB_MAX_BINARY_LEN   TSDB_MAX_FIELD_LEN  // 16384-8:65519
+#define TSDB_MAX_BINARY_LEN    TSDB_MAX_FIELD_LEN  // 16384-8:65519
-#define TSDB_MAX_NCHAR_LEN    TSDB_MAX_FIELD_LEN  // 16384-8:65519
+#define TSDB_MAX_NCHAR_LEN     TSDB_MAX_FIELD_LEN  // 16384-8:65519
-#define TSDB_MAX_GEOMETRY_LEN TSDB_MAX_FIELD_LEN  // 16384-8:65519
+#define TSDB_MAX_GEOMETRY_LEN  TSDB_MAX_FIELD_LEN  // 16384-8:65519
+#define TSDB_MAX_VARBINARY_LEN TSDB_MAX_FIELD_LEN  // 16384-8:65519
 
 #define PRIMARYKEY_TIMESTAMP_COL_ID    1
 #define COL_REACH_END(colId, maxColId) ((colId) > (maxColId))

include/util/tencode.h

@@ -89,7 +89,7 @@ typedef struct {
       RET = -1;                      \
     }                                \
     tEncoderClear(&coder);           \
-  } while (0)
+  } while (0);
 
 static void* tEncoderMalloc(SEncoder* pCoder, int32_t size);
 static void* tDecoderMalloc(SDecoder* pCoder, int32_t size);

include/util/types.h

@@ -85,8 +85,6 @@ typedef uint16_t VarDataLenT;  // maxVarDataLen: 65535
 #define varDataVal(v)  ((char *)(v) + VARSTR_HEADER_SIZE)
 #define varDataTLen(v) (sizeof(VarDataLenT) + varDataLen(v))
 
-#define NCHAR_WIDTH_TO_BYTES(n) ((n)*TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE)
-
 typedef int32_t VarDataOffsetT;
 
 typedef struct tstr {

source/client/CMakeLists.txt

@@ -16,7 +16,7 @@ target_include_directories(
 target_link_libraries(
     taos
     INTERFACE api
-    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
+    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom geometry
 )
 
 if(TD_DARWIN_ARM64)
@@ -57,7 +57,7 @@ target_include_directories(
 target_link_libraries(
     taos_static
     INTERFACE api
-    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
+    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom geometry
 )
 
 if(${BUILD_TEST})

source/client/inc/clientSml.h

@@ -33,6 +33,7 @@ extern "C" {
 #include "ttime.h"
 #include "ttypes.h"
 #include "cJSON.h"
+#include "geosWrapper.h"
 
 #if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
 #  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
@@ -192,7 +193,7 @@ typedef struct {
   //
   SArray      *preLineTagKV;
   SArray      *maxTagKVs;
-  SArray      *masColKVs;
+  SArray      *maxColKVs;
 
   SSmlLineInfo preLine;
   STableMeta  *currSTableMeta;
@@ -250,7 +251,6 @@ int64_t           smlParseOpenTsdbTime(SSmlHandle *info, const char *data, int32
 int32_t           smlClearForRerun(SSmlHandle *info);
 int32_t           smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg);
 uint8_t           smlGetTimestampLen(int64_t num);
-void              clearColValArray(SArray* pCols);
 void              smlDestroyTableInfo(void *para);
 
 void freeSSmlKv(void* data);

source/client/src/clientEnv.c

@@ -133,7 +133,8 @@ void closeTransporter(SAppInstInfo *pAppInfo) {
 static bool clientRpcRfp(int32_t code, tmsg_t msgType) {
   if (NEED_REDIRECT_ERROR(code)) {
     if (msgType == TDMT_SCH_QUERY || msgType == TDMT_SCH_MERGE_QUERY || msgType == TDMT_SCH_FETCH ||
-        msgType == TDMT_SCH_MERGE_FETCH || msgType == TDMT_SCH_QUERY_HEARTBEAT || msgType == TDMT_SCH_DROP_TASK) {
+        msgType == TDMT_SCH_MERGE_FETCH || msgType == TDMT_SCH_QUERY_HEARTBEAT || msgType == TDMT_SCH_DROP_TASK ||
+        msgType == TDMT_SCH_TASK_NOTIFY) {
       return false;
     }
     return true;

source/client/src/clientImpl.c

@@ -503,7 +503,7 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
     pResInfo->userFields[i].bytes = pSchema[i].bytes;
     pResInfo->userFields[i].type = pSchema[i].type;
 
-    if (pSchema[i].type == TSDB_DATA_TYPE_VARCHAR || pSchema[i].type == TSDB_DATA_TYPE_GEOMETRY) {
+    if (pSchema[i].type == TSDB_DATA_TYPE_VARCHAR || pSchema[i].type == TSDB_DATA_TYPE_VARBINARY || pSchema[i].type == TSDB_DATA_TYPE_GEOMETRY) {
       pResInfo->userFields[i].bytes -= VARSTR_HEADER_SIZE;
     } else if (pSchema[i].type == TSDB_DATA_TYPE_NCHAR || pSchema[i].type == TSDB_DATA_TYPE_JSON) {
       pResInfo->userFields[i].bytes = (pResInfo->userFields[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;

source/client/src/clientJniConnector.c

@@ -580,6 +580,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetDoubleFp, i, (jdouble)dv);
       } break;
       case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_VARBINARY:
       case TSDB_DATA_TYPE_GEOMETRY: {
         memcpy(tmp, row[i], length[i]);  // handle the case that terminated does not exist
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetStringFp, i, (*env)->NewStringUTF(env, tmp));

source/client/src/clientMain.c

@@ -387,11 +387,22 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
         len += sprintf(str + len, "%lf", dv);
       } break;
 
+      case TSDB_DATA_TYPE_VARBINARY:{
+        void* data = NULL;
+        uint32_t size = 0;
+        int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
+        if(taosAscii2Hex(row[i], charLen, &data, &size) < 0){
+          break;
+        }
+        memcpy(str + len, data, size);
+        len += size;
+        taosMemoryFree(data);
+      }break;
       case TSDB_DATA_TYPE_BINARY:
       case TSDB_DATA_TYPE_NCHAR:
       case TSDB_DATA_TYPE_GEOMETRY: {
         int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
-        if (fields[i].type == TSDB_DATA_TYPE_BINARY || fields[i].type == TSDB_DATA_TYPE_GEOMETRY) {
+        if (fields[i].type == TSDB_DATA_TYPE_BINARY || fields[i].type == TSDB_DATA_TYPE_VARBINARY || fields[i].type == TSDB_DATA_TYPE_GEOMETRY) {
           if (ASSERT(charLen <= fields[i].bytes && charLen >= 0)) {
             tscError("taos_print_row error binary. charLen:%d, fields[i].bytes:%d", charLen, fields[i].bytes);
           }

source/client/src/clientRawBlockWrite.c

@@ -56,7 +56,7 @@ static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sch
     cJSON_AddItemToObject(column, "name", cname);
     cJSON* ctype = cJSON_CreateNumber(s->type);
     cJSON_AddItemToObject(column, "type", ctype);
-    if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) {
+    if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY|| s->type == TSDB_DATA_TYPE_GEOMETRY) {
       int32_t length = s->bytes - VARSTR_HEADER_SIZE;
       cJSON*  cbytes = cJSON_CreateNumber(length);
       cJSON_AddItemToObject(column, "length", cbytes);
@@ -77,7 +77,7 @@ static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sch
     cJSON_AddItemToObject(tag, "name", tname);
     cJSON* ttype = cJSON_CreateNumber(s->type);
     cJSON_AddItemToObject(tag, "type", ttype);
-    if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) {
+    if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) {
       int32_t length = s->bytes - VARSTR_HEADER_SIZE;
       cJSON*  cbytes = cJSON_CreateNumber(length);
       cJSON_AddItemToObject(tag, "length", cbytes);
@@ -130,7 +130,7 @@ static char* buildAlterSTableJson(void* alterData, int32_t alterDataLen) {
       cJSON* colType = cJSON_CreateNumber(field->type);
       cJSON_AddItemToObject(json, "colType", colType);
 
-      if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_GEOMETRY) {
+      if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_VARBINARY || field->type == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = field->bytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
@@ -155,7 +155,7 @@ static char* buildAlterSTableJson(void* alterData, int32_t alterDataLen) {
       cJSON_AddItemToObject(json, "colName", colName);
       cJSON* colType = cJSON_CreateNumber(field->type);
       cJSON_AddItemToObject(json, "colType", colType);
-      if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_GEOMETRY) {
+      if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_VARBINARY || field->type == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = field->bytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
@@ -292,7 +292,13 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
 
     cJSON* tvalue = NULL;
     if (IS_VAR_DATA_TYPE(pTagVal->type)) {
-      char* buf = taosMemoryCalloc(pTagVal->nData + 3, 1);
+      char* buf = NULL;
+      if(pTagVal->type == TSDB_DATA_TYPE_VARBINARY){
+        buf = taosMemoryCalloc(pTagVal->nData*2 + 2 + 3, 1);
+      }else{
+        buf = taosMemoryCalloc(pTagVal->nData + 3, 1);
+      }
+
       if (!buf) goto end;
       dataConverToStr(buf, pTagVal->type, pTagVal->pData, pTagVal->nData, NULL);
       tvalue = cJSON_CreateString(buf);
@@ -457,7 +463,7 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
       cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
       cJSON_AddItemToObject(json, "colType", colType);
 
-      if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY || vAlterTbReq.type == TSDB_DATA_TYPE_GEOMETRY) {
+      if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY || vAlterTbReq.type == TSDB_DATA_TYPE_VARBINARY || vAlterTbReq.type == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
@@ -478,7 +484,7 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
       cJSON_AddItemToObject(json, "colName", colName);
       cJSON* colType = cJSON_CreateNumber(vAlterTbReq.colModType);
       cJSON_AddItemToObject(json, "colType", colType);
-      if (vAlterTbReq.colModType == TSDB_DATA_TYPE_BINARY || vAlterTbReq.colModType == TSDB_DATA_TYPE_GEOMETRY) {
+      if (vAlterTbReq.colModType == TSDB_DATA_TYPE_BINARY || vAlterTbReq.colModType == TSDB_DATA_TYPE_VARBINARY || vAlterTbReq.colModType == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
@@ -515,7 +521,11 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
           }
           buf = parseTagDatatoJson(vAlterTbReq.pTagVal);
         } else {
-          buf = taosMemoryCalloc(vAlterTbReq.nTagVal + 1, 1);
+          if(vAlterTbReq.tagType == TSDB_DATA_TYPE_VARBINARY){
+            buf = taosMemoryCalloc(vAlterTbReq.nTagVal*2 + 2 + 3, 1);
+          }else{
+            buf = taosMemoryCalloc(vAlterTbReq.nTagVal + 3, 1);
+          }
           dataConverToStr(buf, vAlterTbReq.tagType, vAlterTbReq.pTagVal, vAlterTbReq.nTagVal, NULL);
         }
 

source/client/src/clientSml.c

@@ -608,7 +608,7 @@ static int32_t smlGenerateSchemaAction(SSchema *colField, SHashObj *colHash, SSm
       return TSDB_CODE_SML_INVALID_DATA;
     }
 
-    if (((colField[*index].type == TSDB_DATA_TYPE_VARCHAR || colField[*index].type == TSDB_DATA_TYPE_GEOMETRY) &&
+    if (((colField[*index].type == TSDB_DATA_TYPE_VARCHAR  || colField[*index].type == TSDB_DATA_TYPE_VARBINARY || colField[*index].type == TSDB_DATA_TYPE_GEOMETRY) &&
          (colField[*index].bytes - VARSTR_HEADER_SIZE) < kv->length) ||
         (colField[*index].type == TSDB_DATA_TYPE_NCHAR &&
          ((colField[*index].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE < kv->length))) {
@@ -639,7 +639,7 @@ static int32_t smlFindNearestPowerOf2(int32_t length, uint8_t type) {
     }
   }
 
-  if ((type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) && result > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
+  if ((type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY || type == TSDB_DATA_TYPE_GEOMETRY) && result > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
     result = TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE;
   } else if (type == TSDB_DATA_TYPE_NCHAR && result > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
     result = (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
@@ -647,7 +647,7 @@ static int32_t smlFindNearestPowerOf2(int32_t length, uint8_t type) {
 
   if (type == TSDB_DATA_TYPE_NCHAR) {
     result = result * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE;
-  } else if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
+  } else if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
     result = result + VARSTR_HEADER_SIZE;
   }
   return result;
@@ -691,7 +691,7 @@ static int32_t smlCheckMeta(SSchema *schema, int32_t length, SArray *cols, bool
 }
 
 static int32_t getBytes(uint8_t type, int32_t length) {
-  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_GEOMETRY) {
+  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_GEOMETRY) {
     return smlFindNearestPowerOf2(length, type);
   } else {
     return tDataTypes[type].bytes;
@@ -1085,6 +1085,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
   return 0;
 
 end:
+  taosHashCancelIterate(info->superTables, tmp);
   taosHashCleanup(hashTmp);
   taosMemoryFreeClear(pTableMeta);
   catalogRefreshTableMeta(info->pCatalog, &conn, &pName, 1);
@@ -1189,20 +1190,12 @@ void smlDestroyTableInfo(void *para) {
   taosMemoryFree(tag);
 }
 
-void clearColValArray(SArray *pCols) {
-  int32_t num = taosArrayGetSize(pCols);
-  for (int32_t i = 0; i < num; ++i) {
-    SColVal *pCol = taosArrayGet(pCols, i);
-    if (TSDB_DATA_TYPE_NCHAR == pCol->type) {
-      taosMemoryFreeClear(pCol->value.pData);
-    }
-  }
-}
-
 void freeSSmlKv(void *data) {
   SSmlKv *kv = (SSmlKv *)data;
-  if (kv->keyEscaped) taosMemoryFree((void *)(kv->key));
+  if (kv->keyEscaped) taosMemoryFreeClear(kv->key);
-  if (kv->valueEscaped) taosMemoryFree((void *)(kv->value));
+  if (kv->valueEscaped) taosMemoryFreeClear(kv->value);
+  if (kv->type == TSDB_DATA_TYPE_GEOMETRY) geosFreeBuffer((void *)(kv->value));
+  if (kv->type == TSDB_DATA_TYPE_VARBINARY) taosMemoryFreeClear(kv->value);
 }
 
 void smlDestroyInfo(SSmlHandle *info) {
@@ -1445,6 +1438,7 @@ static int32_t smlInsertData(SSmlHandle *info) {
     code = smlCheckAuth(info, &conn, pName.tname, AUTH_TYPE_WRITE);
     if(code != TSDB_CODE_SUCCESS){
       taosMemoryFree(measure);
+      taosHashCancelIterate(info->childTables, oneTable);
       return code;
     }
 
@@ -1453,6 +1447,7 @@ static int32_t smlInsertData(SSmlHandle *info) {
     if (code != TSDB_CODE_SUCCESS) {
       uError("SML:0x%" PRIx64 " catalogGetTableHashVgroup failed. table name: %s", info->id, tableData->childTableName);
       taosMemoryFree(measure);
+      taosHashCancelIterate(info->childTables, oneTable);
       return code;
     }
     taosHashPut(info->pVgHash, (const char *)&vg.vgId, sizeof(vg.vgId), (char *)&vg, sizeof(vg));
@@ -1462,6 +1457,7 @@ static int32_t smlInsertData(SSmlHandle *info) {
     if (unlikely(NULL == pMeta || NULL == (*pMeta)->tableMeta)) {
       uError("SML:0x%" PRIx64 " NULL == pMeta. table name: %s", info->id, tableData->childTableName);
       taosMemoryFree(measure);
+      taosHashCancelIterate(info->childTables, oneTable);
       return TSDB_CODE_SML_INTERNAL_ERROR;
     }
 
@@ -1477,6 +1473,7 @@ static int32_t smlInsertData(SSmlHandle *info) {
     taosMemoryFree(measure);
     if (code != TSDB_CODE_SUCCESS) {
       uError("SML:0x%" PRIx64 " smlBindData failed", info->id);
+      taosHashCancelIterate(info->childTables, oneTable);
       return code;
     }
     oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);

source/client/src/clientSmlJson.c

@@ -569,6 +569,8 @@ static int32_t smlConvertJSONNumber(SSmlKv *pVal, char *typeStr, cJSON *value) {
 static int32_t smlConvertJSONString(SSmlKv *pVal, char *typeStr, cJSON *value) {
   if (strcasecmp(typeStr, "binary") == 0) {
     pVal->type = TSDB_DATA_TYPE_BINARY;
+  } else if (strcasecmp(typeStr, "varbinary") == 0) {
+    pVal->type = TSDB_DATA_TYPE_VARBINARY;
   } else if (strcasecmp(typeStr, "nchar") == 0) {
     pVal->type = TSDB_DATA_TYPE_NCHAR;
   } else {
@@ -577,7 +579,7 @@ static int32_t smlConvertJSONString(SSmlKv *pVal, char *typeStr, cJSON *value) {
   }
   pVal->length = strlen(value->valuestring);
 
-  if (pVal->type == TSDB_DATA_TYPE_BINARY && pVal->length > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
+  if ((pVal->type == TSDB_DATA_TYPE_BINARY || pVal->type == TSDB_DATA_TYPE_VARBINARY) && pVal->length > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
     return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
   }
   if (pVal->type == TSDB_DATA_TYPE_NCHAR &&
@@ -1010,7 +1012,7 @@ static int32_t smlParseJSONStringExt(SSmlHandle *info, cJSON *root, SSmlLineInfo
     if (ret == TSDB_CODE_SUCCESS) {
       ret = smlBuildRow(info->currTableDataCtx);
     }
-    clearColValArray(info->currTableDataCtx->pValues);
+    clearColValArraySml(info->currTableDataCtx->pValues);
     if (unlikely(ret != TSDB_CODE_SUCCESS)) {
       smlBuildInvalidDataMsg(&info->msgBuf, "smlBuildCol error", NULL);
       return ret;
@@ -1214,7 +1216,7 @@ static int32_t smlParseJSONString(SSmlHandle *info, char **start, SSmlLineInfo *
     if (ret == TSDB_CODE_SUCCESS) {
       ret = smlBuildRow(info->currTableDataCtx);
     }
-    clearColValArray(info->currTableDataCtx->pValues);
+    clearColValArraySml(info->currTableDataCtx->pValues);
     if (unlikely(ret != TSDB_CODE_SUCCESS)) {
       smlBuildInvalidDataMsg(&info->msgBuf, "smlBuildCol error", NULL);
       return ret;

source/client/src/clientSmlLine.c

@@ -102,6 +102,68 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
+  if (pVal->value[0] == 'g' || pVal->value[0] == 'G') {  // geometry
+    if (pVal->value[1] == '"' && pVal->value[pVal->length - 1] == '"' && pVal->length >= sizeof("POINT")+3) {
+      int32_t code = initCtxGeomFromText();
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+      char* tmp = taosMemoryCalloc(pVal->length, 1);
+      memcpy(tmp, pVal->value + NCHAR_ADD_LEN - 1, pVal->length - NCHAR_ADD_LEN);
+      code = doGeomFromText(tmp, (unsigned char **)&pVal->value, &pVal->length);
+      taosMemoryFree(tmp);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+
+      pVal->type = TSDB_DATA_TYPE_GEOMETRY;
+      if (pVal->length > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
+        geosFreeBuffer((void*)(pVal->value));
+        return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+      }
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (pVal->value[0] == 'b' || pVal->value[0] == 'B') {  // varbinary
+    if (pVal->value[1] == '"' && pVal->value[pVal->length - 1] == '"' && pVal->length >= 3) {
+      pVal->type = TSDB_DATA_TYPE_VARBINARY;
+      if(isHex(pVal->value + NCHAR_ADD_LEN - 1, pVal->length - NCHAR_ADD_LEN)){
+        if(!isValidateHex(pVal->value + NCHAR_ADD_LEN - 1, pVal->length - NCHAR_ADD_LEN)){
+          return TSDB_CODE_PAR_INVALID_VARBINARY;
+        }
+
+        void* data = NULL;
+        uint32_t size = 0;
+        if(taosHex2Ascii(pVal->value + NCHAR_ADD_LEN - 1, pVal->length - NCHAR_ADD_LEN, &data, &size) < 0){
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
+
+        if (size + VARSTR_HEADER_SIZE > TSDB_MAX_VARBINARY_LEN) {
+          taosMemoryFree(data);
+          return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+        }
+        pVal->value  = data;
+        pVal->length = size;
+      }else{
+        pVal->length -= NCHAR_ADD_LEN;
+        if (pVal->length > TSDB_MAX_VARBINARY_LEN - VARSTR_HEADER_SIZE) {
+          return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
+        }
+        void *data = taosMemoryMalloc(pVal->length);
+        if(data == NULL){
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
+        memcpy(data, pVal->value + (NCHAR_ADD_LEN - 1), pVal->length);
+        pVal->value = data;
+      }
+
+      return TSDB_CODE_SUCCESS;
+    }
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
   if (pVal->value[0] == 't' || pVal->value[0] == 'T') {
     if (pVal->length == 1 ||
         (pVal->length == 4 && (pVal->value[1] == 'r' || pVal->value[1] == 'R') &&
@@ -390,14 +452,14 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
           SSmlKv   kv = {.key = tag->name, .keyLen = strlen(tag->name), .type = tag->type};
           if (tag->type == TSDB_DATA_TYPE_NCHAR) {
             kv.length = (tag->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
-          } else if (tag->type == TSDB_DATA_TYPE_BINARY) {
+          } else if (tag->type == TSDB_DATA_TYPE_BINARY || tag->type == TSDB_DATA_TYPE_GEOMETRY || tag->type == TSDB_DATA_TYPE_VARBINARY) {
             kv.length = tag->bytes - VARSTR_HEADER_SIZE;
           }
           taosArrayPush((*tmp)->cols, &kv);
         }
       }
       info->currSTableMeta = (*tmp)->tableMeta;
-      info->masColKVs = (*tmp)->cols;
+      info->maxColKVs = (*tmp)->cols;
     }
   }
 
@@ -491,6 +553,10 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
       char *tmp = (char *)taosMemoryMalloc(kv.length);
       memcpy(tmp, kv.value, kv.length);
       PROCESS_SLASH_IN_FIELD_VALUE(tmp, kv.length);
+      ASSERT(kv.type != TSDB_DATA_TYPE_GEOMETRY);
+      if(kv.type == TSDB_DATA_TYPE_VARBINARY){
+        taosMemoryFree((void*)kv.value);
+      }
       kv.value = tmp;
       kv.valueEscaped = valueEscaped;
     }
@@ -512,13 +578,13 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
         freeSSmlKv(&kv);
         return TSDB_CODE_SUCCESS;
       }
-      if (cnt >= taosArrayGetSize(info->masColKVs)) {
+      if (cnt >= taosArrayGetSize(info->maxColKVs)) {
         info->dataFormat = false;
         info->reRun = true;
         freeSSmlKv(&kv);
         return TSDB_CODE_SUCCESS;
       }
-      SSmlKv *maxKV = (SSmlKv *)taosArrayGet(info->masColKVs, cnt);
+      SSmlKv *maxKV = (SSmlKv *)taosArrayGet(info->maxColKVs, cnt);
       if (kv.type != maxKV->type) {
         info->dataFormat = false;
         info->reRun = true;
@@ -663,14 +729,15 @@ int32_t smlParseInfluxString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLine
   if (info->dataFormat) {
     uDebug("SML:0x%" PRIx64 " smlParseInfluxString format true, ts:%" PRId64, info->id, ts);
     ret = smlBuildCol(info->currTableDataCtx, info->currSTableMeta->schema, &kv, 0);
-    if (ret != TSDB_CODE_SUCCESS) {
+    if (ret == TSDB_CODE_SUCCESS) {
+      ret = smlBuildRow(info->currTableDataCtx);
+    }
+
+    clearColValArraySml(info->currTableDataCtx->pValues);
+    if (unlikely(ret != TSDB_CODE_SUCCESS)) {
+      smlBuildInvalidDataMsg(&info->msgBuf, "smlBuildCol error", NULL);
       return ret;
     }
-    ret = smlBuildRow(info->currTableDataCtx);
-    if (ret != TSDB_CODE_SUCCESS) {
-      return ret;
-    }
-    clearColValArray(info->currTableDataCtx->pValues);
   } else {
     uDebug("SML:0x%" PRIx64 " smlParseInfluxString format false, ts:%" PRId64, info->id, ts);
     taosArraySet(elements->colArray, 0, &kv);

source/client/src/clientSmlTelnet.c

@@ -307,7 +307,7 @@ int32_t smlParseTelnetString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLine
     if (ret == TSDB_CODE_SUCCESS) {
       ret = smlBuildRow(info->currTableDataCtx);
     }
-    clearColValArray(info->currTableDataCtx->pValues);
+    clearColValArraySml(info->currTableDataCtx->pValues);
     if (unlikely(ret != TSDB_CODE_SUCCESS)) {
       smlBuildInvalidDataMsg(&info->msgBuf, "smlBuildCol error", NULL);
       return ret;

source/client/test/CMakeLists.txt

@@ -20,7 +20,7 @@ TARGET_LINK_LIBRARIES(
 ADD_EXECUTABLE(smlTest smlTest.cpp)
 TARGET_LINK_LIBRARIES(
         smlTest
-        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest taos_static qcom geometry
 )
 
 TARGET_INCLUDE_DIRECTORIES(

source/client/test/clientTests.cpp

@@ -826,6 +826,25 @@ TEST(clientCase, projection_query_tables) {
   }
   taos_free_result(pRes);
 
+  int64_t start = 1685959190000;
+
+  int32_t code = -1;
+  for(int32_t i = 0; i < 1000000; ++i) {
+    char t[512] = {0};
+
+    sprintf(t, "insert into t1 values(%ld, %ld)", start + i, i);
+    while(1) {
+      void* p = taos_query(pConn, t);
+      code = taos_errno(p);
+      taos_free_result(p);
+      if (code != 0) {
+        printf("insert data error, retry\n");
+      } else {
+        break;
+      }
+    }
+  }
+
   for (int32_t i = 0; i < 1; ++i) {
     printf("create table :%d\n", i);
     createNewTable(pConn, i);
@@ -901,13 +920,40 @@ TEST(clientCase, agg_query_tables) {
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "show table distributed tup");
+  int64_t st = 1685959293000;
-  if (taos_errno(pRes) != 0) {
+  for (int32_t i = 0; i < 10000000; ++i) {
-    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+    char s[256] = {0};
-    taos_free_result(pRes);
+
-    ASSERT_TRUE(false);
+    while (1) {
+      sprintf(s, "insert into t1 values(%ld, %d)", st + i, i);
+      pRes = taos_query(pConn, s);
+
+      int32_t ret = taos_errno(pRes);
+      taos_free_result(pRes);
+      if (ret == 0) {
+        break;
+      }
+    }
+
+    while (1) {
+      sprintf(s, "insert into t2 values(%ld, %d)", st + i, i);
+      pRes = taos_query(pConn, s);
+      int32_t ret = taos_errno(pRes);
+
+      taos_free_result(pRes);
+      if (ret == 0) {
+        break;
+      }
+    }
   }
 
+//  pRes = taos_query(pConn, "show table distributed tup");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+//    taos_free_result(pRes);
+//    ASSERT_TRUE(false);
+//  }
+
   printResult(pRes);
   taos_free_result(pRes);
   taos_close(pConn);

source/common/CMakeLists.txt

@@ -16,6 +16,14 @@ ENDIF ()
 IF (TD_STORAGE)
   ADD_DEFINITIONS(-D_STORAGE)
   TARGET_LINK_LIBRARIES(common PRIVATE storage)
+
+  IF(${TD_LINUX})
+    IF(${BUILD_WITH_COS})
+      add_definitions(-DUSE_COS)
+    ENDIF(${BUILD_WITH_COS})
+
+  ENDIF(${TD_LINUX})
+
 ENDIF ()
 
 target_include_directories(

source/common/src/systable.c

@@ -284,7 +284,6 @@ static const SSysDbTableSchema topicSchema[] = {
     {.name = "type", .bytes = 8 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
 };
 
-
 static const SSysDbTableSchema subscriptionSchema[] = {
     {.name = "topic_name", .bytes = TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
     {.name = "consumer_group", .bytes = TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
@@ -295,12 +294,13 @@ static const SSysDbTableSchema subscriptionSchema[] = {
 };
 
 static const SSysDbTableSchema vnodesSchema[] = {
-    {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "replica", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = true},
-    {.name = "status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "dnode_ep", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
+    {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
+    {.name = "status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "role_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
+    {.name = "start_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = true},
+    {.name = "restored", .bytes = 1, .type = TSDB_DATA_TYPE_BOOL, .sysInfo = true},
 };
 
 static const SSysDbTableSchema userUserPrivilegesSchema[] = {
@@ -314,7 +314,7 @@ static const SSysDbTableSchema userUserPrivilegesSchema[] = {
 static const SSysTableMeta infosMeta[] = {
     {TSDB_INS_TABLE_DNODES, dnodesSchema, tListLen(dnodesSchema), true},
     {TSDB_INS_TABLE_MNODES, mnodesSchema, tListLen(mnodesSchema), true},
-    {TSDB_INS_TABLE_MODULES, modulesSchema, tListLen(modulesSchema), true},
+    // {TSDB_INS_TABLE_MODULES, modulesSchema, tListLen(modulesSchema), true},
     {TSDB_INS_TABLE_QNODES, qnodesSchema, tListLen(qnodesSchema), true},
     {TSDB_INS_TABLE_SNODES, snodesSchema, tListLen(snodesSchema), true},
     {TSDB_INS_TABLE_CLUSTER, clusterSchema, tListLen(clusterSchema), true},