Merge remote-tracking branch 'origin/3.0' into fix/TD-24001

README-CN.md

@@ -15,7 +15,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)
 
-简体中文 | [English](README.md) | 很多职位正在热招中，请看[这里](https://www.taosdata.com/cn/careers/)
+简体中文 | [English](README.md) | [TDengine 云服务](https://cloud.taosdata.com/?utm_medium=cn&utm_source=github) | 很多职位正在热招中，请看[这里](https://www.taosdata.com/cn/careers/)
 
 # TDengine 简介
 
@@ -52,7 +52,7 @@ TDengine 还提供一组辅助工具软件 taosTools，目前它包含 taosBench
 ### Ubuntu 18.04 及以上版本 & Debian：
 
 ```bash
-sudo apt-get install -y gcc cmake build-essential git libssl-dev libgflags2.2 libgflags-dev
+sudo apt-get install -y gcc cmake build-essential git libssl-dev libgflags2.2 libgflags-dev libgeos-dev
 ```
 
 #### 为 taos-tools 安装编译需要的软件
@@ -68,14 +68,14 @@ sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-d
 ```bash
 sudo yum install epel-release
 sudo yum update
-sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
+sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel geos geos-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 
-### CentOS 8 & Fedora
+### CentOS 8/Fedora/Rocky Linux
 
 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
+sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel geos geos-devel
 ```
 
 #### 在 CentOS 上构建 taosTools 安装依赖软件
@@ -88,7 +88,7 @@ sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 sudo yum install -y zlib-devel zlib-static xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libatomic-static libstdc++-static openssl-devel
 ```
 
-#### CentOS 8/Rocky Linux 
+#### CentOS 8/Fedora/Rocky Linux 
 
 ```
 sudo yum install -y epel-release
@@ -101,7 +101,7 @@ sudo yum install -y zlib-devel zlib-static xz-devel snappy-devel jansson jansson
 
 若 powertools 安装失败，可以尝试改用：
 ```
-sudo yum config-manager --set-enabled Powertools
+sudo yum config-manager --set-enabled powertools
 ```
 
 #### CentOS + devtoolset
@@ -117,7 +117,7 @@ scl enable devtoolset-9 -- bash
 ### macOS
 
 ```
-brew install argp-standalone pkgconfig
+brew install argp-standalone pkgconfig geos
 ```
 
 ### 设置 golang 开发环境

README.md

@@ -60,7 +60,7 @@ To build TDengine, use [CMake](https://cmake.org/) 3.0.2 or higher versions in t
 ### Ubuntu 18.04 and above or Debian
 
 ```bash
-sudo apt-get install -y gcc cmake build-essential git libssl-dev libgflags2.2 libgflags-dev
+sudo apt-get install -y gcc cmake build-essential git libssl-dev libgflags2.2 libgflags-dev libgeos-dev
 ```
 
 #### Install build dependencies for taosTools
@@ -76,14 +76,14 @@ sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-d
 ```bash
 sudo yum install epel-release
 sudo yum update
-sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
+sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel geos geos-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 
-### CentOS 8 & Fedora
+### CentOS 8/Fedora/Rocky Linux
 
 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
+sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel geos geos-devel
 ```
 
 #### Install build dependencies for taosTools on CentOS
@@ -94,7 +94,7 @@ sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 sudo yum install -y zlib-devel zlib-static xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libatomic-static libstdc++-static openssl-devel
 ```
 
-#### CentOS 8/Rocky Linux
+#### CentOS 8/Fedora/Rocky Linux
 
 ```
 sudo yum install -y epel-release
@@ -124,7 +124,7 @@ scl enable devtoolset-9 -- bash
 ### macOS
 
 ```
-brew install argp-standalone pkgconfig
+brew install argp-standalone pkgconfig geos
 ```
 
 ### Setup golang environment

cmake/cmake.define

@@ -123,8 +123,8 @@ ELSE ()
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
     ELSE ()
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -g3 -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal -g3 -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
     ENDIF ()
 
     # disable all assert

cmake/cmake.options

@@ -64,12 +64,25 @@ IF(${TD_WINDOWS})
             ON
         )
 
+    MESSAGE("build geos Win32")
+    option(
+            BUILD_GEOS
+            "If build geos on Windows"
+            ON
+        )
+
 ELSEIF (TD_DARWIN_64)
     IF(${BUILD_TEST})
         add_definitions(-DCOMPILER_SUPPORTS_CXX13)
     ENDIF ()
 ENDIF ()
 
+option(
+        BUILD_GEOS
+        "If build geos on Windows"
+        OFF
+    )
+
 option(
     BUILD_SHARED_LIBS
     ""

cmake/cmake.platform

@@ -56,7 +56,17 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin
 
         SET(TD_DARWIN TRUE)
         SET(OSTYPE "macOS")
+        execute_process(COMMAND geos-config --cflags OUTPUT_VARIABLE GEOS_CFLAGS)
+        execute_process(COMMAND geos-config --ldflags OUTPUT_VARIABLE GEOS_LDFLAGS)
+        string(SUBSTRING ${GEOS_CFLAGS} 2 -1 GEOS_CFLAGS)
+        string(REGEX REPLACE "\n" "" GEOS_CFLAGS ${GEOS_CFLAGS})
+        string(SUBSTRING ${GEOS_LDFLAGS} 2 -1 GEOS_LDFLAGS)
+        string(REGEX REPLACE "\n" "" GEOS_LDFLAGS ${GEOS_LDFLAGS})
+        MESSAGE("GEOS_CFLAGS "${GEOS_CFLAGS})
+        MESSAGE("GEOS_LDFLAGS "${GEOS_LDFLAGS})
         ADD_DEFINITIONS("-DDARWIN -Wno-tautological-pointer-compare")
+        INCLUDE_DIRECTORIES(${GEOS_CFLAGS})
+        LINK_DIRECTORIES(${GEOS_LDFLAGS})
 
         IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64")
             MESSAGE("Current system arch is arm64")

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.0.4.1")
+  SET(TD_VER_NUMBER "3.0.4.3")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

cmake/geos_CMakeLists.txt.in

+
+# geos
+ExternalProject_Add(geos
+        GIT_REPOSITORY https://github.com/libgeos/geos.git
+        GIT_TAG 3.11.2
+        SOURCE_DIR "${TD_CONTRIB_DIR}/geos"
+        BINARY_DIR ""
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        TEST_COMMAND ""
+        )
\ No newline at end of file

cmake/stub_CMakeLists.txt.in

@@ -2,6 +2,7 @@
 # stub
 ExternalProject_Add(stub
         GIT_REPOSITORY https://github.com/coolxv/cpp-stub.git
+        GIT_TAG 5e903b8e
         GIT_SUBMODULES "src"
         SOURCE_DIR "${TD_CONTRIB_DIR}/cpp-stub"
         BINARY_DIR "${TD_CONTRIB_DIR}/cpp-stub/src"

cmake/taosadapter_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
         GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG 565ca21
+        GIT_TAG 3.0
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

contrib/CMakeLists.txt

@@ -134,6 +134,11 @@ if(${BUILD_ADDR2LINE})
     endif(NOT ${TD_WINDOWS})
 endif(${BUILD_ADDR2LINE})
 
+# geos
+if(${BUILD_GEOS})
+    cat("${TD_SUPPORT_DIR}/geos_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+endif()
+
 # download dependencies
 configure_file(${CONTRIB_TMP_FILE} "${TD_CONTRIB_DIR}/deps-download/CMakeLists.txt")
 execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
@@ -226,11 +231,16 @@ if(${BUILD_WITH_ROCKSDB})
     if(${TD_LINUX})
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized -Wno-error=unused-but-set-variable -Wno-error=unused-variable -Wno-error=unused-function -Wno-errno=unused-private-field -Wno-error=unused-result")
     endif(${TD_LINUX})
+    MESSAGE(STATUS "CXXXX STATUS CONFIG: " ${CMAKE_CXX_FLAGS})
 
     if(${TD_DARWIN})
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized")
     endif(${TD_DARWIN})
 
+    if (${TD_DARWIN_ARM64})
+        set(HAS_ARMV8_CRC true)
+    endif(${TD_DARWIN_ARM64})
+
     if (${TD_WINDOWS})
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819")  
     endif(${TD_WINDOWS})
@@ -243,7 +253,7 @@ if(${BUILD_WITH_ROCKSDB})
     endif(${TD_DARWIN})
 
     if(${TD_WINDOWS})
-        option(WITH_JNI "" ON)
+	    option(WITH_JNI "" OFF)
     endif(${TD_WINDOWS})
 
     if(${TD_WINDOWS})
@@ -255,7 +265,7 @@ if(${BUILD_WITH_ROCKSDB})
     option(WITH_FALLOCATE "" OFF)
     option(WITH_JEMALLOC "" OFF)
     option(WITH_GFLAGS "" OFF)
-    option(PORTABLE "" ON)
+    option(PORTABLE "" OFF)
     option(WITH_LIBURING "" OFF)
     option(FAIL_ON_WARNINGS OFF)
 
@@ -263,8 +273,11 @@ if(${BUILD_WITH_ROCKSDB})
     option(WITH_BENCHMARK_TOOLS "" OFF)
     option(WITH_TOOLS "" OFF)
     option(WITH_LIBURING "" OFF)
-
+    IF (TD_LINUX) 
+    option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
+    ELSE()
     option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" OFF)
+    ENDIF()
     add_subdirectory(rocksdb EXCLUDE_FROM_ALL)
     target_include_directories(
         rocksdb
@@ -470,6 +483,15 @@ if(${BUILD_ADDR2LINE})
     endif(NOT ${TD_WINDOWS})
 endif(${BUILD_ADDR2LINE})
 
+# geos
+if(${BUILD_GEOS})
+    option(BUILD_SHARED_LIBS "Build GEOS with shared libraries" OFF)
+    add_subdirectory(geos EXCLUDE_FROM_ALL)
+    target_include_directories(
+        geos_c
+        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/geos/include>
+    )
+endif(${BUILD_GEOS})
 
 # ================================================================================================
 # Build test

docs/doxgen/CMakeLists.txt

@@ -4,7 +4,7 @@ if(${BUILD_DOCS})
     find_package(Doxygen)
     if (DOXYGEN_FOUND)
         # Build the doc
-        set(DOXYGEN_IN ${TD_SOURCE_DIR}/docs/Doxyfile.in)
+        set(DOXYGEN_IN ${TD_SOURCE_DIR}/docs/doxgen/Doxyfile.in)
         set(DOXYGEN_OUT ${CMAKE_BINARY_DIR}/Doxyfile)
 
         configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)

docs/en/07-develop/01-connect/index.md

@@ -83,7 +83,7 @@ If `maven` is used to manage the projects, what needs to be done is only adding
 <dependency>
   <groupId>com.taosdata.jdbc</groupId>
   <artifactId>taos-jdbcdriver</artifactId>
-  <version>3.0.0</version>
+  <version>3.2.1</version>
 </dependency>
 ```
 

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

@@ -42,7 +42,6 @@ In TDengine, the data types below can be used when specifying a column or tag.
 | 14  |       NCHAR       | User Defined | Multi-byte string that can include multi byte characters like Chinese characters. Each character of NCHAR type consumes 4 bytes storage. The string value should be quoted with single quotes. Literal single quote inside the string must be preceded with backslash, like `\'`. The length must be specified when defining a column or tag of NCHAR type, for example nchar(10) means it can store at most 10 characters of nchar type and will consume fixed storage of 40 bytes. An error will be reported if the string value exceeds the length defined. |
 | 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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-
 :::note
 
 - Only ASCII visible characters are suggested to be used in a column or tag of BINARY type. Multi-byte characters must be stored in NCHAR type.

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

@@ -1008,8 +1008,7 @@ SAMPLE(expr, k)
 
 **More explanations**:
 
-This function cannot be used in expression calculation.
-- Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline
+- This function cannot be used in expression calculation.
 
 
 ### TAIL
@@ -1088,7 +1087,6 @@ CSUM(expr)
 
 - Arithmetic operation can't be performed on the result of `csum` function
 - Can only be used with aggregate functions This function can be used with supertables and standard tables.
-- Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline
 
 
 ### DERIVATIVE
@@ -1112,7 +1110,6 @@ ignore_negative: {
 
 **More explanation**:
 
-- It can be used together with `PARTITION BY tbname` against a STable.
 - It can be used together with a selected column. For example: select \_rowts, DERIVATIVE() from.
 
 ### DIFF
@@ -1175,7 +1172,6 @@ MAVG(expr, k)
 
 - Arithmetic operation can't be performed on the result of `MAVG`.
 - Can only be used with data columns, can't be used with tags. - Can't be used with aggregate functions.
-- Must be used with `PARTITION BY tbname` when it's used on a STable to force the result on each single timeline
 
 
 ### STATECOUNT
@@ -1201,7 +1197,6 @@ STATECOUNT(expr, oper, val)
 
 **More explanations**:
 
-- Must be used together with `PARTITION BY tbname` when it's used on a STable to force the result into each single timeline]
 - Can't be used with window operation, like interval/state_window/session_window
 
 
@@ -1229,7 +1224,6 @@ STATEDURATION(expr, oper, val, unit)
 
 **More explanations**:
 
-- Must be used together with `PARTITION BY tbname` when it's used on a STable to force the result into each single timeline]
 - Can't be used with window operation, like interval/state_window/session_window
 
 
@@ -1247,7 +1241,6 @@ TWA(expr)
 
 **Applicable table types**: standard tables and supertables
 
-- Must be used together with `PARTITION BY tbname` to force the result into each single timeline.
 
 
 ## System Information Functions

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

@@ -959,6 +959,7 @@ The preceding example uses the SQL statement `select ts, speed from speed_table`
 
 ```java
 Properties config = new Properties();
+config.setProperty("bootstrap.servers", "localhost:6030");
 config.setProperty("enable.auto.commit", "true");
 config.setProperty("group.id", "group1");
 config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ResultDeserializer");
@@ -966,12 +967,14 @@ config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.Res
 TaosConsumer consumer = new TaosConsumer<>(config);
 ```
 
+- bootstrap.servers: `ip:port` where the TDengine server is located, or `ip:port` where the taosAdapter is located if WebSocket connection is used.
 - enable.auto.commit: Specifies whether to commit automatically.
 - group.id: consumer: Specifies the group that the consumer is in.
 - value.deserializer: To deserialize the results, you can inherit `com.taosdata.jdbc.tmq.ReferenceDeserializer` and specify the result set bean. You can also inherit `com.taosdata.jdbc.tmq.Deserializer` and perform custom deserialization based on the SQL result set.
 - td.connect.type: Specifies the type connect with TDengine, `jni` or `WebSocket`. default is `jni`
 - httpConnectTimeout: WebSocket connection timeout in milliseconds, the default value is 5000 ms. It only takes effect when using WebSocket type.
 - messageWaitTimeout: socket timeout in milliseconds, the default value is 10000 ms. It only takes effect when using WebSocket type.
+- httpPoolSize: Maximum number of concurrent requests on the a connection。It only takes effect when using WebSocket type.
 - For more information, see [Consumer Parameters](../../../develop/tmq).
 
 #### Subscribe to consume data
@@ -1015,10 +1018,20 @@ public abstract class ConsumerLoop {
 
     public ConsumerLoop() throws SQLException {
         Properties config = new Properties();
+        config.setProperty("td.connect.type", "jni");
+        config.setProperty("bootstrap.servers", "localhost:6030");
+        config.setProperty("td.connect.user", "root");
+        config.setProperty("td.connect.pass", "taosdata");
+        config.setProperty("auto.offset.reset", "earliest");
         config.setProperty("msg.with.table.name", "true");
         config.setProperty("enable.auto.commit", "true");
+        config.setProperty("auto.commit.interval.ms", "1000");
         config.setProperty("group.id", "group1");
+        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");
@@ -1090,12 +1103,19 @@ public abstract class ConsumerLoop {
 
     public ConsumerLoop() throws SQLException {
         Properties config = new Properties();
-        config.setProperty("bootstrap.servers", "localhost:6041");
         config.setProperty("td.connect.type", "ws");
+        config.setProperty("bootstrap.servers", "localhost:6041");
+        config.setProperty("td.connect.user", "root");
+        config.setProperty("td.connect.pass", "taosdata");
+        config.setProperty("auto.offset.reset", "earliest");
         config.setProperty("msg.with.table.name", "true");
         config.setProperty("enable.auto.commit", "true");
+        config.setProperty("auto.commit.interval.ms", "1000");
         config.setProperty("group.id", "group2");
+        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/03-connector/07-python.mdx

@@ -362,7 +362,7 @@ By using the optional req_id parameter, you can specify a request ID that can be
 
 ##### TaosConnection class
 
-The `TaosConnection` class contains both an implementation of the PEP249 Connection interface (e.g., the `cursor()` method and the `close()` method) and many extensions (e.g., the `execute()`, `query()`, `schemaless_insert()`, and `subscribe()` methods).
+As the way to connect introduced above but add `req_id` argument.
 
 ```python title="execute method"
 {{#include docs/examples/python/connection_usage_native_reference_with_req_id.py:insert}}
@@ -372,13 +372,9 @@ The `TaosConnection` class contains both an implementation of the PEP249 Connect
 {{#include docs/examples/python/connection_usage_native_reference_with_req_id.py:query}}
 ```
 
-:::tip
-The queried results can only be fetched once. For example, only one of `fetch_all()` and `fetch_all_into_dict()` can be used in the example above. Repeated fetches will result in an empty list.
-:::
-
 ##### Use of TaosResult class
 
-In the above example of using the `TaosConnection` class, we have shown two ways to get the result of a query: `fetch_all()` and `fetch_all_into_dict()`. In addition, `TaosResult` also provides methods to iterate through the result set by rows (`rows_iter`) or by data blocks (`blocks_iter`). Using these two methods will be more efficient in scenarios where the query has a large amount of data.
+As the way to fetch data introduced above but add `req_id` argument.
 
 ```python title="blocks_iter method"
 {{#include docs/examples/python/result_set_with_req_id_examples.py}}
@@ -391,17 +387,12 @@ The `TaosConnection` class and the `TaosResult` class already implement all the
 {{#include docs/examples/python/cursor_usage_native_reference_with_req_id.py}}
 ```
 
-:::note
-The TaosCursor class uses native connections for write and query operations. In a client-side multi-threaded scenario, this cursor instance must remain thread exclusive and cannot be shared across threads for use, otherwise, it will result in errors in the returned results.
-
-:::
-
 </TabItem>
 <TabItem value="rest" label="REST connection">
 
 ##### Use of TaosRestCursor class
 
-The `TaosRestCursor` class is an implementation of the PEP249 Cursor interface.
+As the way to connect introduced above but add `req_id` argument.
 
 ```python title="Use of TaosRestCursor"
 {{#include docs/examples/python/connect_rest_with_req_id_examples.py:basic}}
@@ -421,8 +412,11 @@ The `RestClient` class is a direct wrapper for the [REST API](/reference/rest-ap
 For a more detailed description of the `sql()` method, please refer to [RestClient](https://docs.taosdata.com/api/taospy/taosrest/restclient.html).
 
 </TabItem>
+
 <TabItem value="websocket" label="WebSocket connection">
 
+As the way to connect introduced above but add `req_id` argument.
+
 ```python
 {{#include docs/examples/python/connect_websocket_with_req_id_examples.py:basic}}
 ```

docs/en/14-reference/03-connector/index.mdx

@@ -62,7 +62,7 @@ The different database framework specifications for various programming language
 | **Regular Query**                      | Support       | Support         | Support       | Support       | Support       | Support       |
 | **Parameter Binding**                  | Not Supported | Not Supported   | Support       | Support       | Not Supported | Support       |
 | **Subscription (TMQ) **                | Supported     | Support         | Support       | Not Supported | Not Supported | Support       |
-| **Schemaless**                         | Supported     | Not Supported   | Not Supported | Not Supported | Not Supported | Not Supported |
+| **Schemaless**                         | Not Supported | Not Supported   | Not Supported | Not Supported | Not Supported | Not Supported |
 | **Bulk Pulling (based on WebSocket) ** | Support       | Support         | Support       | Support       | Support       | Support       |
 | **DataFrame**                          | Not Supported | Support         | Not Supported | Not Supported | Not Supported | Not Supported |
 

docs/en/14-reference/12-config/index.md

@@ -111,7 +111,7 @@ The parameters described in this document by the effect that they have on the sy
 | Attribute     | Description                                    |
 | ------------- | ---------------------------------------------- |
 | Applicable    | Client/Server                                  |
-| Meaning       | The maximum waiting time to get avaliable conn |
+| Meaning       | The maximum waiting time to get available conn |
 | Value Range   | 10-50000000(ms)                                |
 | Default Value | 500000                                         |
 

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

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

docs/examples/c/async_query_example.c

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

docs/examples/c/query_example.c

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

docs/examples/java/src/main/java/com/taos/example/StmtInsertExample.java

@@ -6,39 +6,32 @@ import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
 
 public class StmtInsertExample {
-    private static ArrayList<Long> tsToLongArray(String ts) {
-        ArrayList<Long> result = new ArrayList<>();
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
-        LocalDateTime localDateTime = LocalDateTime.parse(ts, formatter);
-        result.add(localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli());
-        return result;
-    }
-
-    private static <T> ArrayList<T> toArray(T v) {
-        ArrayList<T> result = new ArrayList<>();
-        result.add(v);
-        return result;
-    }
+    private static String datePattern = "yyyy-MM-dd HH:mm:ss.SSS";
+    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern(datePattern);
 
-    private static List<String> getRawData() {
-        return Arrays.asList(
-                "d1001,2018-10-03 14:38:05.000,10.30000,219,0.31000,California.SanFrancisco,2",
-                "d1001,2018-10-03 14:38:15.000,12.60000,218,0.33000,California.SanFrancisco,2",
-                "d1001,2018-10-03 14:38:16.800,12.30000,221,0.31000,California.SanFrancisco,2",
-                "d1002,2018-10-03 14:38:16.650,10.30000,218,0.25000,California.SanFrancisco,3",
-                "d1003,2018-10-03 14:38:05.500,11.80000,221,0.28000,California.LosAngeles,2",
-                "d1003,2018-10-03 14:38:16.600,13.40000,223,0.29000,California.LosAngeles,2",
-                "d1004,2018-10-03 14:38:05.000,10.80000,223,0.29000,California.LosAngeles,3",
-                "d1004,2018-10-03 14:38:06.500,11.50000,221,0.35000,California.LosAngeles,3"
-        );
+    private static List<String> getRawData(int size) {
+        SimpleDateFormat format = new SimpleDateFormat(datePattern);
+        List<String> result = new ArrayList<>();
+        long current = System.currentTimeMillis();
+        Random random = new Random();
+        for (int i = 0; i < size; i++) {
+            String time = format.format(current + i);
+            int id = random.nextInt(10);
+            result.add("d" + id + "," + time + ",10.30000,219,0.31000,California.SanFrancisco,2");
+        }
+        return result.stream()
+                .sorted(Comparator.comparing(s -> s.split(",")[0])).collect(Collectors.toList());
     }
 
     private static Connection getConnection() throws SQLException {
@@ -48,9 +41,9 @@ public class StmtInsertExample {
 
     private static void createTable(Connection conn) throws SQLException {
         try (Statement stmt = conn.createStatement()) {
-            stmt.execute("CREATE DATABASE power KEEP 3650");
-            stmt.executeUpdate("USE power");
-            stmt.execute("CREATE STABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) " +
+            stmt.execute("CREATE DATABASE if not exists power KEEP 3650");
+            stmt.executeUpdate("use power");
+            stmt.execute("CREATE STABLE if not exists meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) " +
                     "TAGS (location BINARY(64), groupId INT)");
         }
     }
@@ -58,21 +51,54 @@ public class StmtInsertExample {
     private static void insertData() throws SQLException {
         try (Connection conn = getConnection()) {
             createTable(conn);
-            String psql = "INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)";
+            String psql = "INSERT INTO ? USING power.meters TAGS(?, ?) VALUES(?, ?, ?, ?)";
             try (TSDBPreparedStatement pst = (TSDBPreparedStatement) conn.prepareStatement(psql)) {
-                for (String line : getRawData()) {
+                String tableName = null;
+                ArrayList<Long> ts = new ArrayList<>();
+                ArrayList<Float> current = new ArrayList<>();
+                ArrayList<Integer> voltage = new ArrayList<>();
+                ArrayList<Float> phase = new ArrayList<>();
+                for (String line : getRawData(100000)) {
                     String[] ps = line.split(",");
-                    // bind table name and tags
-                    pst.setTableName(ps[0]);
-                    pst.setTagString(0, ps[5]);
-                    pst.setTagInt(1, Integer.valueOf(ps[6]));
+                    if (tableName == null) {
+                        // bind table name and tags
+                        tableName = "power." + ps[0];
+                        pst.setTableName(ps[0]);
+                        pst.setTagString(0, ps[5]);
+                        pst.setTagInt(1, Integer.valueOf(ps[6]));
+                    } else {
+                        if (!tableName.equals(ps[0])) {
+                            pst.setTimestamp(0, ts);
+                            pst.setFloat(1, current);
+                            pst.setInt(2, voltage);
+                            pst.setFloat(3, phase);
+                            pst.columnDataAddBatch();
+                            pst.columnDataExecuteBatch();
+
+                            // bind table name and tags
+                            tableName = ps[0];
+                            pst.setTableName(ps[0]);
+                            pst.setTagString(0, ps[5]);
+                            pst.setTagInt(1, Integer.valueOf(ps[6]));
+                            ts.clear();
+                            current.clear();
+                            voltage.clear();
+                            phase.clear();
+                        }
+                    }
                     // bind values
-                    pst.setTimestamp(0, tsToLongArray(ps[1])); //ps[1] looks like: 2018-10-03 14:38:05.000
-                    pst.setFloat(1, toArray(Float.valueOf(ps[2])));
-                    pst.setInt(2, toArray(Integer.valueOf(ps[3])));
-                    pst.setFloat(3, toArray(Float.valueOf(ps[4])));
-                    pst.columnDataAddBatch();
+                    // ps[1] looks like: 2018-10-03 14:38:05.000
+                    LocalDateTime localDateTime = LocalDateTime.parse(ps[1], formatter);
+                    ts.add(localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli());
+                    current.add(Float.valueOf(ps[2]));
+                    voltage.add(Integer.valueOf(ps[3]));
+                    phase.add(Float.valueOf(ps[4]));
                 }
+                pst.setTimestamp(0, ts);
+                pst.setFloat(1, current);
+                pst.setInt(2, voltage);
+                pst.setFloat(3, phase);
+                pst.columnDataAddBatch();
                 pst.columnDataExecuteBatch();
             }
         }

docs/examples/java/src/main/java/com/taos/example/SubscribeDemo.java

@@ -53,20 +53,28 @@ public class SubscribeDemo {
 
             // create consumer
             Properties properties = new Properties();
+            properties.getProperty(TMQConstants.CONNECT_TYPE, "jni");
             properties.setProperty(TMQConstants.BOOTSTRAP_SERVERS, "127.0.0.1:6030");
+            properties.setProperty(TMQConstants.CONNECT_USER, "root");
+            properties.setProperty(TMQConstants.CONNECT_PASS, "taosdata");
             properties.setProperty(TMQConstants.MSG_WITH_TABLE_NAME, "true");
             properties.setProperty(TMQConstants.ENABLE_AUTO_COMMIT, "true");
-            properties.setProperty(TMQConstants.GROUP_ID, "test");
+            properties.setProperty(TMQConstants.AUTO_COMMIT_INTERVAL, "1000");
+            properties.setProperty(TMQConstants.GROUP_ID, "test1");
+            properties.setProperty(TMQConstants.CLIENT_ID, "1");
+            properties.setProperty(TMQConstants.AUTO_OFFSET_RESET, "earliest");
             properties.setProperty(TMQConstants.VALUE_DESERIALIZER,
                     "com.taos.example.MetersDeserializer");
+            properties.setProperty(TMQConstants.VALUE_DESERIALIZER_ENCODING, "UTF-8");
+            properties.setProperty(TMQConstants.EXPERIMENTAL_SNAPSHOT_ENABLE, "true");
 
             // poll data
             try (TaosConsumer<Meters> consumer = new TaosConsumer<>(properties)) {
                 consumer.subscribe(Collections.singletonList(TOPIC));
                 while (!shutdown.get()) {
                     ConsumerRecords<Meters> meters = consumer.poll(Duration.ofMillis(100));
-                    for (ConsumerRecord<Meters> recode : meters) {
-                        Meters meter = recode.value();
+                    for (ConsumerRecord<Meters> r : meters) {
+                        Meters meter = r.value();
                         System.out.println(meter);
                     }
                 }

docs/examples/java/src/main/java/com/taos/example/WebsocketSubscribeDemo.java

 package com.taos.example;
 
+import com.taosdata.jdbc.tmq.ConsumerRecord;
 import com.taosdata.jdbc.tmq.ConsumerRecords;
 import com.taosdata.jdbc.tmq.TMQConstants;
 import com.taosdata.jdbc.tmq.TaosConsumer;
@@ -54,18 +55,26 @@ public class WebsocketSubscribeDemo {
             Properties properties = new Properties();
             properties.setProperty(TMQConstants.BOOTSTRAP_SERVERS, "127.0.0.1:6041");
             properties.setProperty(TMQConstants.CONNECT_TYPE, "ws");
+            properties.setProperty(TMQConstants.CONNECT_USER, "root");
+            properties.setProperty(TMQConstants.CONNECT_PASS, "taosdata");
+            properties.setProperty(TMQConstants.AUTO_OFFSET_RESET, "earliest");
             properties.setProperty(TMQConstants.MSG_WITH_TABLE_NAME, "true");
             properties.setProperty(TMQConstants.ENABLE_AUTO_COMMIT, "true");
-            properties.setProperty(TMQConstants.GROUP_ID, "test");
+            properties.setProperty(TMQConstants.AUTO_COMMIT_INTERVAL, "1000");
+            properties.setProperty(TMQConstants.GROUP_ID, "test2");
+            properties.setProperty(TMQConstants.CLIENT_ID, "1");
             properties.setProperty(TMQConstants.VALUE_DESERIALIZER,
                     "com.taos.example.MetersDeserializer");
+            properties.setProperty(TMQConstants.VALUE_DESERIALIZER_ENCODING, "UTF-8");
+            properties.setProperty(TMQConstants.EXPERIMENTAL_SNAPSHOT_ENABLE, "true");
 
             // poll data
             try (TaosConsumer<Meters> consumer = new TaosConsumer<>(properties)) {
                 consumer.subscribe(Collections.singletonList(TOPIC));
                 while (!shutdown.get()) {
                     ConsumerRecords<Meters> meters = consumer.poll(Duration.ofMillis(100));
-                    for (Meters meter : meters) {
+                    for (ConsumerRecord<Meters> r : meters) {
+                        Meters meter = (Meters) r.value();
                         System.out.println(meter);
                     }
                 }

docs/zh/07-develop/01-connect/index.md

@@ -82,7 +82,7 @@ TDengine 提供了丰富的应用程序开发接口，为了便于用户快速
 <dependency>
   <groupId>com.taosdata.jdbc</groupId>
   <artifactId>taos-jdbcdriver</artifactId>
-  <version>3.0.0</version>
+  <version>3.2.1</version>
 </dependency>
 ```
 

docs/zh/08-connector/14-java.mdx

@@ -962,6 +962,7 @@ statement.executeUpdate("create topic if not exists topic_speed as select ts, sp
 
 ```java
 Properties config = new Properties();
+config.setProperty("bootstrap.servers", "localhost:6030");
 config.setProperty("enable.auto.commit", "true");
 config.setProperty("group.id", "group1");
 config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ResultDeserializer");
@@ -969,12 +970,14 @@ config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.Res
 TaosConsumer consumer = new TaosConsumer<>(config);
 ```
 
+- bootstrap.servers: TDengine 服务端所在的`ip:port`，如果使用 WebSocket 连接，则为 taosAdapter 所在的`ip:port`。
 - enable.auto.commit: 是否允许自动提交。
 - group.id: consumer: 所在的 group。
 - value.deserializer: 结果集反序列化方法，可以继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer`，并指定结果集 bean，实现反序列化。也可以继承 `com.taosdata.jdbc.tmq.Deserializer`，根据 SQL 的 resultSet 自定义反序列化方式。
 - td.connect.type: 连接方式。jni：表示使用动态库连接的方式，ws/WebSocket：表示使用 WebSocket 进行数据通信。默认为 jni 方式。
-- httpConnectTimeout：创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
-- messageWaitTimeout：数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。
+- httpConnectTimeout: 创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
+- messageWaitTimeout: 数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。
+- httpPoolSize: 同一个连接下最大并行请求数。仅在 WebSocket 连接下有效。
   其他参数请参考：[Consumer 参数列表](../../../develop/tmq#创建-consumer-以及consumer-group)
 
 #### 订阅消费数据
@@ -1016,10 +1019,19 @@ public abstract class ConsumerLoop {
 
     public ConsumerLoop() throws SQLException {
         Properties config = new Properties();
+        config.setProperty("td.connect.type", "jni");
+        config.setProperty("bootstrap.servers", "localhost:6030");
+        config.setProperty("td.connect.user", "root");
+        config.setProperty("td.connect.pass", "taosdata");
+        config.setProperty("auto.offset.reset", "earliest");
         config.setProperty("msg.with.table.name", "true");
         config.setProperty("enable.auto.commit", "true");
+        config.setProperty("auto.commit.interval.ms", "1000");
         config.setProperty("group.id", "group1");
+        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");
@@ -1093,12 +1105,19 @@ public abstract class ConsumerLoop {
 
     public ConsumerLoop() throws SQLException {
         Properties config = new Properties();
-        config.setProperty("bootstrap.servers", "localhost:6041");
         config.setProperty("td.connect.type", "ws");
+        config.setProperty("bootstrap.servers", "localhost:6041");
+        config.setProperty("td.connect.user", "root");
+        config.setProperty("td.connect.pass", "taosdata");
+        config.setProperty("auto.offset.reset", "earliest");
         config.setProperty("msg.with.table.name", "true");
         config.setProperty("enable.auto.commit", "true");
+        config.setProperty("auto.commit.interval.ms", "1000");
         config.setProperty("group.id", "group2");
+        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/zh/08-connector/26-rust.mdx

@@ -65,6 +65,13 @@ taos = "*"
 taos = { version = "*", default-features = false, features = ["ws"] }
 ```
 
+当仅启用 `ws` 特性时，可同时指定 `r2d2` 使得在同步（blocking/sync）模式下使用 [r2d2] 作为连接池：
+
+```toml
+[dependencies]
+taos = { version = "*", default-features = false, features = ["r2d2", "ws"] }
+```
+
 </TabItem>
 
 <TabItem value="native" label="仅原生连接">
@@ -257,26 +264,24 @@ let conn: Taos = cfg.build();
 
 ### 连接池
 
-在复杂应用中，建议启用连接池。[taos] 的连接池使用 [r2d2] 实现。
+在复杂应用中，建议启用连接池。[taos] 的连接池默认（异步模式）使用 [deadpool] 实现。
 
 如下，可以生成一个默认参数的连接池。
 
 ```rust
-let pool = TaosBuilder::from_dsn(dsn)?.pool()?;
+let pool: Pool<TaosBuilder> = TaosBuilder::from_dsn("taos:///")
+    .unwrap()
+    .pool()
+    .unwrap();
 ```
 
 同样可以使用连接池的构造器，对连接池参数进行设置：
 
 ```rust
-let dsn = "taos://localhost:6030";
-
-let opts = PoolBuilder::new()
-    .max_size(5000) // max connections
-    .max_lifetime(Some(Duration::from_secs(60 * 60))) // lifetime of each connection
-    .min_idle(Some(1000)) // minimal idle connections
-    .connection_timeout(Duration::from_secs(2));
-
-let pool = TaosBuilder::from_dsn(dsn)?.with_pool_builder(opts)?;
+let pool: Pool<TaosBuilder> = Pool::builder(Manager::from_dsn(self.dsn.clone()).unwrap().0)
+    .max_size(88)  // 最大连接数
+    .build()
+    .unwrap();
 ```
 
 在应用代码中，使用 `pool.get()?` 来获取一个连接对象 [Taos]。
@@ -516,6 +521,7 @@ consumer.unsubscribe().await;
 其他相关结构体 API 使用说明请移步 Rust 文档托管网页：<https://docs.rs/taos>。
 
 [taos]: https://github.com/taosdata/rust-connector-taos
+[deadpool]: https://crates.io/crates/deadpool
 [r2d2]: https://crates.io/crates/r2d2
 [TaosBuilder]: https://docs.rs/taos/latest/taos/struct.TaosBuilder.html
 [TaosCfg]: https://docs.rs/taos/latest/taos/struct.TaosCfg.html

docs/zh/08-connector/30-python.mdx

@@ -362,7 +362,7 @@ TaosCursor 类使用原生连接进行写入、查询操作。在客户端多线
 
 ##### TaosConnection 类的使用
 
-`TaosConnection` 类既包含对 PEP249 Connection 接口的实现(如：`cursor`方法和 `close` 方法)，也包含很多扩展功能（如： `execute`、 `query`、`schemaless_insert` 和 `subscribe` 方法。
+类似上文介绍的使用方法，增加 `req_id` 参数。
 
 ```python title="execute 方法"
 {{#include docs/examples/python/connection_usage_native_reference_with_req_id.py:insert}}
@@ -372,13 +372,9 @@ TaosCursor 类使用原生连接进行写入、查询操作。在客户端多线
 {{#include docs/examples/python/connection_usage_native_reference_with_req_id.py:query}}
 ```
 
-:::tip
-查询结果只能获取一次。比如上面的示例中 `fetch_all()` 和 `fetch_all_into_dict()` 只能用一个。重复获取得到的结果为空列表。
-:::
-
 ##### TaosResult 类的使用
 
-上面 `TaosConnection` 类的使用示例中，我们已经展示了两种获取查询结果的方法： `fetch_all()` 和 `fetch_all_into_dict()`。除此之外 `TaosResult` 还提供了按行迭代(`rows_iter`)或按数据块迭代(`blocks_iter`)结果集的方法。在查询数据量较大的场景，使用这两个方法会更高效。
+类似上文介绍的使用方法，增加 `req_id` 参数。
 
 ```python title="blocks_iter 方法"
 {{#include docs/examples/python/result_set_with_req_id_examples.py}}
@@ -391,14 +387,11 @@ TaosCursor 类使用原生连接进行写入、查询操作。在客户端多线
 {{#include docs/examples/python/cursor_usage_native_reference_with_req_id.py}}
 ```
 
-:::note
-TaosCursor 类使用原生连接进行写入、查询操作。在客户端多线程的场景下，这个游标实例必须保持线程独享，不能跨线程共享使用，否则会导致返回结果出现错误。
-
-:::
-
 </TabItem>
 <TabItem value="rest" label="REST 连接">
 
+类似上文介绍的使用方法，增加 `req_id` 参数。
+
 #####  TaosRestCursor 类的使用
 
 `TaosRestCursor` 类是对 PEP249 Cursor 接口的实现。
@@ -420,8 +413,11 @@ TaosCursor 类使用原生连接进行写入、查询操作。在客户端多线
 
 对于 `sql()` 方法更详细的介绍， 请参考 [RestClient](https://docs.taosdata.com/api/taospy/taosrest/restclient.html)。
 </TabItem>
+
 <TabItem value="websocket" label="WebSocket 连接">
 
+类似上文介绍的使用方法，增加 `req_id` 参数。
+
 ```python
 {{#include docs/examples/python/connect_websocket_with_req_id_examples.py:basic}}
 ```

docs/zh/08-connector/index.md

@@ -45,7 +45,7 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 | **连接管理**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **普通查询**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **参数绑定**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
-| **数据订阅（TMQ）** | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
+| **数据订阅（TMQ）** | 暂不支持 | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **Schemaless**      | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **DataFrame**       | 不支持   | 支持       | 不支持 | 不支持 | 不支持      | 不支持   |
 

docs/zh/12-taos-sql/02-database.md

@@ -121,6 +121,8 @@ alter_database_option: {
   | WAL_LEVEL value
   | WAL_FSYNC_PERIOD value
   | KEEP value
+  | WAL_RETENTION_PERIOD value
+  | WAL_RETENTION_SIZE value
 }
 ```
 

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

@@ -1001,7 +1001,6 @@ SAMPLE(expr, k)
 **使用说明**：
 
 - 不能参与表达式计算；该函数可以应用在普通表和超级表上；
-- 使用在超级表上的时候，需要搭配 PARTITION by tbname 使用，将结果强制规约到单个时间线。
 
 
 ### TAIL
@@ -1080,7 +1079,6 @@ CSUM(expr)
 
 - 不支持 +、-、*、/ 运算，如 csum(col1) + csum(col2)。
 - 只能与聚合（Aggregation）函数一起使用。 该函数可以应用在普通表和超级表上。
-- 使用在超级表上的时候，需要搭配 PARTITION BY tbname使用，将结果强制规约到单个时间线。
 
 
 ### DERIVATIVE
@@ -1104,7 +1102,6 @@ ignore_negative: {
 
 **使用说明**:
 
-- DERIVATIVE 函数可以在由 PARTITION BY 划分出单独时间线的情况下用于超级表（也即 PARTITION BY tbname）。
 - 可以与选择相关联的列一起使用。 例如: select \_rowts, DERIVATIVE() from。
 
 ### DIFF
@@ -1167,7 +1164,6 @@ MAVG(expr, k)
 
 - 不支持 +、-、*、/ 运算，如 mavg(col1, k1) + mavg(col2, k1);
 - 只能与普通列，选择（Selection）、投影（Projection）函数一起使用，不能与聚合（Aggregation）函数一起使用；
-- 使用在超级表上的时候，需要搭配 PARTITION BY tbname使用，将结果强制规约到单个时间线。
 
 
 ### STATECOUNT
@@ -1193,7 +1189,6 @@ STATECOUNT(expr, oper, val)
 
 **使用说明**：
 
-- 该函数可以应用在普通表上，在由 PARTITION BY 划分出单独时间线的情况下用于超级表（也即 PARTITION BY tbname）
 - 不能和窗口操作一起使用，例如 interval/state_window/session_window。
 
 
@@ -1221,7 +1216,6 @@ STATEDURATION(expr, oper, val, unit)
 
 **使用说明**：
 
-- 该函数可以应用在普通表上，在由 PARTITION BY 划分出单独时间线的情况下用于超级表（也即 PARTITION BY tbname）
 - 不能和窗口操作一起使用，例如 interval/state_window/session_window。
 
 
@@ -1239,8 +1233,6 @@ TWA(expr)
 
 **适用于**：表和超级表。
 
-**使用说明**： TWA 函数可以在由 PARTITION BY 划分出单独时间线的情况下用于超级表（也即 PARTITION BY tbname）。
-
 
 ## 系统信息函数
 

docs/zh/14-reference/12-config/index.md

@@ -91,11 +91,30 @@ taos --dump-config
 ### maxShellConns
 
 | 属性     | 说明                    |
-| -------- | ----------------------- |
+| --------| ----------------------- |
 | 适用范围 | 仅服务端适用            |
-| 含义     | 一个 dnode 容许的连接数 |
+| 含义    | 一个 dnode 容许的连接数 |
 | 取值范围 | 10-50000000             |
-| 缺省值   | 5000                    |
+| 缺省值  | 5000                    |
+
+### numOfRpcSessions 
+
+| 属性     | 说明                    |
+| --------| ---------------------- |
+| 适用范围 |  客户端和服务端都适用      |
+| 含义     | 一个客户端能创建的最大连接数|
+| 取值范围 | 100-100000             |
+| 缺省值   | 10000                 |
+
+### timeToGetAvailableConn
+
+| 属性     | 说明                  |
+| -------- | --------------------|
+| 适用范围 |  客户端和服务端都适用    |
+| 含义     |获得可用连接的最长等待时间|
+| 取值范围 | 10-50000000(单位为毫秒)|
+| 缺省值   | 500000               |
+
 
 ### numOfRpcSessions 
 

docs/zh/27-train-faq/01-faq.md

@@ -247,10 +247,17 @@ launchctl limit maxfiles
 该提示是创建 db 的 vnode 数量不够了，需要的 vnode 不能超过了 dnode 中 vnode 的上限。因为系统默认是一个 dnode 中有 CPU 核数两倍的 vnode，也可以通过配置文件中的参数 supportVnodes 控制。
 正常调大 taos.cfg 中 supportVnodes 参数即可。
 
-### 21 【查询】在服务器上的使用 tao-CLI 能查到指定时间段的数据，但在客户端机器上查不到？
+### 21 在服务器上的使用 taos-CLI 能查到指定时间段的数据，但在客户端机器上查不到？
 这种情况是因为客户端与服务器上设置的时区不一致导致的，调整客户端与服务器的时区一致即可解决。
 
-### 22 【表名】表名确认是存在的，但写入或查询时报表不存在错误，非常奇怪，什么原因？ 
+### 22 表名确认是存在的，但在写入或查询时返回表名不存在，什么原因？ 
 TDengine 中的所有名称，包括数据库名、表名等都是区分大小写的，如果这些名称在程序或 taos-CLI 中没有使用反引号（`）括起来使用，即使你输入的是大写的，引擎也会转化成小写来使用，如果名称前后加上了反引号，引擎就不会再转化成小写，会保持原样来使用。
 
+### 23 在 taos-CLI 中查询，字段内容不能完全显示出来怎么办？
+可以使用 \G 参数来竖式显示，如 show databases\G; （为了输入方便，在"\"后加 TAB 键，会自动补全后面的内容）
 
+### 24 使用 taosBenchmark 测试工具写入数据查询很快，为什么我写入的数据查询非常慢？
+TDengine 在写入数据时如果有很严重的乱序写入问题，会严重影响查询性能，所以需要在写入前解决乱序的问题。如果业务是从 kafka 消费写入，请合理设计消费者，尽可能的一个子表数据由一个消费者去消费并写入，避免由设计产生的乱序。
+
+### 25 我想统计下前后两条写入记录之间的时间差值是多少？
+使用 DIFF 函数，可以查看时间列或数值列前后两条记录的差值，非常方便，详细说明见 SQL手册->函数->DIFF

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.0.4.2
+
+<Release type="tdengine" version="3.0.4.2" />
+
 ## 3.0.4.1
 
 <Release type="tdengine" version="3.0.4.1" />

docs/zh/28-releases/02-tools.md

@@ -14,10 +14,6 @@ import Release from "/components/ReleaseV3";
 
 <Release type="tools" version="2.5.0" />
 
-## 2.5.0
-
-<Release type="tools" version="2.5.0" />
-
 ## 2.4.12
 
 <Release type="tools" version="2.4.12" />

examples/lua/lua51/lua_connector51.c

@@ -162,6 +162,7 @@ static int l_query(lua_State *L){
 	case TSDB_DATA_TYPE_JSON:
 	case TSDB_DATA_TYPE_BINARY:
 	case TSDB_DATA_TYPE_NCHAR:
+	case TSDB_DATA_TYPE_GEOMETRY:
 	  //printf("type:%d, max len:%d, current len:%d\n",fields[i].type, fields[i].bytes, length[i]);
 	  lua_pushlstring(L,(char *)row[i], length[i]);
 	  break;

examples/lua/lua_connector.c

@@ -161,6 +161,7 @@ static int l_query(lua_State *L){
 	case TSDB_DATA_TYPE_JSON:
 	case TSDB_DATA_TYPE_BINARY:
 	case TSDB_DATA_TYPE_NCHAR:
+	case TSDB_DATA_TYPE_GEOMETRY:
 	  //printf("type:%d, max len:%d, current len:%d\n",fields[i].type, fields[i].bytes, length[i]);
 	  lua_pushlstring(L,(char *)row[i], length[i]);
 	  break;

include/client/taos.h

@@ -51,7 +51,8 @@ typedef void   TAOS_SUB;
 #define TSDB_DATA_TYPE_BLOB       18  // binary
 #define TSDB_DATA_TYPE_MEDIUMBLOB 19
 #define TSDB_DATA_TYPE_BINARY     TSDB_DATA_TYPE_VARCHAR  // string
-#define TSDB_DATA_TYPE_MAX        20
+#define TSDB_DATA_TYPE_GEOMETRY   20  // geometry
+#define TSDB_DATA_TYPE_MAX        21
 
 typedef enum {
   TSDB_OPTION_LOCALE,

include/common/tcommon.h

@@ -37,6 +37,13 @@ extern "C" {
 )
 // clang-format on
 
+typedef bool (*state_key_cmpr_fn)(void* pKey1, void* pKey2);
+
+typedef struct STableKeyInfo {
+  uint64_t uid;
+  uint64_t groupId;
+} STableKeyInfo;
+
 typedef struct SWinKey {
   uint64_t groupId;
   TSKEY    ts;

include/common/tdataformat.h

@@ -145,7 +145,7 @@ int32_t tColDataCopy(SColData *pColDataFrom, SColData *pColData, xMallocFn xMall
 extern void (*tColDataCalcSMA[])(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min, int16_t *numOfNull);
 
 // for stmt bind
-int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind);
+int32_t tColDataAddValueByBind(SColData *pColData, TAOS_MULTI_BIND *pBind, int32_t buffMaxLen);
 void    tColDataSortMerge(SArray *colDataArr);
 
 // for raw block

include/common/tglobal.h

@@ -29,7 +29,6 @@ extern "C" {
 #define SLOW_LOG_TYPE_OTHERS 0x4
 #define SLOW_LOG_TYPE_ALL    0xFFFFFFFF
 
-
 // cluster
 extern char     tsFirst[];
 extern char     tsSecond[];
@@ -131,7 +130,7 @@ extern int32_t tsSlowLogScope;
 // client
 extern int32_t tsMinSlidingTime;
 extern int32_t tsMinIntervalTime;
-extern int32_t tsMaxMemUsedByInsert;
+extern int32_t tsMaxInsertBatchRows;
 
 // build info
 extern char version[];
@@ -180,6 +179,8 @@ extern int32_t tsRpcRetryInterval;
 extern bool    tsDisableStream;
 extern int64_t tsStreamBufferSize;
 extern int64_t tsCheckpointInterval;
+extern bool    tsFilterScalarMode;
+extern int32_t tsMaxStreamBackendCache;
 
 // #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 

include/common/tmsg.h

@@ -2009,10 +2009,8 @@ typedef struct {
   int8_t withMeta;
   char*  sql;
   char   subDbName[TSDB_DB_FNAME_LEN];
-  union {
-    char* ast;
-    char  subStbName[TSDB_TABLE_FNAME_LEN];
-  };
+  char*  ast;
+  char   subStbName[TSDB_TABLE_FNAME_LEN];
 } SCMCreateTopicReq;
 
 int32_t tSerializeSCMCreateTopicReq(void* buf, int32_t bufLen, const SCMCreateTopicReq* pReq);
@@ -2822,6 +2820,7 @@ static FORCE_INLINE int32_t tEncodeSMqRebVgReq(void** buf, const SMqRebVgReq* pR
     tlen += taosEncodeString(buf, pReq->qmsg);
   } else if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {
     tlen += taosEncodeFixedI64(buf, pReq->suid);
+    tlen += taosEncodeString(buf, pReq->qmsg);
   }
   return tlen;
 }
@@ -2838,6 +2837,7 @@ static FORCE_INLINE void* tDecodeSMqRebVgReq(const void* buf, SMqRebVgReq* pReq)
     buf = taosDecodeString(buf, &pReq->qmsg);
   } else if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {
     buf = taosDecodeFixedI64(buf, &pReq->suid);
+    buf = taosDecodeString(buf, &pReq->qmsg);
   }
   return (void*)buf;
 }

include/common/ttime.h

@@ -23,7 +23,7 @@
 extern "C" {
 #endif
 
-#define TIME_IS_VAR_DURATION(_t) ((_t) == 'n' || (_t) == 'y' || (_t) == 'N' || (_t) == 'Y')
+#define IS_CALENDAR_TIME_DURATION(_t) ((_t) == 'n' || (_t) == 'y' || (_t) == 'N' || (_t) == 'Y')
 
 #define TIME_UNIT_NANOSECOND  'b'
 #define TIME_UNIT_MICROSECOND 'u'
@@ -74,7 +74,7 @@ static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
 
 int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision);
 
-int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precision);
+int64_t taosTimeTruncate(int64_t ts, const SInterval* pInterval);
 int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char unit, int32_t precision);
 
 int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* ts, char* unit, int32_t timePrecision);

include/common/ttokendef.h

@@ -146,211 +146,212 @@
 #define TK_MEDIUMBLOB                     128
 #define TK_BLOB                           129
 #define TK_VARBINARY                      130
-#define TK_DECIMAL                        131
-#define TK_COMMENT                        132
-#define TK_MAX_DELAY                      133
-#define TK_WATERMARK                      134
-#define TK_ROLLUP                         135
-#define TK_TTL                            136
-#define TK_SMA                            137
-#define TK_DELETE_MARK                    138
-#define TK_FIRST                          139
-#define TK_LAST                           140
-#define TK_SHOW                           141
-#define TK_PRIVILEGES                     142
-#define TK_DATABASES                      143
-#define TK_TABLES                         144
-#define TK_STABLES                        145
-#define TK_MNODES                         146
-#define TK_QNODES                         147
-#define TK_FUNCTIONS                      148
-#define TK_INDEXES                        149
-#define TK_ACCOUNTS                       150
-#define TK_APPS                           151
-#define TK_CONNECTIONS                    152
-#define TK_LICENCES                       153
-#define TK_GRANTS                         154
-#define TK_QUERIES                        155
-#define TK_SCORES                         156
-#define TK_TOPICS                         157
-#define TK_VARIABLES                      158
-#define TK_CLUSTER                        159
-#define TK_BNODES                         160
-#define TK_SNODES                         161
-#define TK_TRANSACTIONS                   162
-#define TK_DISTRIBUTED                    163
-#define TK_CONSUMERS                      164
-#define TK_SUBSCRIPTIONS                  165
-#define TK_VNODES                         166
-#define TK_ALIVE                          167
-#define TK_LIKE                           168
-#define TK_TBNAME                         169
-#define TK_QTAGS                          170
-#define TK_AS                             171
-#define TK_INDEX                          172
-#define TK_FUNCTION                       173
-#define TK_INTERVAL                       174
-#define TK_COUNT                          175
-#define TK_LAST_ROW                       176
-#define TK_TOPIC                          177
-#define TK_META                           178
-#define TK_CONSUMER                       179
-#define TK_GROUP                          180
-#define TK_DESC                           181
-#define TK_DESCRIBE                       182
-#define TK_RESET                          183
-#define TK_QUERY                          184
-#define TK_CACHE                          185
-#define TK_EXPLAIN                        186
-#define TK_ANALYZE                        187
-#define TK_VERBOSE                        188
-#define TK_NK_BOOL                        189
-#define TK_RATIO                          190
-#define TK_NK_FLOAT                       191
-#define TK_OUTPUTTYPE                     192
-#define TK_AGGREGATE                      193
-#define TK_BUFSIZE                        194
-#define TK_LANGUAGE                       195
-#define TK_REPLACE                        196
-#define TK_STREAM                         197
-#define TK_INTO                           198
-#define TK_PAUSE                          199
-#define TK_RESUME                         200
-#define TK_TRIGGER                        201
-#define TK_AT_ONCE                        202
-#define TK_WINDOW_CLOSE                   203
-#define TK_IGNORE                         204
-#define TK_EXPIRED                        205
-#define TK_FILL_HISTORY                   206
-#define TK_UPDATE                         207
-#define TK_SUBTABLE                       208
-#define TK_UNTREATED                      209
-#define TK_KILL                           210
-#define TK_CONNECTION                     211
-#define TK_TRANSACTION                    212
-#define TK_BALANCE                        213
-#define TK_VGROUP                         214
-#define TK_LEADER                         215
-#define TK_MERGE                          216
-#define TK_REDISTRIBUTE                   217
-#define TK_SPLIT                          218
-#define TK_DELETE                         219
-#define TK_INSERT                         220
-#define TK_NULL                           221
-#define TK_NK_QUESTION                    222
-#define TK_NK_ARROW                       223
-#define TK_ROWTS                          224
-#define TK_QSTART                         225
-#define TK_QEND                           226
-#define TK_QDURATION                      227
-#define TK_WSTART                         228
-#define TK_WEND                           229
-#define TK_WDURATION                      230
-#define TK_IROWTS                         231
-#define TK_ISFILLED                       232
-#define TK_CAST                           233
-#define TK_NOW                            234
-#define TK_TODAY                          235
-#define TK_TIMEZONE                       236
-#define TK_CLIENT_VERSION                 237
-#define TK_SERVER_VERSION                 238
-#define TK_SERVER_STATUS                  239
-#define TK_CURRENT_USER                   240
-#define TK_CASE                           241
-#define TK_WHEN                           242
-#define TK_THEN                           243
-#define TK_ELSE                           244
-#define TK_BETWEEN                        245
-#define TK_IS                             246
-#define TK_NK_LT                          247
-#define TK_NK_GT                          248
-#define TK_NK_LE                          249
-#define TK_NK_GE                          250
-#define TK_NK_NE                          251
-#define TK_MATCH                          252
-#define TK_NMATCH                         253
-#define TK_CONTAINS                       254
-#define TK_IN                             255
-#define TK_JOIN                           256
-#define TK_INNER                          257
-#define TK_SELECT                         258
-#define TK_DISTINCT                       259
-#define TK_WHERE                          260
-#define TK_PARTITION                      261
-#define TK_BY                             262
-#define TK_SESSION                        263
-#define TK_STATE_WINDOW                   264
-#define TK_EVENT_WINDOW                   265
-#define TK_SLIDING                        266
-#define TK_FILL                           267
-#define TK_VALUE                          268
-#define TK_VALUE_F                        269
-#define TK_NONE                           270
-#define TK_PREV                           271
-#define TK_NULL_F                         272
-#define TK_LINEAR                         273
-#define TK_NEXT                           274
-#define TK_HAVING                         275
-#define TK_RANGE                          276
-#define TK_EVERY                          277
-#define TK_ORDER                          278
-#define TK_SLIMIT                         279
-#define TK_SOFFSET                        280
-#define TK_LIMIT                          281
-#define TK_OFFSET                         282
-#define TK_ASC                            283
-#define TK_NULLS                          284
-#define TK_ABORT                          285
-#define TK_AFTER                          286
-#define TK_ATTACH                         287
-#define TK_BEFORE                         288
-#define TK_BEGIN                          289
-#define TK_BITAND                         290
-#define TK_BITNOT                         291
-#define TK_BITOR                          292
-#define TK_BLOCKS                         293
-#define TK_CHANGE                         294
-#define TK_COMMA                          295
-#define TK_CONCAT                         296
-#define TK_CONFLICT                       297
-#define TK_COPY                           298
-#define TK_DEFERRED                       299
-#define TK_DELIMITERS                     300
-#define TK_DETACH                         301
-#define TK_DIVIDE                         302
-#define TK_DOT                            303
-#define TK_EACH                           304
-#define TK_FAIL                           305
-#define TK_FILE                           306
-#define TK_FOR                            307
-#define TK_GLOB                           308
-#define TK_ID                             309
-#define TK_IMMEDIATE                      310
-#define TK_IMPORT                         311
-#define TK_INITIALLY                      312
-#define TK_INSTEAD                        313
-#define TK_ISNULL                         314
-#define TK_KEY                            315
-#define TK_MODULES                        316
-#define TK_NK_BITNOT                      317
-#define TK_NK_SEMI                        318
-#define TK_NOTNULL                        319
-#define TK_OF                             320
-#define TK_PLUS                           321
-#define TK_PRIVILEGE                      322
-#define TK_RAISE                          323
-#define TK_RESTRICT                       324
-#define TK_ROW                            325
-#define TK_SEMI                           326
-#define TK_STAR                           327
-#define TK_STATEMENT                      328
-#define TK_STRICT                         329
-#define TK_STRING                         330
-#define TK_TIMES                          331
-#define TK_VALUES                         332
-#define TK_VARIABLE                       333
-#define TK_VIEW                           334
-#define TK_WAL                            335
+#define TK_GEOMETRY                       131
+#define TK_DECIMAL                        132
+#define TK_COMMENT                        133
+#define TK_MAX_DELAY                      134
+#define TK_WATERMARK                      135
+#define TK_ROLLUP                         136
+#define TK_TTL                            137
+#define TK_SMA                            138
+#define TK_DELETE_MARK                    139
+#define TK_FIRST                          140
+#define TK_LAST                           141
+#define TK_SHOW                           142
+#define TK_PRIVILEGES                     143
+#define TK_DATABASES                      144
+#define TK_TABLES                         145
+#define TK_STABLES                        146
+#define TK_MNODES                         147
+#define TK_QNODES                         148
+#define TK_FUNCTIONS                      149
+#define TK_INDEXES                        150
+#define TK_ACCOUNTS                       151
+#define TK_APPS                           152
+#define TK_CONNECTIONS                    153
+#define TK_LICENCES                       154
+#define TK_GRANTS                         155
+#define TK_QUERIES                        156
+#define TK_SCORES                         157
+#define TK_TOPICS                         158
+#define TK_VARIABLES                      159
+#define TK_CLUSTER                        160
+#define TK_BNODES                         161
+#define TK_SNODES                         162
+#define TK_TRANSACTIONS                   163
+#define TK_DISTRIBUTED                    164
+#define TK_CONSUMERS                      165
+#define TK_SUBSCRIPTIONS                  166
+#define TK_VNODES                         167
+#define TK_ALIVE                          168
+#define TK_LIKE                           169
+#define TK_TBNAME                         170
+#define TK_QTAGS                          171
+#define TK_AS                             172
+#define TK_INDEX                          173
+#define TK_FUNCTION                       174
+#define TK_INTERVAL                       175
+#define TK_COUNT                          176
+#define TK_LAST_ROW                       177
+#define TK_TOPIC                          178
+#define TK_META                           179
+#define TK_CONSUMER                       180
+#define TK_GROUP                          181
+#define TK_DESC                           182
+#define TK_DESCRIBE                       183
+#define TK_RESET                          184
+#define TK_QUERY                          185
+#define TK_CACHE                          186
+#define TK_EXPLAIN                        187
+#define TK_ANALYZE                        188
+#define TK_VERBOSE                        189
+#define TK_NK_BOOL                        190
+#define TK_RATIO                          191
+#define TK_NK_FLOAT                       192
+#define TK_OUTPUTTYPE                     193
+#define TK_AGGREGATE                      194
+#define TK_BUFSIZE                        195
+#define TK_LANGUAGE                       196
+#define TK_REPLACE                        197
+#define TK_STREAM                         198
+#define TK_INTO                           199
+#define TK_PAUSE                          200
+#define TK_RESUME                         201
+#define TK_TRIGGER                        202
+#define TK_AT_ONCE                        203
+#define TK_WINDOW_CLOSE                   204
+#define TK_IGNORE                         205
+#define TK_EXPIRED                        206
+#define TK_FILL_HISTORY                   207
+#define TK_UPDATE                         208
+#define TK_SUBTABLE                       209
+#define TK_UNTREATED                      210
+#define TK_KILL                           211
+#define TK_CONNECTION                     212
+#define TK_TRANSACTION                    213
+#define TK_BALANCE                        214
+#define TK_VGROUP                         215
+#define TK_LEADER                         216
+#define TK_MERGE                          217
+#define TK_REDISTRIBUTE                   218
+#define TK_SPLIT                          219
+#define TK_DELETE                         220
+#define TK_INSERT                         221
+#define TK_NULL                           222
+#define TK_NK_QUESTION                    223
+#define TK_NK_ARROW                       224
+#define TK_ROWTS                          225
+#define TK_QSTART                         226
+#define TK_QEND                           227
+#define TK_QDURATION                      228
+#define TK_WSTART                         229
+#define TK_WEND                           230
+#define TK_WDURATION                      231
+#define TK_IROWTS                         232
+#define TK_ISFILLED                       233
+#define TK_CAST                           234
+#define TK_NOW                            235
+#define TK_TODAY                          236
+#define TK_TIMEZONE                       237
+#define TK_CLIENT_VERSION                 238
+#define TK_SERVER_VERSION                 239
+#define TK_SERVER_STATUS                  240
+#define TK_CURRENT_USER                   241
+#define TK_CASE                           242
+#define TK_WHEN                           243
+#define TK_THEN                           244
+#define TK_ELSE                           245
+#define TK_BETWEEN                        246
+#define TK_IS                             247
+#define TK_NK_LT                          248
+#define TK_NK_GT                          249
+#define TK_NK_LE                          250
+#define TK_NK_GE                          251
+#define TK_NK_NE                          252
+#define TK_MATCH                          253
+#define TK_NMATCH                         254
+#define TK_CONTAINS                       255
+#define TK_IN                             256
+#define TK_JOIN                           257
+#define TK_INNER                          258
+#define TK_SELECT                         259
+#define TK_DISTINCT                       260
+#define TK_WHERE                          261
+#define TK_PARTITION                      262
+#define TK_BY                             263
+#define TK_SESSION                        264
+#define TK_STATE_WINDOW                   265
+#define TK_EVENT_WINDOW                   266
+#define TK_SLIDING                        267
+#define TK_FILL                           268
+#define TK_VALUE                          269
+#define TK_VALUE_F                        270
+#define TK_NONE                           271
+#define TK_PREV                           272
+#define TK_NULL_F                         273
+#define TK_LINEAR                         274
+#define TK_NEXT                           275
+#define TK_HAVING                         276
+#define TK_RANGE                          277
+#define TK_EVERY                          278
+#define TK_ORDER                          279
+#define TK_SLIMIT                         280
+#define TK_SOFFSET                        281
+#define TK_LIMIT                          282
+#define TK_OFFSET                         283
+#define TK_ASC                            284
+#define TK_NULLS                          285
+#define TK_ABORT                          286
+#define TK_AFTER                          287
+#define TK_ATTACH                         288
+#define TK_BEFORE                         289
+#define TK_BEGIN                          290
+#define TK_BITAND                         291
+#define TK_BITNOT                         292
+#define TK_BITOR                          293
+#define TK_BLOCKS                         294
+#define TK_CHANGE                         295
+#define TK_COMMA                          296
+#define TK_CONCAT                         297
+#define TK_CONFLICT                       298
+#define TK_COPY                           299
+#define TK_DEFERRED                       300
+#define TK_DELIMITERS                     301
+#define TK_DETACH                         302
+#define TK_DIVIDE                         303
+#define TK_DOT                            304
+#define TK_EACH                           305
+#define TK_FAIL                           306
+#define TK_FILE                           307
+#define TK_FOR                            308
+#define TK_GLOB                           309
+#define TK_ID                             310
+#define TK_IMMEDIATE                      311
+#define TK_IMPORT                         312
+#define TK_INITIALLY                      313
+#define TK_INSTEAD                        314
+#define TK_ISNULL                         315
+#define TK_KEY                            316
+#define TK_MODULES                        317
+#define TK_NK_BITNOT                      318
+#define TK_NK_SEMI                        319
+#define TK_NOTNULL                        320
+#define TK_OF                             321
+#define TK_PLUS                           322
+#define TK_PRIVILEGE                      323
+#define TK_RAISE                          324
+#define TK_RESTRICT                       325
+#define TK_ROW                            326
+#define TK_SEMI                           327
+#define TK_STAR                           328
+#define TK_STATEMENT                      329
+#define TK_STRICT                         330
+#define TK_STRING                         331
+#define TK_TIMES                          332
+#define TK_VALUES                         333
+#define TK_VARIABLE                       334
+#define TK_VIEW                           335
+#define TK_WAL                            336
 
 
 

include/common/ttypes.h

@@ -269,7 +269,7 @@ 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_VARCHAR) || ((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_VALID_TINYINT(_t)   ((_t) >= INT8_MIN && (_t) <= INT8_MAX)
@@ -316,6 +316,8 @@ static FORCE_INLINE bool isNull(const void *val, int32_t type) {
       return *(uint32_t *)val == TSDB_DATA_UINT_NULL;
     case TSDB_DATA_TYPE_UBIGINT:
       return *(uint64_t *)val == TSDB_DATA_UBIGINT_NULL;
+    case TSDB_DATA_TYPE_GEOMETRY:
+      return varDataLen(val) == sizeof(int8_t) && *(uint8_t *)varDataVal(val) == TSDB_DATA_GEOMETRY_NULL;
 
     default:
       return false;

include/libs/executor/dataSinkMgt.h

@@ -59,7 +59,7 @@ typedef struct SDataSinkMgtCfg {
   uint32_t maxDataBlockNumPerQuery;
 } SDataSinkMgtCfg;
 
-int32_t dsDataSinkMgtInit(SDataSinkMgtCfg* cfg);
+int32_t dsDataSinkMgtInit(SDataSinkMgtCfg* cfg, SStorageAPI* pAPI);
 
 typedef struct SInputData {
   const struct SSDataBlock* pData;

include/libs/executor/executor.h

@@ -23,6 +23,7 @@ extern "C" {
 #include "query.h"
 #include "tcommon.h"
 #include "tmsgcb.h"
+#include "storageapi.h"
 
 typedef void* qTaskInfo_t;
 typedef void* DataSinkHandle;
@@ -41,7 +42,6 @@ typedef struct {
 
 typedef struct {
   void*   tqReader;
-  void*   meta;
   void*   config;
   void*   vnode;
   void*   mnd;
@@ -51,10 +51,10 @@ typedef struct {
   bool    initTableReader;
   bool    initTqReader;
   int32_t numOfVgroups;
+  void*   sContext;  // SSnapContext*
 
-  void* sContext;  // SSnapContext*
-
-  void* pStateBackend;
+  void*   pStateBackend;
+  struct SStorageAPI api;
 } SReadHandle;
 
 // in queue mode, data streams are seperated by msg
@@ -82,6 +82,8 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers, int32_t v
 qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* pReaderHandle, int32_t vgId, int32_t* numOfCols,
                                      uint64_t id);
 
+int32_t qGetTableList(int64_t suid, void* pVnode, void* node, SArray **tableList, void* pTaskInfo);
+
 /**
  * set the task Id, usually used by message queue process
  * @param tinfo
@@ -90,6 +92,8 @@ qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* pReaderHandle, int3
  */
 void qSetTaskId(qTaskInfo_t tinfo, uint64_t taskId, uint64_t queryId);
 
+//void qSetTaskCode(qTaskInfo_t tinfo, int32_t code);
+
 int32_t qSetStreamOpOpen(qTaskInfo_t tinfo);
 
 // todo refactor
@@ -186,7 +190,17 @@ int32_t qSerializeTaskStatus(qTaskInfo_t tinfo, char** pOutput, int32_t* len);
 
 int32_t qDeserializeTaskStatus(qTaskInfo_t tinfo, const char* pInput, int32_t len);
 
-STimeWindow getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key);
+void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t order);
+void getInitialStartTimeWindow(SInterval* pInterval, TSKEY ts, STimeWindow* w, bool ascQuery);
+STimeWindow getAlignQueryTimeWindow(const SInterval* pInterval, int64_t key);
+/**
+ * return the scan info, in the form of tuple of two items, including table uid and current timestamp
+ * @param tinfo
+ * @param uid
+ * @param ts
+ * @return
+ */
+int32_t qGetStreamScanStatus(qTaskInfo_t tinfo, uint64_t* uid, int64_t* ts);
 
 SArray* qGetQueriedTableListInfo(qTaskInfo_t tinfo);
 

include/libs/executor/storageapi.h

+/*
+ * 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 TDENGINE_STORAGEAPI_H
+#define TDENGINE_STORAGEAPI_H
+
+#include "tsimplehash.h"
+#include "tscalablebf.h"
+#include "taosdef.h"
+#include "tmsg.h"
+#include "tcommon.h"
+#include "index.h"
+#include "function.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TIMEWINDOW_RANGE_CONTAINED 1
+#define TIMEWINDOW_RANGE_EXTERNAL  2
+
+#define CACHESCAN_RETRIEVE_TYPE_ALL    0x1
+#define CACHESCAN_RETRIEVE_TYPE_SINGLE 0x2
+#define CACHESCAN_RETRIEVE_LAST_ROW    0x4
+#define CACHESCAN_RETRIEVE_LAST        0x8
+
+#define META_READER_NOLOCK 0x1
+
+typedef struct SMeta SMeta;
+typedef TSKEY (*GetTsFun)(void*);
+
+typedef struct SMetaEntry {
+  int64_t  version;
+  int8_t   type;
+  int8_t   flags;  // TODO: need refactor?
+  tb_uid_t uid;
+  char *   name;
+  union {
+    struct {
+      SSchemaWrapper schemaRow;
+      SSchemaWrapper schemaTag;
+      SRSmaParam     rsmaParam;
+    } stbEntry;
+    struct {
+      int64_t  ctime;
+      int32_t  ttlDays;
+      int32_t  commentLen;
+      char *   comment;
+      tb_uid_t suid;
+      uint8_t *pTags;
+    } ctbEntry;
+    struct {
+      int64_t        ctime;
+      int32_t        ttlDays;
+      int32_t        commentLen;
+      char *         comment;
+      int32_t        ncid;  // next column id
+      SSchemaWrapper schemaRow;
+    } ntbEntry;
+    struct {
+      STSma *tsma;
+    } smaEntry;
+  };
+
+  uint8_t *pBuf;
+} SMetaEntry;
+
+typedef struct SMetaReader {
+  int32_t             flags;
+  void *              pMeta;
+  SDecoder            coder;
+  SMetaEntry          me;
+  void *              pBuf;
+  int32_t             szBuf;
+  struct SStoreMeta*  pAPI;
+} SMetaReader;
+
+typedef struct SMTbCursor {
+  void *      pDbc;
+  void *      pKey;
+  void *      pVal;
+  int32_t     kLen;
+  int32_t     vLen;
+  SMetaReader mr;
+} SMTbCursor;
+
+typedef struct SRowBuffPos {
+  void* pRowBuff;
+  void* pKey;
+  bool  beFlushed;
+  bool  beUsed;
+} SRowBuffPos;
+
+// tq
+typedef struct SMetaTableInfo {
+  int64_t         suid;
+  int64_t         uid;
+  SSchemaWrapper *schema;
+  char            tbName[TSDB_TABLE_NAME_LEN];
+} SMetaTableInfo;
+
+typedef struct SSnapContext {
+  SMeta *     pMeta;     // todo remove it
+  int64_t     snapVersion;
+  void *      pCur;
+  int64_t     suid;
+  int8_t      subType;
+  SHashObj *  idVersion;
+  SHashObj *  suidInfo;
+  SArray *    idList;
+  int32_t     index;
+  bool        withMeta;
+  bool        queryMeta;  // true-get meta, false-get data
+} SSnapContext;
+
+typedef struct {
+  int64_t uid;
+  int64_t ctbNum;
+} SMetaStbStats;
+
+// void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
+// int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList);
+// int32_t tqReaderAddTbUidList(STqReader *pReader, const SArray *pTableUidList);
+// int32_t tqReaderRemoveTbUidList(STqReader *pReader, const SArray *tbUidList);
+// bool    tqReaderIsQueriedTable(STqReader* pReader, uint64_t uid);
+// bool    tqCurrentBlockConsumed(const STqReader* pReader);
+// int32_t tqReaderSeek(STqReader *pReader, int64_t ver, const char *id);
+// bool    tqNextBlockInWal(STqReader* pReader, const char* idstr);
+// bool    tqNextBlockImpl(STqReader *pReader, const char* idstr);
+// int32_t        getTableInfoFromSnapshot(SSnapContext *ctx, void **pBuf, int32_t *contLen, int16_t *type, int64_t *uid);
+// SMetaTableInfo getMetaTableInfoFromSnapshot(SSnapContext *ctx);
+// int32_t        setForSnapShot(SSnapContext *ctx, int64_t uid);
+// int32_t        destroySnapContext(SSnapContext *ctx);
+
+// clang-format off
+/*-------------------------------------------------new api format---------------------------------------------------*/
+typedef struct TsdReader {
+  int32_t      (*tsdReaderOpen)(void* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,
+                           SSDataBlock* pResBlock, void** ppReader, const char* idstr, bool countOnly,
+                           SHashObj** pIgnoreTables);
+  void         (*tsdReaderClose)();
+  void         (*tsdSetReaderTaskId)(void *pReader, const char *pId);
+  int32_t      (*tsdSetQueryTableList)();
+  int32_t      (*tsdNextDataBlock)();
+
+  int32_t      (*tsdReaderRetrieveBlockSMAInfo)();
+  SSDataBlock *(*tsdReaderRetrieveDataBlock)();
+
+  void         (*tsdReaderReleaseDataBlock)();
+
+  int32_t      (*tsdReaderResetStatus)();
+  int32_t      (*tsdReaderGetDataBlockDistInfo)();
+  int64_t      (*tsdReaderGetNumOfInMemRows)();
+  void         (*tsdReaderNotifyClosing)();
+} TsdReader;
+
+typedef struct SStoreCacheReader {
+  int32_t  (*openReader)(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
+                         SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr);
+  void    *(*closeReader)(void *pReader);
+  int32_t  (*retrieveRows)(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, const int32_t *dstSlotIds,
+                           SArray *pTableUidList);
+  int32_t  (*reuseReader)(void *pReader, void *pTableIdList, int32_t numOfTables);
+} SStoreCacheReader;
+
+// clang-format on
+
+/*------------------------------------------------------------------------------------------------------------------*/
+/*
+void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
+int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList);
+int32_t tqReaderAddTbUidList(STqReader *pReader, const SArray *pTableUidList);
+int32_t tqReaderRemoveTbUidList(STqReader *pReader, const SArray *tbUidList);
+bool    tqReaderIsQueriedTable(STqReader* pReader, uint64_t uid);
+bool    tqCurrentBlockConsumed(const STqReader* pReader);
+
+int32_t tqReaderSeek(STqReader *pReader, int64_t ver, const char *id);
+bool    tqNextBlockInWal(STqReader* pReader, const char* idstr);
+bool    tqNextBlockImpl(STqReader *pReader, const char* idstr);
+
+ int32_t    tqRetrieveDataBlock(STqReader *pReader, SSDataBlock **pRes, const char* idstr);
+STqReader *tqReaderOpen(void *pVnode);
+void       tqReaderClose(STqReader *);
+
+int32_t tqReaderSetSubmitMsg(STqReader *pReader, void *msgStr, int32_t msgLen, int64_t ver);
+bool    tqNextDataBlockFilterOut(STqReader *pReader, SHashObj *filterOutUids);
+SWalReader* tqGetWalReader(STqReader* pReader);
+int32_t tqRetrieveTaosxBlock(STqReader *pReader, SArray *blocks, SArray *schemas, SSubmitTbData **pSubmitTbDataRet);
+*/
+// todo rename
+typedef struct SStoreTqReader {
+  struct STqReader* (*tqReaderOpen)();
+  void (*tqReaderClose)();
+
+  int32_t (*tqReaderSeek)();
+  int32_t (*tqRetrieveBlock)();
+  bool (*tqReaderNextBlockInWal)();
+  bool (*tqNextBlockImpl)();  // todo remove it
+  SSDataBlock* (*tqGetResultBlock)();
+
+  void (*tqReaderSetColIdList)();
+  int32_t (*tqReaderSetQueryTableList)();
+
+  int32_t (*tqReaderAddTables)();
+  int32_t (*tqReaderRemoveTables)();
+
+  bool (*tqReaderIsQueriedTable)();
+  bool (*tqReaderCurrentBlockConsumed)();
+
+  struct SWalReader *(*tqReaderGetWalReader)();  // todo remove it
+  int32_t (*tqReaderRetrieveTaosXBlock)();          // todo remove it
+
+  int32_t (*tqReaderSetSubmitMsg)();  // todo remove it
+  bool (*tqReaderNextBlockFilterOut)();
+} SStoreTqReader;
+
+typedef struct SStoreSnapshotFn {
+  int32_t (*createSnapshot)(SSnapContext *ctx, int64_t uid);
+  int32_t (*destroySnapshot)(SSnapContext *ctx);
+  SMetaTableInfo (*getMetaTableInfoFromSnapshot)(SSnapContext* ctx);
+  int32_t (*getTableInfoFromSnapshot)(SSnapContext* ctx, void** pBuf, int32_t* contLen, int16_t* type, int64_t* uid);
+} SStoreSnapshotFn;
+
+/**
+void        metaReaderInit(SMetaReader *pReader, SMeta *pMeta, int32_t flags);
+void        metaReaderReleaseLock(SMetaReader *pReader);
+void        metaReaderClear(SMetaReader *pReader);
+int32_t     metaReaderGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid);
+int32_t     metaReaderGetTableEntryByUidCache(SMetaReader *pReader, tb_uid_t uid);
+int32_t     metaGetTableTags(SMeta *pMeta, uint64_t suid, SArray *uidList);
+const void *metaGetTableTagVal(void *tag, int16_t type, STagVal *tagVal);
+int         metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName);
+
+int      metaGetTableUidByName(void *meta, char *tbName, uint64_t *uid);
+int      metaGetTableTypeByName(void *meta, char *tbName, ETableType *tbType);
+bool     metaIsTableExist(SMeta *pMeta, tb_uid_t uid);
+int32_t  metaGetCachedTableUidList(SMeta *pMeta, tb_uid_t suid, const uint8_t *key, int32_t keyLen, SArray *pList,
+                                   bool *acquired);
+int32_t  metaUidFilterCachePut(SMeta *pMeta, uint64_t suid, const void *pKey, int32_t keyLen, void *pPayload,
+                               int32_t payloadLen, double selectivityRatio);
+tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name);
+int32_t  metaGetCachedTbGroup(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray** pList);
+int32_t  metaPutTbGroupToCache(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload, int32_t payloadLen);
+ */
+
+typedef struct SStoreMeta {
+  SMTbCursor *(*openTableMetaCursor)(void *pVnode);                        // metaOpenTbCursor
+  void        (*closeTableMetaCursor)(SMTbCursor *pTbCur);                 // metaCloseTbCursor
+  int32_t     (*cursorNext)(SMTbCursor *pTbCur, ETableType jumpTableType); // metaTbCursorNext
+  int32_t     (*cursorPrev)(SMTbCursor *pTbCur, ETableType jumpTableType); // metaTbCursorPrev
+
+  int32_t     (*getTableTags)(void *pVnode, uint64_t suid, SArray *uidList);
+  int32_t     (*getTableTagsByUid)(void *pVnode, int64_t suid, SArray *uidList);
+  const void *(*extractTagVal)(const void *tag, int16_t type, STagVal *tagVal);  // todo remove it
+
+  int32_t     (*getTableUidByName)(void *pVnode, char *tbName, uint64_t *uid);
+  int32_t     (*getTableTypeByName)(void *pVnode, char *tbName, ETableType *tbType);
+  int32_t     (*getTableNameByUid)(void *pVnode, uint64_t uid, char *tbName);
+  bool        (*isTableExisted)(void *pVnode, tb_uid_t uid);
+
+  int32_t     (*metaGetCachedTbGroup)(void* pVnode, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray** pList);
+  int32_t     (*metaPutTbGroupToCache)(void* pVnode, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload, int32_t payloadLen);
+
+  int32_t     (*getCachedTableList)(void* pVnode, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray* pList1, bool* acquireRes);
+  int32_t     (*putCachedTableList)(void* pVnode, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload, int32_t payloadLen, double selectivityRatio);
+
+  void       *(*storeGetIndexInfo)();
+  void       *(*getInvertIndex)(void* pVnode);
+  int32_t     (*getChildTableList)(void *pVnode, int64_t suid, SArray *list);  // support filter and non-filter cases. [vnodeGetCtbIdList & vnodeGetCtbIdListByFilter]
+  int32_t     (*storeGetTableList)(void* pVnode, int8_t type, SArray* pList);    // vnodeGetStbIdList  & vnodeGetAllTableList
+  void       *storeGetVersionRange;
+  void       *storeGetLastTimestamp;
+
+  int32_t     (*getTableSchema)(void *pVnode, int64_t uid, STSchema **pSchema, int64_t *suid);  // tsdbGetTableSchema
+
+  // db name, vgId, numOfTables, numOfSTables
+  int32_t (*getNumOfChildTables)(void* pVnode, int64_t uid, int64_t* numOfTables);  // int32_t metaGetStbStats(SMeta *pMeta, int64_t uid, SMetaStbStats *pInfo);
+  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);
+ */
+} SStoreMeta;
+
+typedef struct SStoreMetaReader {
+  void    (*initReader)(SMetaReader *pReader, void *pVnode, int32_t flags, SStoreMeta* pAPI);
+  void    (*clearReader)(SMetaReader *pReader);
+  void    (*readerReleaseLock)(SMetaReader *pReader);
+  int32_t (*getTableEntryByUid)(SMetaReader *pReader, tb_uid_t uid);
+  int32_t (*getTableEntryByName)(SMetaReader *pReader, const char *name);
+  int32_t (*getEntryGetUidCache)(SMetaReader *pReader, tb_uid_t uid);
+} SStoreMetaReader;
+
+typedef struct SUpdateInfo {
+  SArray      *pTsBuckets;
+  uint64_t     numBuckets;
+  SArray      *pTsSBFs;
+  uint64_t     numSBFs;
+  int64_t      interval;
+  int64_t      watermark;
+  TSKEY        minTS;
+  SScalableBf *pCloseWinSBF;
+  SHashObj    *pMap;
+  uint64_t     maxDataVersion;
+} SUpdateInfo;
+
+typedef struct {
+  void*   iter;      //  rocksdb_iterator_t*    iter;
+  void*   snapshot;  //  rocksdb_snapshot_t*    snapshot;
+  void*   readOpt;   //  rocksdb_readoptions_t* readOpt;
+  void*   db;        //  rocksdb_t*             db;
+  void*   pCur;
+  int64_t number;
+} SStreamStateCur;
+
+typedef struct SStateStore {
+  int32_t (*streamStatePutParName)(SStreamState* pState, int64_t groupId, const char* tbname);
+  int32_t (*streamStateGetParName)(SStreamState* pState, int64_t groupId, void** pVal);
+
+  int32_t (*streamStateAddIfNotExist)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateReleaseBuf)(SStreamState* pState, const SWinKey* key, void* pVal);
+  void    (*streamStateFreeVal)(void* val);
+
+  int32_t (*streamStatePut)(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
+  int32_t (*streamStateGet)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
+  bool    (*streamStateCheck)(SStreamState* pState, const SWinKey* key);
+  int32_t (*streamStateGetByPos)(SStreamState* pState, void* pos, void** pVal);
+  int32_t (*streamStateDel)(SStreamState* pState, const SWinKey* key);
+  int32_t (*streamStateClear)(SStreamState* pState);
+  void    (*streamStateSetNumber)(SStreamState* pState, int32_t number);
+  int32_t (*streamStateSaveInfo)(SStreamState* pState, void* pKey, int32_t keyLen, void* pVal, int32_t vLen);
+  int32_t (*streamStateGetInfo)(SStreamState* pState, void* pKey, int32_t keyLen, void** pVal, int32_t* pLen);
+
+  int32_t (*streamStateFillPut)(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
+  int32_t (*streamStateFillGet)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateFillDel)(SStreamState* pState, const SWinKey* key);
+
+  int32_t (*streamStateCurNext)(SStreamState* pState, SStreamStateCur* pCur);
+  int32_t (*streamStateCurPrev)(SStreamState* pState, SStreamStateCur* pCur);
+
+  SStreamStateCur*  (*streamStateGetAndCheckCur)(SStreamState* pState, SWinKey* key);
+  SStreamStateCur*  (*streamStateSeekKeyNext)(SStreamState* pState, const SWinKey* key);
+  SStreamStateCur*  (*streamStateFillSeekKeyNext)(SStreamState* pState, const SWinKey* key);
+  SStreamStateCur*  (*streamStateFillSeekKeyPrev)(SStreamState* pState, const SWinKey* key);
+  void   (*streamStateFreeCur)(SStreamStateCur* pCur);
+
+  int32_t (*streamStateGetGroupKVByCur)(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+  int32_t (*streamStateGetKVByCur)(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
+
+  int32_t (*streamStateSessionAddIfNotExist)(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateSessionPut)(SStreamState* pState, const SSessionKey* key, const void* value, int32_t vLen);
+  int32_t (*streamStateSessionGet)(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateSessionDel)(SStreamState* pState, const SSessionKey* key);
+  int32_t (*streamStateSessionClear)(SStreamState* pState);
+  int32_t (*streamStateSessionGetKVByCur)(SStreamStateCur* pCur, SSessionKey* pKey, void** pVal, int32_t* pVLen);
+  int32_t (*streamStateStateAddIfNotExist)(SStreamState* pState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
+                                     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);
+  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);
+  void    (*updateInfoDestroy)(SUpdateInfo *pInfo);
+
+  SUpdateInfo* (*updateInfoInitP)(SInterval *pInterval, int64_t watermark);
+  void        (*updateInfoAddCloseWindowSBF)(SUpdateInfo *pInfo);
+  void        (*updateInfoDestoryColseWinSBF)(SUpdateInfo *pInfo);
+  int32_t     (*updateInfoSerialize)(void *buf, int32_t bufLen, const SUpdateInfo *pInfo);
+  int32_t     (*updateInfoDeserialize)(void *buf, int32_t bufLen, SUpdateInfo *pInfo);
+
+  SStreamStateCur* (*streamStateSessionSeekKeyNext)(SStreamState* pState, const SSessionKey* key);
+  SStreamStateCur* (*streamStateSessionSeekKeyCurrentPrev)(SStreamState* pState, const SSessionKey* key);
+  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);
+
+  void (*streamFileStateDestroy)(struct SStreamFileState* pFileState);
+  void (*streamFileStateClear)(struct SStreamFileState* pFileState);
+  bool (*needClearDiskBuff)(struct SStreamFileState* pFileState);
+
+  SStreamState* (*streamStateOpen)(char* path, void* pTask, bool specPath, int32_t szPage, int32_t pages);
+  void          (*streamStateClose)(SStreamState* pState, bool remove);
+  int32_t       (*streamStateBegin)(SStreamState* pState);
+  int32_t       (*streamStateCommit)(SStreamState* pState);
+  void          (*streamStateDestroy)(SStreamState* pState, bool remove);
+  int32_t       (*streamStateDeleteCheckPoint)(SStreamState* pState, TSKEY mark);
+} SStateStore;
+
+typedef struct SStorageAPI {
+  SStoreMeta          metaFn;  // todo: refactor
+  TsdReader           tsdReader;
+  SStoreMetaReader    metaReaderFn;
+  SStoreCacheReader   cacheFn;
+  SStoreSnapshotFn    snapshotFn;
+  SStoreTqReader      tqReaderFn;
+  SStateStore         stateStore;
+  SMetaDataFilterAPI  metaFilter;
+  SFunctionStateStore functionStore;
+} SStorageAPI;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_STORAGEAPI_H

include/libs/function/function.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tcommon.h"
+#include "tsimplehash.h"
 #include "tvariant.h"
 
 struct SqlFunctionCtx;
@@ -76,7 +77,7 @@ enum {
 enum {
   MAIN_SCAN = 0x0u,
   REVERSE_SCAN = 0x1u,  // todo remove it
-  PRE_SCAN = 0x2u,   // pre-scan belongs to the main scan and occurs before main scan
+  PRE_SCAN = 0x2u,      // pre-scan belongs to the main scan and occurs before main scan
 };
 
 typedef struct SPoint1 {
@@ -127,16 +128,58 @@ typedef struct SSerializeDataHandle {
   void                 *pState;
 } SSerializeDataHandle;
 
+// incremental state storage
+typedef struct STdbState {
+  void               *rocksdb;
+  void              **pHandle;
+  void               *writeOpts;
+  void               *readOpts;
+  void              **cfOpts;
+  void               *dbOpt;
+  struct SStreamTask *pOwner;
+  void               *param;
+  void               *env;
+  SListNode          *pComparNode;
+  void               *pBackend;
+  char                idstr[64];
+  void               *compactFactory;
+  TdThreadRwlock      rwLock;
+
+  void *db;
+  void *pStateDb;
+  void *pFuncStateDb;
+  void *pFillStateDb;  // todo refactor
+  void *pSessionStateDb;
+  void *pParNameDb;
+  void *pParTagDb;
+  void *txn;
+} STdbState;
+
+typedef struct {
+  STdbState               *pTdbState;
+  struct SStreamFileState *pFileState;
+  int32_t                  number;
+  SSHashObj               *parNameMap;
+  int64_t                  checkPointId;
+  int32_t                  taskId;
+  int64_t                  streamId;
+} SStreamState;
+
+typedef struct SFunctionStateStore {
+  int32_t (*streamStateFuncPut)(SStreamState *pState, const SWinKey *key, const void *value, int32_t vLen);
+  int32_t (*streamStateFuncGet)(SStreamState *pState, const SWinKey *key, void **ppVal, int32_t *pVLen);
+} SFunctionStateStore;
+
 // sql function runtime context
 typedef struct SqlFunctionCtx {
   SInputColumnInfoData input;
   SResultDataInfo      resDataInfo;
-  uint32_t             order;       // data block scanner order: asc|desc
-  uint8_t              isPseudoFunc;// denote current function is pseudo function or not [added for perf reason]
-  uint8_t              isNotNullFunc;// not return null value.
-  uint8_t              scanFlag;    // record current running step, default: 0
-  int16_t              functionId;  // function id
-  char                *pOutput;     // final result output buffer, point to sdata->data
+  uint32_t             order;          // data block scanner order: asc|desc
+  uint8_t              isPseudoFunc;   // denote current function is pseudo function or not [added for perf reason]
+  uint8_t              isNotNullFunc;  // not return null value.
+  uint8_t              scanFlag;       // record current running step, default: 0
+  int16_t              functionId;     // function id
+  char                *pOutput;        // final result output buffer, point to sdata->data
   // input parameter, e.g., top(k, 20), the number of results of top query is kept in param
   SFunctParam *param;
   // corresponding output buffer for timestamp of each result, e.g., diff/csum
@@ -155,6 +198,7 @@ typedef struct SqlFunctionCtx {
   SSerializeDataHandle saveHandle;
   int32_t              exprIdx;
   char                *udfName;
+  SFunctionStateStore *pStore;
 } SqlFunctionCtx;
 
 typedef struct tExprNode {

include/libs/function/functionMgt.h

@@ -158,6 +158,17 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_STDDEV_PARTIAL,
   FUNCTION_TYPE_STDDEV_MERGE,
 
+  // geometry functions
+  FUNCTION_TYPE_GEOM_FROM_TEXT = 4250,
+  FUNCTION_TYPE_AS_TEXT,
+  FUNCTION_TYPE_MAKE_POINT,
+  FUNCTION_TYPE_INTERSECTS,
+  FUNCTION_TYPE_EQUALS,
+  FUNCTION_TYPE_TOUCHES,
+  FUNCTION_TYPE_COVERS,
+  FUNCTION_TYPE_CONTAINS,
+  FUNCTION_TYPE_CONTAINS_PROPERLY,
+
   // user defined funcion
   FUNCTION_TYPE_UDF = 10000
 } EFunctionType;

include/libs/function/taosudf.h

@@ -109,7 +109,7 @@ 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_VARCHAR) || ((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))
 
 static FORCE_INLINE char *udfColDataGetData(const SUdfColumn *pColumn, int32_t row) {

include/libs/geometry/geomFunc.h

+/*
+ * 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 TDENGINE_GEOM_FUNC_H
+#define TDENGINE_GEOM_FUNC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "function.h"
+
+int32_t makePointFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+int32_t geomFromTextFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t asTextFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+int32_t intersectsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t equalsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t touchesFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t coversFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t containsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t containsProperlyFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_GEOM_FUNC_H

include/libs/geometry/geosWrapper.h

+/*
+ * 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 TDENGINE_GEOS_WRAPPER_H
+#define TDENGINE_GEOS_WRAPPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "os.h"
+
+#include "tgeosctx.h"
+
+void geosFreeBuffer(void *buffer);
+
+int32_t initCtxMakePoint();
+int32_t doMakePoint(double x, double y, unsigned char **outputGeom, size_t *size);
+
+int32_t initCtxGeomFromText();
+int32_t doGeomFromText(const char *inputWKT, unsigned char **outputGeom, size_t *size);
+
+int32_t initCtxAsText();
+int32_t doAsText(const unsigned char *inputGeom, size_t size, char **outputWKT);
+
+int32_t initCtxRelationFunc();
+int32_t doIntersects(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                     bool swapped, char *res);
+int32_t doEquals(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                 bool swapped, char *res);
+int32_t doTouches(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                  bool swapped, char *res);
+int32_t doCovers(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                 bool swapped, char *res);
+int32_t doContains(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                   bool swapped, char *res);
+int32_t doContainsProperly(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
+                           bool swapped, char *res);
+
+int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom, const GEOSPreparedGeometry **outputPreparedGeom);
+void destroyGeometry(GEOSGeometry **geom, const GEOSPreparedGeometry **preparedGeom);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*TDENGINE_GEOS_WRAPPER_H*/

include/libs/index/index.h

@@ -212,13 +212,38 @@ typedef struct SIndexMetaArg {
   void*    idx;
   void*    ivtIdx;
   uint64_t suid;
+  int (*metaFilterFunc)(void* metaEx, void* param, SArray* result);
 } SIndexMetaArg;
 
+/**
+ * the underlying storage module must implement this API to employ the index functions.
+ * @param pMeta
+ * @param param
+ * @param results
+ * @return
+ */
+typedef struct SMetaFltParam {
+  uint64_t suid;
+  int16_t  cid;
+  int16_t  type;
+  void    *val;
+  bool     reverse;
+  bool     equal;
+  int (*filterFunc)(void *a, void *b, int16_t type);
+} SMetaFltParam;
+
+typedef struct SMetaDataFilterAPI {
+  int32_t (*metaFilterTableIds)(void *pVnode, SMetaFltParam *arg, SArray *pUids);
+  int32_t (*metaFilterCreateTime)(void *pVnode, SMetaFltParam *arg, SArray *pUids);
+  int32_t (*metaFilterTableName)(void *pVnode, SMetaFltParam *arg, SArray *pUids);
+  int32_t (*metaFilterTtl)(void *pVnode, SMetaFltParam *arg, SArray *pUids);
+} SMetaDataFilterAPI;
+
 typedef enum { SFLT_NOT_INDEX, SFLT_COARSE_INDEX, SFLT_ACCURATE_INDEX } SIdxFltStatus;
 
-SIdxFltStatus idxGetFltStatus(SNode* pFilterNode);
+SIdxFltStatus idxGetFltStatus(SNode* pFilterNode, SMetaDataFilterAPI* pAPI);
 
-int32_t doFilterTag(SNode* pFilterNode, SIndexMetaArg* metaArg, SArray* result, SIdxFltStatus* status);
+int32_t doFilterTag(SNode* pFilterNode, SIndexMetaArg* metaArg, SArray* result, SIdxFltStatus* status, SMetaDataFilterAPI* pAPI);
 
 /*
  *  init index env

include/libs/nodes/cmdnodes.h

@@ -364,6 +364,7 @@ typedef struct SCreateTopicStmt {
   bool      ignoreExists;
   bool      withMeta;
   SNode*    pQuery;
+  SNode*    pWhere;
 } SCreateTopicStmt;
 
 typedef struct SDropTopicStmt {

include/libs/nodes/plannodes.h

@@ -112,6 +112,7 @@ typedef struct SJoinLogicNode {
   SNode*     pOnConditions;
   bool       isSingleTableJoin;
   EOrder     inputTsOrder;
+  SNode*     pColEqualOnConditions;
 } SJoinLogicNode;
 
 typedef struct SAggLogicNode {
@@ -406,6 +407,7 @@ typedef struct SSortMergeJoinPhysiNode {
   SNode*     pOnConditions;
   SNodeList* pTargets;
   EOrder     inputTsOrder;
+  SNode*     pColEqualOnConditions;
 } SSortMergeJoinPhysiNode;
 
 typedef struct SAggPhysiNode {
@@ -448,7 +450,7 @@ typedef struct SMergePhysiNode {
   bool       ignoreGroupId;
 } SMergePhysiNode;
 
-typedef struct SWinodwPhysiNode {
+typedef struct SWindowPhysiNode {
   SPhysiNode node;
   SNodeList* pExprs;  // these are expression list of parameter expression of function
   SNodeList* pFuncs;
@@ -461,10 +463,10 @@ typedef struct SWinodwPhysiNode {
   EOrder     inputTsOrder;
   EOrder     outputTsOrder;
   bool       mergeDataBlock;
-} SWinodwPhysiNode;
+} SWindowPhysiNode;
 
 typedef struct SIntervalPhysiNode {
-  SWinodwPhysiNode window;
+  SWindowPhysiNode window;
   int64_t          interval;
   int64_t          offset;
   int64_t          sliding;
@@ -497,7 +499,7 @@ typedef struct SMultiTableIntervalPhysiNode {
 } SMultiTableIntervalPhysiNode;
 
 typedef struct SSessionWinodwPhysiNode {
-  SWinodwPhysiNode window;
+  SWindowPhysiNode window;
   int64_t          gap;
 } SSessionWinodwPhysiNode;
 
@@ -506,14 +508,14 @@ typedef SSessionWinodwPhysiNode SStreamSemiSessionWinodwPhysiNode;
 typedef SSessionWinodwPhysiNode SStreamFinalSessionWinodwPhysiNode;
 
 typedef struct SStateWinodwPhysiNode {
-  SWinodwPhysiNode window;
+  SWindowPhysiNode window;
   SNode*           pStateKey;
 } SStateWinodwPhysiNode;
 
 typedef SStateWinodwPhysiNode SStreamStateWinodwPhysiNode;
 
 typedef struct SEventWinodwPhysiNode {
-  SWinodwPhysiNode window;
+  SWindowPhysiNode window;
   SNode*           pStartCond;
   SNode*           pEndCond;
 } SEventWinodwPhysiNode;

include/libs/qcom/query.h

@@ -51,6 +51,12 @@ typedef enum {
   TARGET_TYPE_OTHER,
 } ETargetType;
 
+typedef enum {
+  TCOL_TYPE_COLUMN = 1,
+  TCOL_TYPE_TAG,
+  TCOL_TYPE_NONE,
+} ETableColumnType;
+
 #define QUERY_POLICY_VNODE  1
 #define QUERY_POLICY_HYBRID 2
 #define QUERY_POLICY_QNODE  3
@@ -253,6 +259,7 @@ void    destroyQueryExecRes(SExecResult* pRes);
 int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len);
 char*   parseTagDatatoJson(void* p);
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
+void    getColumnTypeFromMeta(STableMeta* pMeta, char* pName, ETableColumnType* pType);
 int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst);
 int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst);
 void    freeVgInfo(SDBVgInfo* vgInfo);

include/libs/stream/streamState.h

@@ -27,65 +27,63 @@
 extern "C" {
 #endif
 
+#include "storageapi.h"
+
 // void*      streamBackendInit(const char* path);
 // void       streamBackendCleanup(void* arg);
 // SListNode* streamBackendAddCompare(void* backend, void* arg);
 // void       streamBackendDelCompare(void* backend, void* arg);
-typedef bool (*state_key_cmpr_fn)(void* pKey1, void* pKey2);
-
-typedef struct STdbState {
-  rocksdb_t*                       rocksdb;
-  rocksdb_column_family_handle_t** pHandle;
-  rocksdb_writeoptions_t*          writeOpts;
-  rocksdb_readoptions_t*           readOpts;
-  rocksdb_options_t**              cfOpts;
-  rocksdb_options_t*               dbOpt;
-  struct SStreamTask*              pOwner;
-  void*                            param;
-  void*                            env;
-  SListNode*                       pComparNode;
-  void*                            pBackendHandle;
-  char                             idstr[64];
-  void*                            compactFactory;
-
-  TDB* db;
-  TTB* pStateDb;
-  TTB* pFuncStateDb;
-  TTB* pFillStateDb;  // todo refactor
-  TTB* pSessionStateDb;
-  TTB* pParNameDb;
-  TTB* pParTagDb;
-  TXN* txn;
-} STdbState;
-
-// incremental state storage
-typedef struct {
-  STdbState*        pTdbState;
-  SStreamFileState* pFileState;
-  int32_t           number;
-  SSHashObj*        parNameMap;
-  int64_t           checkPointId;
-  int32_t           taskId;
-  int64_t           streamId;
-} SStreamState;
-
-SStreamState* streamStateOpen(char* path, struct SStreamTask* pTask, bool specPath, int32_t szPage, int32_t pages);
+
+// <<<<<<< HEAD
+// typedef struct STdbState {
+//   rocksdb_t*                       rocksdb;
+//   rocksdb_column_family_handle_t** pHandle;
+//   rocksdb_writeoptions_t*          writeOpts;
+//   rocksdb_readoptions_t*           readOpts;
+//   rocksdb_options_t**              cfOpts;
+//   rocksdb_options_t*               dbOpt;
+//   struct SStreamTask*              pOwner;
+//   void*                            param;
+//   void*                            env;
+//   SListNode*                       pComparNode;
+//   void*                            pBackend;
+//   char                             idstr[64];
+//   void*                            compactFactory;
+//   TdThreadRwlock                   rwLock;
+// =======
+// typedef struct STdbState {
+//  rocksdb_t*                       rocksdb;
+//  rocksdb_column_family_handle_t** pHandle;
+//  rocksdb_writeoptions_t*          writeOpts;
+//  rocksdb_readoptions_t*           readOpts;
+//  rocksdb_options_t**              cfOpts;
+//  rocksdb_options_t*               dbOpt;
+//  struct SStreamTask*              pOwner;
+//  void*                            param;
+//  void*                            env;
+//  SListNode*                       pComparNode;
+//  void*                            pBackendHandle;
+//  char                             idstr[64];
+//  void*                            compactFactory;
+//
+//  TDB* db;
+//  TTB* pStateDb;
+//  TTB* pFuncStateDb;
+//  TTB* pFillStateDb;  // todo refactor
+//  TTB* pSessionStateDb;
+//  TTB* pParNameDb;
+//  TTB* pParTagDb;
+//  TXN* txn;
+//} STdbState;
+//>>>>>>> enh/dev3.0
+
+SStreamState* streamStateOpen(char* path, void* pTask, bool specPath, int32_t szPage, int32_t pages);
 void          streamStateClose(SStreamState* pState, bool remove);
 int32_t       streamStateBegin(SStreamState* pState);
 int32_t       streamStateCommit(SStreamState* pState);
 void          streamStateDestroy(SStreamState* pState, bool remove);
 int32_t       streamStateDeleteCheckPoint(SStreamState* pState, TSKEY mark);
 
-typedef struct {
-  rocksdb_iterator_t*    iter;
-  rocksdb_snapshot_t*    snapshot;
-  rocksdb_readoptions_t* readOpt;
-  rocksdb_t*             db;
-
-  TBC*    pCur;
-  int64_t number;
-} SStreamStateCur;
-
 int32_t streamStateFuncPut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
 int32_t streamStateFuncGet(SStreamState* pState, const SWinKey* key, void** ppVal, int32_t* pVLen);
 
@@ -119,7 +117,7 @@ int32_t streamStateFillDel(SStreamState* pState, const SWinKey* key);
 
 int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
 int32_t streamStateReleaseBuf(SStreamState* pState, const SWinKey* key, void* pVal);
-void    streamFreeVal(void* val);
+void    streamStateFreeVal(void* val);
 
 SStreamStateCur* streamStateGetAndCheckCur(SStreamState* pState, SWinKey* key);
 SStreamStateCur* streamStateSeekKeyNext(SStreamState* pState, const SWinKey* key);

include/libs/stream/tstream.h

@@ -78,11 +78,11 @@ enum {
   TASK_TRIGGER_STATUS__ACTIVE,
 };
 
-enum {
+typedef enum {
   TASK_LEVEL__SOURCE = 1,
   TASK_LEVEL__AGG,
   TASK_LEVEL__SINK,
-};
+} ETASK_LEVEL;
 
 enum {
   TASK_OUTPUT__FIXED_DISPATCH = 1,
@@ -284,13 +284,13 @@ struct SStreamTask {
   int16_t         dispatchMsgType;
   SStreamStatus   status;
   int32_t         selfChildId;
-  int32_t         nodeId;
+  int32_t         nodeId;      // vgroup id
   SEpSet          epSet;
   SCheckpointInfo chkInfo;
   STaskExec       exec;
-
-  // fill history
-  int8_t fillHistory;
+  int8_t          fillHistory;  // fill history
+  int64_t         ekey;         // end ts key
+  int64_t         endVer;       // end version
 
   // children info
   SArray* childEpInfo;  // SArray<SStreamChildEpInfo*>
@@ -351,7 +351,7 @@ typedef struct SStreamMeta {
 int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo);
 int32_t tDecodeStreamEpInfo(SDecoder* pDecoder, SStreamChildEpInfo* pInfo);
 
-SStreamTask* tNewStreamTask(int64_t streamId);
+SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, int8_t fillHistory, int64_t triggerParam, SArray* pTaskList);
 int32_t      tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask);
 int32_t      tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask);
 void         tFreeStreamTask(SStreamTask* pTask);

include/libs/stream/tstreamFileState.h

@@ -21,23 +21,16 @@
 #include "tarray.h"
 #include "tdef.h"
 #include "tlist.h"
+#include "storageapi.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef struct SStreamFileState SStreamFileState;
-typedef struct SRowBuffPos {
-  void* pRowBuff;
-  void* pKey;
-  bool  beFlushed;
-  bool  beUsed;
-} SRowBuffPos;
 
 typedef SList SStreamSnapshot;
 
-typedef TSKEY (*GetTsFun)(void*);
-
 SStreamFileState* streamFileStateInit(int64_t memSize, uint32_t keySize, uint32_t rowSize, uint32_t selectRowSize,
                                       GetTsFun fp, void* pFile, TSKEY delMark);
 void              streamFileStateDestroy(SStreamFileState* pFileState);

include/libs/stream/tstreamUpdate.h

@@ -19,7 +19,7 @@
 #include "tarray.h"
 #include "tcommon.h"
 #include "tmsg.h"
-#include "tscalablebf.h"
+#include "storageapi.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,18 +30,18 @@ typedef struct SUpdateKey {
   TSKEY   ts;
 } SUpdateKey;
 
-typedef struct SUpdateInfo {
-  SArray      *pTsBuckets;
-  uint64_t     numBuckets;
-  SArray      *pTsSBFs;
-  uint64_t     numSBFs;
-  int64_t      interval;
-  int64_t      watermark;
-  TSKEY        minTS;
-  SScalableBf *pCloseWinSBF;
-  SHashObj    *pMap;
-  uint64_t     maxDataVersion;
-} SUpdateInfo;
+//typedef struct SUpdateInfo {
+//  SArray      *pTsBuckets;
+//  uint64_t     numBuckets;
+//  SArray      *pTsSBFs;
+//  uint64_t     numSBFs;
+//  int64_t      interval;
+//  int64_t      watermark;
+//  TSKEY        minTS;
+//  SScalableBf *pCloseWinSBF;
+//  SHashObj    *pMap;
+//  uint64_t     maxDataVersion;
+//} SUpdateInfo;
 
 SUpdateInfo *updateInfoInitP(SInterval *pInterval, int64_t watermark);
 SUpdateInfo *updateInfoInit(int64_t interval, int32_t precision, int64_t watermark);

include/libs/wal/wal.h

@@ -149,6 +149,7 @@ struct SWalReader {
   TdFilePtr      pIdxFile;
   int64_t        curFileFirstVer;
   int64_t        curVersion;
+  int64_t        skipToVersion; // skip data and jump to destination version, usually used by stream resume ignoring untreated data
   int64_t        capacity;
   TdThreadMutex  mutex;
   SWalFilterCond cond;
@@ -200,6 +201,8 @@ int32_t     walReaderSeekVer(SWalReader *pRead, int64_t ver);
 int32_t     walNextValidMsg(SWalReader *pRead);
 int64_t     walReaderGetCurrentVer(const SWalReader *pReader);
 int64_t     walReaderGetValidFirstVer(const SWalReader *pReader);
+int64_t     walReaderGetSkipToVersion(SWalReader *pReader);
+void        walReaderSetSkipToVersion(SWalReader *pReader, int64_t ver);
 void        walReaderValidVersionRange(SWalReader *pReader, int64_t *sver, int64_t *ever);
 void        walReaderVerifyOffset(SWalReader *pWalReader, STqOffsetVal* pOffset);
 
@@ -209,7 +212,8 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead);
 int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead);
 int32_t walSkipFetchBody(SWalReader *pRead, const SWalCkHead *pHead);
 
-SWalRef *walRefFirstVer(SWal *, SWalRef *);
+void walRefFirstVer(SWal *, SWalRef *);
+void walRefLastVer(SWal *, SWalRef *);
 SWalRef *walRefCommittedVer(SWal *);
 
 SWalRef *walOpenRef(SWal *);

include/util/taoserror.h

@@ -409,6 +409,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MNODE_ALREADY_IS_VOTER        TAOS_DEF_ERROR_CODE(0, 0x0413) // internal
 #define TSDB_CODE_MNODE_ONLY_TWO_MNODE          TAOS_DEF_ERROR_CODE(0, 0x0414) // internal
 #define TSDB_CODE_MNODE_NO_NEED_RESTORE         TAOS_DEF_ERROR_CODE(0, 0x0415) // internal
+#define TSDB_CODE_DNODE_ONLY_USE_WHEN_OFFLINE   TAOS_DEF_ERROR_CODE(0, 0x0416)
 
 // vnode
 // #define TSDB_CODE_VND_ACTION_IN_PROGRESS     TAOS_DEF_ERROR_CODE(0, 0x0500) // 2.x

include/util/tdef.h

@@ -32,7 +32,7 @@ extern "C" {
 #define TD_VER_MAX UINT64_MAX  // TODO: use the real max version from query handle
 
 // Bytes for each type.
-extern const int32_t TYPE_BYTES[16];
+extern const int32_t TYPE_BYTES[17];
 
 // TODO: replace and remove code below
 #define CHAR_BYTES      sizeof(char)
@@ -53,10 +53,11 @@ extern const int32_t TYPE_BYTES[16];
 #define TSDB_DATA_BIGINT_NULL    0x8000000000000000LL
 #define TSDB_DATA_TIMESTAMP_NULL TSDB_DATA_BIGINT_NULL
 
-#define TSDB_DATA_FLOAT_NULL  0x7FF00000            // it is an NAN
-#define TSDB_DATA_DOUBLE_NULL 0x7FFFFF0000000000LL  // an NAN
-#define TSDB_DATA_NCHAR_NULL  0xFFFFFFFF
-#define TSDB_DATA_BINARY_NULL 0xFF
+#define TSDB_DATA_FLOAT_NULL    0x7FF00000            // it is an NAN
+#define TSDB_DATA_DOUBLE_NULL   0x7FFFFF0000000000LL  // an NAN
+#define TSDB_DATA_NCHAR_NULL    0xFFFFFFFF
+#define TSDB_DATA_BINARY_NULL   0xFF
+#define TSDB_DATA_GEOMETRY_NULL 0xFF
 
 #define TSDB_DATA_UTINYINT_NULL  0xFF
 #define TSDB_DATA_USMALLINT_NULL 0xFFFF
@@ -253,6 +254,7 @@ typedef enum ELogicConditionType {
 #define TSDB_IPv4ADDR_LEN       16
 #define TSDB_FILENAME_LEN       128
 #define TSDB_SHOW_SQL_LEN       2048
+#define TSDB_SHOW_SCHEMA_JSON_LEN TSDB_MAX_COLUMNS * 256
 #define TSDB_SLOW_QUERY_SQL_LEN 512
 #define TSDB_SHOW_SUBQUERY_LEN  1000
 
@@ -410,6 +412,8 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_FIELD_LEN             65519               // 16384: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_GEOMETRY_LEN          TSDB_MAX_FIELD_LEN  // 16384-8:65519
+
 #define PRIMARYKEY_TIMESTAMP_COL_ID    1
 #define COL_REACH_END(colId, maxColId) ((colId) > (maxColId))
 

include/util/tgeosctx.h

+/*
+ * 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_UTIL_GEOS_CTX_H_
+#define _TD_UTIL_GEOS_CTX_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <geos_c.h>
+
+typedef struct SGeosContext {
+  GEOSContextHandle_t handle;
+
+  GEOSWKTReader *WKTReader;
+  GEOSWKTWriter *WKTWriter;
+
+  GEOSWKBReader *WKBReader;
+  GEOSWKBWriter *WKBWriter;
+
+  char errMsg[512];
+} SGeosContext;
+
+SGeosContext* getThreadLocalGeosCtx();
+void destroyThreadLocalGeosCtx();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_UTIL_GEOS_CTX_H_*/

packaging/docker/dockerbuild.sh

@@ -123,6 +123,16 @@ else
     echo "Unknown cpuType: ${cpuType}"
     exit 1
 fi
+# check the tdengine cloud base image existed or not
+if [ "$cloudBuild" == "y" ]; then
+  CloudBase=$(docker images | grep tdengine/tdengine-cloud-base ||:)
+  if [[ "$CloudBase" == "" ]]; then
+    echo "Rebuild tdengine cloud base image..."
+    docker build --rm -f "${communityDir}/packaging/docker/DockerfileCloud.base" -t tdengine/tdengine-cloud-base "." --build-arg cpuType=${cpuTypeAlias}
+  else
+    echo "Already found tdengine cloud base image"
+  fi
+fi
 
 docker build --rm -f "${Dockerfile}"  --network=host -t tdengine/tdengine-${dockername}:${version} "." --build-arg pkgFile=${pkgFile} --build-arg dirName=${dirName} --build-arg cpuType=${cpuTypeAlias}
 if [ "$cloudBuild" != "y" ]; then

packaging/tools/makeclient.sh

@@ -175,7 +175,7 @@ if [ "$pagMode" == "lite" ]; then
 fi
 chmod a+x ${install_dir}/install_client.sh
 
-if [[ $productName == "TDengine" ]]; then
+if [[ $productName == "TDengine" ]] && [ "$verMode" != "cloud" ]; then
   # Copy example code
   mkdir -p ${install_dir}/examples
   examples_dir="${top_dir}/examples"
@@ -191,7 +191,7 @@ if [[ $productName == "TDengine" ]]; then
     mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../tools/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
   fi
 
-  if [ "$verMode" == "cluster" ] || [ "$verMode" == "cloud" ]; then
+  if [ "$verMode" == "cluster" ]; then
       # Copy connector
       connector_dir="${code_dir}/connector"
       mkdir -p ${install_dir}/connector

packaging/tools/makepkg.sh

@@ -69,25 +69,29 @@ if [ "$pagMode" == "lite" ]; then
   bin_files="${build_dir}/bin/${serverName} ${build_dir}/bin/${clientName} ${script_dir}/remove.sh ${script_dir}/startPre.sh ${build_dir}/bin/taosBenchmark "
   taostools_bin_files=""
 else
-
-  wget https://github.com/taosdata/grafanaplugin/releases/latest/download/TDinsight.sh -O ${build_dir}/bin/TDinsight.sh \
+  if [ "$verMode" == "cloud" ]; then
+    taostools_bin_files=" ${build_dir}/bin/taosBenchmark"
+  else
+    wget https://github.com/taosdata/grafanaplugin/releases/latest/download/TDinsight.sh -O ${build_dir}/bin/TDinsight.sh \
       && echo "TDinsight.sh downloaded!" \
       || echo "failed to download TDinsight.sh"
-  # download TDinsight caches
-  orig_pwd=$(pwd)
-  tdinsight_caches=""
-  cd ${build_dir}/bin/ && \
-    chmod +x TDinsight.sh
-  ./TDinsight.sh --download-only ||:
-#  tdinsight_caches=$(./TDinsight.sh --download-only | xargs -I printf "${build_dir}/bin/{} ")
-  cd $orig_pwd
-  echo "TDinsight caches: $tdinsight_caches"
-
-  taostools_bin_files=" ${build_dir}/bin/taosdump \
+    # download TDinsight caches
+    orig_pwd=$(pwd)
+    tdinsight_caches=""
+    cd ${build_dir}/bin/ && \
+      chmod +x TDinsight.sh
+    ./TDinsight.sh --download-only ||:
+    #  tdinsight_caches=$(./TDinsight.sh --download-only | xargs -I printf "${build_dir}/bin/{} ")
+    cd $orig_pwd
+    echo "TDinsight caches: $tdinsight_caches"
+
+    taostools_bin_files=" ${build_dir}/bin/taosdump \
       ${build_dir}/bin/taosBenchmark \
       ${build_dir}/bin/TDinsight.sh \
       ${build_dir}/bin/tdengine-datasource.zip \
       ${build_dir}/bin/tdengine-datasource.zip.md5sum"
+  fi
+
   [ -f ${build_dir}/bin/taosx ] && taosx_bin="${build_dir}/bin/taosx"
   explorer_bin_files=$(find ${build_dir}/bin/ -name '*-explorer')
 
@@ -334,14 +338,14 @@ mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo
 [ -f ${wslib_files} ] && cp ${wslib_files} ${install_dir}/driver || :
 
 # Copy connector
-if [ "$verMode" == "cluster" ] || [ "$verMode" == "cloud" ]; then
+if [ "$verMode" == "cluster" ]; then
     connector_dir="${code_dir}/connector"
     mkdir -p ${install_dir}/connector
     if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
         tmp_pwd=`pwd`
     	  cd ${install_dir}/connector
     	  if [ ! -d taos-connector-jdbc ];then
-          	git clone -b 3.1.0 --depth=1 https://github.com/taosdata/taos-connector-jdbc.git ||:
+          	git clone -b 3.2.1 --depth=1 https://github.com/taosdata/taos-connector-jdbc.git ||:
     	  fi
     	  cd taos-connector-jdbc
     	  mvn clean package -Dmaven.test.skip=true
@@ -424,7 +428,7 @@ if [ "$exitcode" != "0" ]; then
   exit $exitcode
 fi
 
-if [ -n "${taostools_bin_files}" ]; then
+if [ -n "${taostools_bin_files}" ] && [ "$verMode" != "cloud" ]; then
     wget https://github.com/taosdata/grafanaplugin/releases/latest/download/TDinsight.sh -O ${taostools_install_dir}/bin/TDinsight.sh && echo "TDinsight.sh downloaded!"|| echo "failed to download TDinsight.sh"
     if [ "$osType" != "Darwin" ]; then
         tar -zcv -f "$(basename ${taostools_pkg_name}).tar.gz" "$(basename ${taostools_install_dir})" --remove-files || :

source/client/inc/clientSml.h

@@ -232,9 +232,9 @@ int           smlJsonParseObjFirst(char **start, SSmlLineInfo *element, int8_t *
 int           smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset);
 //SArray       *smlJsonParseTags(char *start, char *end);
 bool          smlParseNumberOld(SSmlKv *kvVal, SSmlMsgBuf *msg);
-void*         nodeListGet(NodeList* list, const void *key, int32_t len, _equal_fn_sml fn);
-int           nodeListSet(NodeList** list, const void *key, int32_t len, void* value, _equal_fn_sml fn);
-int           nodeListSize(NodeList* list);
+//void*         nodeListGet(NodeList* list, const void *key, int32_t len, _equal_fn_sml fn);
+//int           nodeListSet(NodeList** list, const void *key, int32_t len, void* value, _equal_fn_sml fn);
+//int           nodeListSize(NodeList* list);
 bool          smlDoubleToInt64OverFlow(double num);
 int32_t       smlBuildInvalidDataMsg(SSmlMsgBuf *pBuf, const char *msg1, const char *msg2);
 bool          smlParseNumber(SSmlKv *kvVal, SSmlMsgBuf *msg);
@@ -251,7 +251,7 @@ int32_t           smlClearForRerun(SSmlHandle *info);
 int32_t           smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg);
 uint8_t           smlGetTimestampLen(int64_t num);
 void              clearColValArray(SArray* pCols);
-void              smlDestroyTableInfo(SSmlHandle *info, SSmlTableInfo *tag);
+void              smlDestroyTableInfo(void *para);
 
 void freeSSmlKv(void* data);
 int32_t smlParseInfluxString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLineInfo *elements);

source/client/jni/com_taosdata_jdbc_tmq_TMQConnector.h

@@ -158,6 +158,13 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetVgroupId(JN
  */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTableName(JNIEnv *, jobject, jlong);
 
+/*
+ * Class:     com_taosdata_jdbc_tmq_TMQConnector
+ * Method:    tmqGetOffset
+ * Signature: (J)Ljava/lang/String;
+ */
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetOffset(JNIEnv *, jobject, jlong);
+
 /*
  * Class:     com_taosdata_jdbc_tmq_TMQConnector
  * Method:    fetchBlockImp
@@ -166,6 +173,12 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTableNam
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(JNIEnv *, jobject, jlong, jlong,
                                                                                 jobject, jobject);
 
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqSeekImp(JNIEnv *, jobject, jlong, jstring, jint,
+                                                                          jlong);
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTopicAssignmentImp(JNIEnv *, jobject, jlong,
+                                                                                        jstring, jobject);
+
 #ifdef __cplusplus
 }
 #endif

source/client/src/clientImpl.c

@@ -491,7 +491,8 @@ 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) {
+    if (pSchema[i].type == TSDB_DATA_TYPE_VARCHAR ||
+        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;
@@ -1756,6 +1757,7 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int
     return TSDB_CODE_TSC_INTERNAL_ERROR;
   }
 
+  taosMemoryFreeClear(pResultInfo->convertJson);
   pResultInfo->convertJson = taosMemoryCalloc(1, dataLen);
   if (pResultInfo->convertJson == NULL) return TSDB_CODE_OUT_OF_MEMORY;
   char* p1 = pResultInfo->convertJson;

source/client/src/clientJniConnector.c

@@ -579,7 +579,8 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
         dv = GET_DOUBLE_VAL(row[i]);
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetDoubleFp, i, (jdouble)dv);
       } break;
-      case TSDB_DATA_TYPE_BINARY: {
+      case TSDB_DATA_TYPE_BINARY:
+      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

@@ -393,9 +393,10 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
       } break;
 
       case TSDB_DATA_TYPE_BINARY:
-      case TSDB_DATA_TYPE_NCHAR: {
+      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) {
+        if (fields[i].type == TSDB_DATA_TYPE_BINARY || 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);
           }
@@ -475,6 +476,8 @@ const char *taos_data_type(int type) {
       return "TSDB_DATA_TYPE_NCHAR";
     case TSDB_DATA_TYPE_JSON:
       return "TSDB_DATA_TYPE_JSON";
+    case TSDB_DATA_TYPE_GEOMETRY:
+      return "TSDB_DATA_TYPE_GEOMETRY";
     case TSDB_DATA_TYPE_UTINYINT:
       return "TSDB_DATA_TYPE_UTINYINT";
     case TSDB_DATA_TYPE_USMALLINT:

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) {
+    if (s->type == TSDB_DATA_TYPE_BINARY || 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) {
+    if (s->type == TSDB_DATA_TYPE_BINARY || 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) {
+      if (field->type == TSDB_DATA_TYPE_BINARY || 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) {
+      if (field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = field->bytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
@@ -457,7 +457,7 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
       cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
       cJSON_AddItemToObject(json, "colType", colType);
 
-      if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY) {
+      if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY || 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 +478,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) {
+      if (vAlterTbReq.colModType == TSDB_DATA_TYPE_BINARY || vAlterTbReq.colModType == TSDB_DATA_TYPE_GEOMETRY) {
         int32_t length = vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE;
         cJSON*  cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);

source/client/src/clientSml.c

@@ -24,72 +24,91 @@ int64_t smlToMilli[3] = {3600000LL, 60000LL, 1000LL};
 int64_t smlFactorNS[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
 int64_t smlFactorS[3] = {1000LL, 1000000LL, 1000000000LL};
 
-void *nodeListGet(NodeList *list, const void *key, int32_t len, _equal_fn_sml fn) {
-  NodeList *tmp = list;
-  while (tmp) {
-    if (fn == NULL) {
-      if (tmp->data.used && tmp->data.keyLen == len && memcmp(tmp->data.key, key, len) == 0) {
-        return tmp->data.value;
-      }
-    } else {
-      if (tmp->data.used && fn(tmp->data.key, key) == 0) {
-        return tmp->data.value;
-      }
-    }
-
-    tmp = tmp->next;
+//void *nodeListGet(NodeList *list, const void *key, int32_t len, _equal_fn_sml fn) {
+//  NodeList *tmp = list;
+//  while (tmp) {
+//    if (fn == NULL) {
+//      if (tmp->data.used && tmp->data.keyLen == len && memcmp(tmp->data.key, key, len) == 0) {
+//        return tmp->data.value;
+//      }
+//    } else {
+//      if (tmp->data.used && fn(tmp->data.key, key) == 0) {
+//        return tmp->data.value;
+//      }
+//    }
+//
+//    tmp = tmp->next;
+//  }
+//  return NULL;
+//}
+//
+//int nodeListSet(NodeList **list, const void *key, int32_t len, void *value, _equal_fn_sml fn) {
+//  NodeList *tmp = *list;
+//  while (tmp) {
+//    if (!tmp->data.used) break;
+//    if (fn == NULL) {
+//      if (tmp->data.keyLen == len && memcmp(tmp->data.key, key, len) == 0) {
+//        return -1;
+//      }
+//    } else {
+//      if (tmp->data.keyLen == len && fn(tmp->data.key, key) == 0) {
+//        return -1;
+//      }
+//    }
+//
+//    tmp = tmp->next;
+//  }
+//  if (tmp) {
+//    tmp->data.key = key;
+//    tmp->data.keyLen = len;
+//    tmp->data.value = value;
+//    tmp->data.used = true;
+//  } else {
+//    NodeList *newNode = (NodeList *)taosMemoryCalloc(1, sizeof(NodeList));
+//    if (newNode == NULL) {
+//      return -1;
+//    }
+//    newNode->data.key = key;
+//    newNode->data.keyLen = len;
+//    newNode->data.value = value;
+//    newNode->data.used = true;
+//    newNode->next = *list;
+//    *list = newNode;
+//  }
+//  return 0;
+//}
+//
+//int nodeListSize(NodeList *list) {
+//  int cnt = 0;
+//  while (list) {
+//    if (list->data.used)
+//      cnt++;
+//    else
+//      break;
+//    list = list->next;
+//  }
+//  return cnt;
+//}
+
+static int32_t smlCheckAuth(SSmlHandle *info,  SRequestConnInfo* conn, const char* pTabName, AUTH_TYPE type){
+  SUserAuthInfo pAuth = {0};
+  snprintf(pAuth.user, sizeof(pAuth.user), "%s", info->taos->user);
+  if (NULL == pTabName) {
+    tNameSetDbName(&pAuth.tbName, info->taos->acctId, info->pRequest->pDb, strlen(info->pRequest->pDb));
+  } else {
+    toName(info->taos->acctId, info->pRequest->pDb, pTabName, &pAuth.tbName);
   }
-  return NULL;
-}
+  pAuth.type = type;
 
-int nodeListSet(NodeList **list, const void *key, int32_t len, void *value, _equal_fn_sml fn) {
-  NodeList *tmp = *list;
-  while (tmp) {
-    if (!tmp->data.used) break;
-    if (fn == NULL) {
-      if (tmp->data.keyLen == len && memcmp(tmp->data.key, key, len) == 0) {
-        return -1;
-      }
-    } else {
-      if (tmp->data.keyLen == len && fn(tmp->data.key, key) == 0) {
-        return -1;
-      }
-    }
+  int32_t      code = TSDB_CODE_SUCCESS;
+  SUserAuthRes authRes = {0};
 
-    tmp = tmp->next;
-  }
-  if (tmp) {
-    tmp->data.key = key;
-    tmp->data.keyLen = len;
-    tmp->data.value = value;
-    tmp->data.used = true;
-  } else {
-    NodeList *newNode = (NodeList *)taosMemoryCalloc(1, sizeof(NodeList));
-    if (newNode == NULL) {
-      return -1;
-    }
-    newNode->data.key = key;
-    newNode->data.keyLen = len;
-    newNode->data.value = value;
-    newNode->data.used = true;
-    newNode->next = *list;
-    *list = newNode;
-  }
-  return 0;
-}
+  code = catalogChkAuth(info->pCatalog, conn, &pAuth, &authRes);
 
-int nodeListSize(NodeList *list) {
-  int cnt = 0;
-  while (list) {
-    if (list->data.used)
-      cnt++;
-    else
-      break;
-    list = list->next;
-  }
-  return cnt;
-}
 
+  return (code == TSDB_CODE_SUCCESS) ? (authRes.pass ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED) : code;
+
+}
 inline bool smlDoubleToInt64OverFlow(double num) {
   if (num >= (double)INT64_MAX || num <= (double)INT64_MIN) return true;
   return false;
@@ -211,6 +230,16 @@ void getTableUid(SSmlHandle *info, SSmlLineInfo *currElement, SSmlTableInfo *tin
   }
 }
 
+static void smlDestroySTableMeta(void *para) {
+  SSmlSTableMeta *meta = *(SSmlSTableMeta**)para;
+  taosHashCleanup(meta->tagHash);
+  taosHashCleanup(meta->colHash);
+  taosArrayDestroy(meta->tags);
+  taosArrayDestroy(meta->cols);
+  taosMemoryFreeClear(meta->tableMeta);
+  taosMemoryFree(meta);
+}
+
 SSmlSTableMeta *smlBuildSTableMeta(bool isDataFormat) {
   SSmlSTableMeta *meta = (SSmlSTableMeta *)taosMemoryCalloc(sizeof(SSmlSTableMeta), 1);
   if (!meta) {
@@ -245,7 +274,7 @@ SSmlSTableMeta *smlBuildSTableMeta(bool isDataFormat) {
   return meta;
 
 cleanup:
-  taosMemoryFree(meta);
+  smlDestroySTableMeta(meta);
   return NULL;
 }
 
@@ -555,7 +584,7 @@ static int32_t smlGenerateSchemaAction(SSchema *colField, SHashObj *colHash, SSm
       return TSDB_CODE_SML_INVALID_DATA;
     }
 
-    if ((colField[*index].type == TSDB_DATA_TYPE_VARCHAR &&
+    if (((colField[*index].type == TSDB_DATA_TYPE_VARCHAR || 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))) {
@@ -586,7 +615,7 @@ static int32_t smlFindNearestPowerOf2(int32_t length, uint8_t type) {
     }
   }
 
-  if (type == TSDB_DATA_TYPE_BINARY && result > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
+  if ((type == TSDB_DATA_TYPE_BINARY || 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;
@@ -594,7 +623,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) {
+  } else if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
     result = result + VARSTR_HEADER_SIZE;
   }
   return result;
@@ -638,7 +667,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) {
+  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_GEOMETRY) {
     return smlFindNearestPowerOf2(length, type);
   } else {
     return tDataTypes[type].bytes;
@@ -813,6 +842,10 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
     code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
 
     if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST || code == TSDB_CODE_MND_STB_NOT_EXIST) {
+      code = smlCheckAuth(info, &conn, NULL, AUTH_TYPE_WRITE);
+      if(code != TSDB_CODE_SUCCESS){
+        goto end;
+      }
       uDebug("SML:0x%" PRIx64 " smlModifyDBSchemas create table:%s", info->id, pName.tname);
       SArray *pColumns = taosArrayInit(taosArrayGetSize(sTableData->cols), sizeof(SField));
       SArray *pTags = taosArrayInit(taosArrayGetSize(sTableData->tags), sizeof(SField));
@@ -857,6 +890,10 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
         goto end;
       }
       if (action != SCHEMA_ACTION_NULL) {
+        code = smlCheckAuth(info, &conn, pName.tname, AUTH_TYPE_WRITE);
+        if(code != TSDB_CODE_SUCCESS){
+          goto end;
+        }
         uDebug("SML:0x%" PRIx64 " smlModifyDBSchemas change table tag, table:%s, action:%d", info->id, pName.tname,
                action);
         SArray *pColumns =
@@ -927,6 +964,10 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
         goto end;
       }
       if (action != SCHEMA_ACTION_NULL) {
+        code = smlCheckAuth(info, &conn, pName.tname, AUTH_TYPE_WRITE);
+        if(code != TSDB_CODE_SUCCESS){
+          goto end;
+        }
         uDebug("SML:0x%" PRIx64 " smlModifyDBSchemas change table col, table:%s, action:%d", info->id, pName.tname,
                action);
         SArray *pColumns =
@@ -1004,6 +1045,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
       }
     }
 
+    taosMemoryFreeClear(sTableData->tableMeta);
     sTableData->tableMeta = pTableMeta;
     uDebug("SML:0x%" PRIx64 "modify schema uid:%" PRIu64 ", sversion:%d, tversion:%d", info->id, pTableMeta->uid,
            pTableMeta->sversion, pTableMeta->tversion) tmp = (SSmlSTableMeta **)taosHashIterate(info->superTables, tmp);
@@ -1062,15 +1104,6 @@ static void smlInsertMeta(SHashObj *metaHash, SArray *metaArray, SArray *cols) {
   }
 }
 
-static void smlDestroySTableMeta(SSmlSTableMeta *meta) {
-  taosHashCleanup(meta->tagHash);
-  taosHashCleanup(meta->colHash);
-  taosArrayDestroy(meta->tags);
-  taosArrayDestroy(meta->cols);
-  taosMemoryFree(meta->tableMeta);
-  taosMemoryFree(meta);
-}
-
 static int32_t smlUpdateMeta(SHashObj *metaHash, SArray *metaArray, SArray *cols, bool isTag, SSmlMsgBuf *msg) {
   for (int i = 0; i < taosArrayGetSize(cols); ++i) {
     SSmlKv *kv = (SSmlKv *)taosArrayGet(cols, i);
@@ -1110,7 +1143,8 @@ static int32_t smlUpdateMeta(SHashObj *metaHash, SArray *metaArray, SArray *cols
   return TSDB_CODE_SUCCESS;
 }
 
-void smlDestroyTableInfo(SSmlHandle *info, SSmlTableInfo *tag) {
+void smlDestroyTableInfo(void *para) {
+  SSmlTableInfo *tag = *(SSmlTableInfo**)para;
   for (size_t i = 0; i < taosArrayGetSize(tag->cols); i++) {
     SHashObj *kvHash = (SHashObj *)taosArrayGetP(tag->cols, i);
     taosHashCleanup(kvHash);
@@ -1147,18 +1181,18 @@ void smlDestroyInfo(SSmlHandle *info) {
   qDestroyQuery(info->pQuery);
 
   // destroy info->childTables
-  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
-  while (oneTable) {
-    smlDestroyTableInfo(info, *oneTable);
-    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
-  }
+//  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
+//  while (oneTable) {
+//    smlDestroyTableInfo(oneTable);
+//    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
+//  }
 
   // destroy info->superTables
-  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
-  while (oneSTable) {
-    smlDestroySTableMeta(*oneSTable);
-    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
-  }
+//  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
+//  while (oneSTable) {
+//    smlDestroySTableMeta(*oneSTable);
+//    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
+//  }
 
   // destroy info->pVgHash
   taosHashCleanup(info->pVgHash);
@@ -1217,6 +1251,8 @@ SSmlHandle *smlBuildSmlInfo(TAOS *taos) {
   info->childTables = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   info->tableUids = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   info->superTables = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  taosHashSetFreeFp(info->superTables, smlDestroySTableMeta);
+  taosHashSetFreeFp(info->childTables, smlDestroyTableInfo);
 
   info->id = smlGenId();
   info->pQuery = smlInitHandle();
@@ -1323,6 +1359,9 @@ static int32_t smlParseLineBottom(SSmlHandle *info) {
       uDebug("SML:0x%" PRIx64 " smlParseLineBottom add meta, format:%d, linenum:%d", info->id, info->dataFormat,
              info->lineNum);
       SSmlSTableMeta *meta = smlBuildSTableMeta(info->dataFormat);
+      if(meta == NULL){
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
       taosHashPut(info->superTables, elements->measure, elements->measureLen, &meta, POINTER_BYTES);
       terrno = 0;
       smlInsertMeta(meta->tagHash, meta->tags, tinfo->tags);
@@ -1367,6 +1406,11 @@ static int32_t smlInsertData(SSmlHandle *info) {
     conn.requestObjRefId = info->pRequest->self;
     conn.mgmtEps = getEpSet_s(&info->taos->pAppInfo->mgmtEp);
 
+    code = smlCheckAuth(info, &conn, pName.tname, AUTH_TYPE_WRITE);
+    if(code != TSDB_CODE_SUCCESS){
+      return code;
+    }
+
     SVgroupInfo vg;
     code = catalogGetTableHashVgroup(info->pCatalog, &conn, &pName, &vg);
     if (code != TSDB_CODE_SUCCESS) {
@@ -1437,18 +1481,18 @@ static void smlPrintStatisticInfo(SSmlHandle *info) {
 int32_t smlClearForRerun(SSmlHandle *info) {
   info->reRun = false;
   // clear info->childTables
-  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
-  while (oneTable) {
-    smlDestroyTableInfo(info, *oneTable);
-    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
-  }
+//  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
+//  while (oneTable) {
+//    smlDestroyTableInfo(info, *oneTable);
+//    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
+//  }
 
   // clear info->superTables
-  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
-  while (oneSTable) {
-    smlDestroySTableMeta(*oneSTable);
-    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
-  }
+//  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
+//  while (oneSTable) {
+//    smlDestroySTableMeta(*oneSTable);
+//    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
+//  }
 
   taosHashClear(info->childTables);
   taosHashClear(info->superTables);
@@ -1586,9 +1630,7 @@ static int smlProcess(SSmlHandle *info, char *lines[], char *rawLine, char *rawL
 
   do {
     code = smlModifyDBSchemas(info);
-    if (code == 0 || code == TSDB_CODE_SML_INVALID_DATA || code == TSDB_CODE_PAR_TOO_MANY_COLUMNS
-        || code == TSDB_CODE_PAR_INVALID_TAGS_NUM || code == TSDB_CODE_PAR_INVALID_TAGS_LENGTH
-        || code == TSDB_CODE_PAR_INVALID_ROW_LENGTH || code == TSDB_CODE_MND_FIELD_VALUE_OVERFLOW) {
+    if (code != TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER && code != TSDB_CODE_SDB_OBJ_CREATING && code != TSDB_CODE_MND_TRANS_CONFLICT) {
       break;
     }
     taosMsleep(100);

source/client/src/clientSmlJson.c

@@ -695,6 +695,10 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
           return TSDB_CODE_SUCCESS;
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
+        if(sMeta == NULL){
+          taosMemoryFreeClear(pTableMeta);
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
         sMeta->tableMeta = pTableMeta;
         taosHashPut(info->superTables, elements->measure, elements->measureLen, &sMeta, POINTER_BYTES);
         for(int i = pTableMeta->tableInfo.numOfColumns; i < pTableMeta->tableInfo.numOfTags + pTableMeta->tableInfo.numOfColumns; i++){
@@ -784,7 +788,7 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
       tinfo->tableDataCtx = smlInitTableDataCtx(info->pQuery, info->currSTableMeta);
       if (tinfo->tableDataCtx == NULL) {
         smlBuildInvalidDataMsg(&info->msgBuf, "smlInitTableDataCtx error", NULL);
-        smlDestroyTableInfo(info, tinfo);
+        smlDestroyTableInfo(&tinfo);
         return TSDB_CODE_SML_INVALID_DATA;
       }
     }
@@ -1048,12 +1052,18 @@ static int32_t smlParseJSONExt(SSmlHandle *info, char *payload) {
     return TSDB_CODE_TSC_INVALID_JSON;
   }
 
-  info->lineNum = payloadNum;
-  info->dataFormat = true;
+
   if (unlikely(info->lines != NULL)) {
+    for (int i = 0; i < info->lineNum; i++) {
+      taosArrayDestroyEx(info->lines[i].colArray, freeSSmlKv);
+      if (info->lines[i].measureTagsLen != 0) taosMemoryFree(info->lines[i].measureTag);
+    }
     taosMemoryFree(info->lines);
     info->lines = NULL;
   }
+  info->lineNum = payloadNum;
+  info->dataFormat = true;
+
   ret = smlClearForRerun(info);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;

source/client/src/clientSmlLine.c

@@ -168,6 +168,10 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
           return TSDB_CODE_SUCCESS;
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
+        if(sMeta == NULL){
+          taosMemoryFreeClear(pTableMeta);
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
         sMeta->tableMeta = pTableMeta;
         taosHashPut(info->superTables, currElement->measure, currElement->measureLen, &sMeta, POINTER_BYTES);
         for (int i = pTableMeta->tableInfo.numOfColumns;
@@ -326,7 +330,7 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
     info->currSTableMeta->uid = tinfo->uid;
     tinfo->tableDataCtx = smlInitTableDataCtx(info->pQuery, info->currSTableMeta);
     if (tinfo->tableDataCtx == NULL) {
-      smlDestroyTableInfo(info, tinfo);
+      smlDestroyTableInfo(&tinfo);
       smlBuildInvalidDataMsg(&info->msgBuf, "smlInitTableDataCtx error", NULL);
       return TSDB_CODE_SML_INVALID_DATA;
     }
@@ -372,6 +376,10 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
           return TSDB_CODE_SUCCESS;
         }
         *tmp = smlBuildSTableMeta(info->dataFormat);
+        if(*tmp == NULL){
+          taosMemoryFreeClear(pTableMeta);
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
         (*tmp)->tableMeta = pTableMeta;
         taosHashPut(info->superTables, currElement->measure, currElement->measureLen, tmp, POINTER_BYTES);
 

source/client/src/clientSmlTelnet.c

@@ -91,6 +91,10 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
           return TSDB_CODE_SUCCESS;
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
+        if(sMeta == NULL){
+          taosMemoryFreeClear(pTableMeta);
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
         sMeta->tableMeta = pTableMeta;
         taosHashPut(info->superTables, elements->measure, elements->measureLen, &sMeta, POINTER_BYTES);
         for(int i = pTableMeta->tableInfo.numOfColumns; i < pTableMeta->tableInfo.numOfTags + pTableMeta->tableInfo.numOfColumns; i++){
@@ -212,7 +216,7 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
       tinfo->tableDataCtx = smlInitTableDataCtx(info->pQuery, info->currSTableMeta);
       if (tinfo->tableDataCtx == NULL) {
         smlBuildInvalidDataMsg(&info->msgBuf, "smlInitTableDataCtx error", NULL);
-        smlDestroyTableInfo(info, tinfo);
+        smlDestroyTableInfo(&tinfo);
         return TSDB_CODE_SML_INVALID_DATA;
       }
     }

source/client/src/clientTmqConnector.c

@@ -17,9 +17,16 @@
 #include "jniCommon.h"
 #include "taos.h"
 
-int __init_tmq = 0;
+int       __init_tmq = 0;
 jmethodID g_offsetCallback;
 
+jclass    g_assignmentClass;
+jmethodID g_assignmentConstructor;
+jmethodID g_assignmentSetVgId;
+jmethodID g_assignmentSetCurrentOffset;
+jmethodID g_assignmentSetBegin;
+jmethodID g_assignmentSetEnd;
+
 void tmqGlobalMethod(JNIEnv *env) {
   // make sure init function executed once
   switch (atomic_val_compare_exchange_32(&__init_tmq, 0, 1)) {
@@ -46,6 +53,38 @@ void tmqGlobalMethod(JNIEnv *env) {
   jniDebug("tmq method register finished");
 }
 
+int  __init_assignment = 0;
+void tmqAssignmentMethod(JNIEnv *env) {
+  // make sure init function executed once
+  switch (atomic_val_compare_exchange_32(&__init_assignment, 0, 1)) {
+    case 0:
+      break;
+    case 1:
+      do {
+        taosMsleep(0);
+      } while (atomic_load_32(&__init_assignment) == 1);
+    case 2:
+      return;
+  }
+
+  if (g_vm == NULL) {
+    (*env)->GetJavaVM(env, &g_vm);
+  }
+
+  jclass assignment = (*env)->FindClass(env, "com/taosdata/jdbc/tmq/Assignment");
+  g_assignmentClass = (*env)->NewGlobalRef(env, assignment);
+  g_assignmentConstructor = (*env)->GetMethodID(env, g_assignmentClass, "<init>", "()V");
+  g_assignmentSetVgId = (*env)->GetMethodID(env, g_assignmentClass, "setVgId", "(I)V");                    // int
+  g_assignmentSetCurrentOffset = (*env)->GetMethodID(env, g_assignmentClass, "setCurrentOffset", "(J)V");  // long
+  g_assignmentSetBegin = (*env)->GetMethodID(env, g_assignmentClass, "setBegin", "(J)V");                  // long
+  g_assignmentSetEnd = (*env)->GetMethodID(env, g_assignmentClass, "setEnd", "(J)V");                      // long
+
+  (*env)->DeleteLocalRef(env, assignment);
+
+  atomic_store_32(&__init_assignment, 2);
+  jniDebug("tmq method assignment finished");
+}
+
 // deprecated
 void commit_cb(tmq_t *tmq, int32_t code, void *param) {
   JNIEnv *env = NULL;
@@ -266,8 +305,9 @@ JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitAsync(JN
   tmq_commit_async(tmq, res, commit_cb, consumer);
 }
 
-JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_consumerCommitAsync(JNIEnv *env, jobject jobj, jlong jtmq,
-                                                                              jlong jres, jobject offset) {
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_consumerCommitAsync(JNIEnv *env, jobject jobj,
+                                                                                   jlong jtmq, jlong jres,
+                                                                                   jobject offset) {
   tmqGlobalMethod(env);
   tmq_t *tmq = (tmq_t *)jtmq;
   if (tmq == NULL) {
@@ -335,7 +375,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetVgroupId(JN
   TAOS_RES *res = (TAOS_RES *)jres;
   if (res == NULL) {
     jniDebug("jobj:%p, invalid res handle", jobj);
-    return -1;
+    return JNI_RESULT_SET_NULL;
   }
   return tmq_get_vgroup_id(res);
 }
@@ -350,6 +390,15 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTableNam
   return (*env)->NewStringUTF(env, tmq_get_table_name(res));
 }
 
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetOffset(JNIEnv *env, jobject jobj, jlong jres) {
+  TAOS_RES *res = (TAOS_RES *)jres;
+  if (res == NULL) {
+    jniDebug("jobj:%p, invalid res handle", jobj);
+    return JNI_RESULT_SET_NULL;
+  }
+  return tmq_get_vgroup_offset(res);
+}
+
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                 jlong res, jobject rowobj,
                                                                                 jobject arrayListObj) {
@@ -369,7 +418,8 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(
       jniDebug("jobj:%p, conn:%p, resultset:%p, no data to retrieve", jobj, tscon, (void *)res);
       return JNI_FETCH_END;
     } else {
-      jniError("jobj:%p, conn:%p, query interrupted, tmq fetch block error code:%d, msg:%s", jobj, tscon, error_code, taos_errstr(tres));
+      jniError("jobj:%p, conn:%p, query interrupted, tmq fetch block error code:%d, msg:%s", jobj, tscon, error_code,
+               taos_errstr(tres));
       return JNI_RESULT_SET_NULL;
     }
   }
@@ -399,3 +449,72 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, jniFromNCharToByteArray(env, (char *)data, len));
   return JNI_SUCCESS;
 }
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqSeekImp(JNIEnv *env, jobject jobj, jlong jtmq,
+                                                                          jstring jtopic, jint partition,
+                                                                          jlong offset) {
+  tmq_t *tmq = (tmq_t *)jtmq;
+  if (tmq == NULL) {
+    jniDebug("jobj:%p, tmq is closed", jobj);
+    return TMQ_CONSUMER_NULL;
+  }
+
+  if (jtopic == NULL) {
+    jniDebug("jobj:%p, topic is null", jobj);
+    return TMQ_TOPIC_NULL;
+  }
+  const char *topicName = (*env)->GetStringUTFChars(env, jtopic, NULL);
+
+  int32_t res = tmq_offset_seek(tmq, topicName, partition, offset);
+
+  if (res != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, tmq seek error, code:%d, msg:%s", jobj, res, tmq_err2str(res));
+  }
+
+  (*env)->ReleaseStringUTFChars(env, jtopic, topicName);
+  return (jint)res;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTopicAssignmentImp(JNIEnv *env, jobject jobj,
+                                                                                        jlong jtmq, jstring jtopic,
+                                                                                        jobject jarrayList) {
+  tmqAssignmentMethod(env);
+  tmq_t *tmq = (tmq_t *)jtmq;
+  if (tmq == NULL) {
+    jniDebug("jobj:%p, tmq is closed", jobj);
+    return TMQ_CONSUMER_NULL;
+  }
+
+  if (jtopic == NULL) {
+    jniDebug("jobj:%p, topic is null", jobj);
+    return TMQ_TOPIC_NULL;
+  }
+
+  const char *topicName = (*env)->GetStringUTFChars(env, jtopic, NULL);
+
+  tmq_topic_assignment *pAssign = NULL;
+  int32_t               numOfAssignment = 0;
+  int32_t               res = tmq_get_topic_assignment(tmq, topicName, &pAssign, &numOfAssignment);
+
+  if (res != TSDB_CODE_SUCCESS) {
+    (*env)->ReleaseStringUTFChars(env, jtopic, topicName);
+    jniError("jobj:%p, tmq get topic assignment error, topic:%s, code:%d, msg:%s", jobj, topicName, res,
+             tmq_err2str(res));
+    tmq_free_assignment(pAssign);
+    return (jint)res;
+  }
+
+  (*env)->ReleaseStringUTFChars(env, jtopic, topicName);
+
+  for (int i = 0; i < numOfAssignment; ++i) {
+    tmq_topic_assignment assignment = pAssign[i];
+    jobject              jassignment = (*env)->NewObject(env, g_assignmentClass, g_assignmentConstructor);
+    (*env)->CallVoidMethod(env, jassignment, g_assignmentSetVgId, assignment.vgId);
+    (*env)->CallVoidMethod(env, jassignment, g_assignmentSetCurrentOffset, assignment.currentOffset);
+    (*env)->CallVoidMethod(env, jassignment, g_assignmentSetBegin, assignment.begin);
+    (*env)->CallVoidMethod(env, jassignment, g_assignmentSetEnd, assignment.end);
+    (*env)->CallBooleanMethod(env, jarrayList, g_arrayListAddFp, jassignment);
+  }
+  tmq_free_assignment(pAssign);
+  return JNI_SUCCESS;
+}

source/client/test/clientTests.cpp

@@ -1100,7 +1100,7 @@ TEST(clientCase, sub_tb_test) {
 
   // 创建订阅 topics 列表
   tmq_list_t* topicList = tmq_list_new();
-  tmq_list_append(topicList, "topic_t1");
+  tmq_list_append(topicList, "t1");
 
   // 启动订阅
   tmq_subscribe(tmq, topicList);
@@ -1118,7 +1118,7 @@ TEST(clientCase, sub_tb_test) {
   tmq_topic_assignment* pAssign = NULL;
   int32_t numOfAssign = 0;
 
-  int32_t code = tmq_get_topic_assignment(tmq, "topic_t1", &pAssign, &numOfAssign);
+  int32_t code = tmq_get_topic_assignment(tmq, "t1", &pAssign, &numOfAssign);
   if (code != 0) {
     printf("error occurs:%s\n", tmq_err2str(code));
     tmq_consumer_close(tmq);
@@ -1127,7 +1127,16 @@ TEST(clientCase, sub_tb_test) {
     return;
   }
 
-  tmq_offset_seek(tmq, "topic_t1", pAssign[0].vgId, 0);
+  tmq_offset_seek(tmq, "t1", pAssign[0].vgId, 4);
+
+  code = tmq_get_topic_assignment(tmq, "t1", &pAssign, &numOfAssign);
+  if (code != 0) {
+    printf("error occurs:%s\n", tmq_err2str(code));
+    tmq_consumer_close(tmq);
+    taos_close(pConn);
+    fprintf(stderr, "%d msg consumed, include %d rows\n", msgCnt, totalRows);
+    return;
+  }
 
   while (1) {
     TAOS_RES* pRes = tmq_consumer_poll(tmq, timeout);

source/common/src/systable.c

@@ -280,7 +280,9 @@ static const SSysDbTableSchema topicSchema[] = {
     {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
     {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
     {.name = "sql", .bytes = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
-    // TODO config
+    {.name = "schema", .bytes = TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
+    {.name = "meta", .bytes = 4 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
+    {.name = "type", .bytes = 8 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY, .sysInfo = false},
 };
 
 

source/common/src/tdatablock.c

@@ -1927,7 +1927,8 @@ void blockDebugShowDataBlocks(const SArray* dataBlocks, const char* flag) {
           case TSDB_DATA_TYPE_DOUBLE:
             printf(" %15lf |", *(double*)var);
             break;
-          case TSDB_DATA_TYPE_VARCHAR: {
+          case TSDB_DATA_TYPE_VARCHAR:
+          case TSDB_DATA_TYPE_GEOMETRY: {
             char*   pData = colDataGetVarData(pColInfoData, j);
             int32_t dataSize = TMIN(sizeof(pBuf) - 1, varDataLen(pData));
             memset(pBuf, 0, dataSize + 1);
@@ -1969,7 +1970,7 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
   if (len >= size - 1) return dumpBuf;
 
   for (int32_t j = 0; j < rows; j++) {
-    len += snprintf(dumpBuf + len, size - len, "%s %d|", flag, j);
+    len += snprintf(dumpBuf + len, size - len, "%s|", flag);
     if (len >= size - 1) return dumpBuf;
 
     for (int32_t k = 0; k < colNum; k++) {
@@ -2032,7 +2033,8 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
           len += snprintf(dumpBuf + len, size - len, " %15d |", *(bool*)var);
           if (len >= size - 1) return dumpBuf;
           break;
-        case TSDB_DATA_TYPE_VARCHAR: {
+        case TSDB_DATA_TYPE_VARCHAR:
+        case TSDB_DATA_TYPE_GEOMETRY: {
           memset(pBuf, 0, sizeof(pBuf));
           char*   pData = colDataGetVarData(pColInfoData, j);
           int32_t dataSize = TMIN(sizeof(pBuf), varDataLen(pData));
@@ -2051,7 +2053,7 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
         } break;
       }
     }
-    len += snprintf(dumpBuf + len, size - len, "\n");
+    len += snprintf(dumpBuf + len, size - len, "%d\n", j);
     if (len >= size - 1) return dumpBuf;
   }
   len += snprintf(dumpBuf + len, size - len, "%s |end\n", flag);
@@ -2138,7 +2140,8 @@ int32_t buildSubmitReqFromDataBlock(SSubmitReq** pReq, const SSDataBlock* pDataB
             }
             break;
           case TSDB_DATA_TYPE_NCHAR:
-          case TSDB_DATA_TYPE_VARCHAR: {  // TSDB_DATA_TYPE_BINARY
+          case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
+          case TSDB_DATA_TYPE_GEOMETRY: {
             if (colDataIsNull_s(pColInfoData, j)) {
               tdAppendColValToRow(&rb, PRIMARYKEY_TIMESTAMP_COL_ID + k, pColInfoData->info.type, TD_VTYPE_NULL, NULL,
                                   false, offset, k);

source/common/src/tmsg.c

@@ -4002,11 +4002,16 @@ int32_t tSerializeSCMCreateTopicReq(void *buf, int32_t bufLen, const SCMCreateTo
   if (tEncodeI8(&encoder, pReq->withMeta) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->subDbName) < 0) return -1;
   if (TOPIC_SUB_TYPE__DB == pReq->subType) {
-  } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
-    if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;
   } else {
-    if (tEncodeI32(&encoder, strlen(pReq->ast)) < 0) return -1;
-    if (tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
+    if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
+      if (tEncodeCStr(&encoder, pReq->subStbName) < 0) return -1;
+    }
+    if (pReq->ast && strlen(pReq->ast) > 0) {
+      if (tEncodeI32(&encoder, strlen(pReq->ast)) < 0) return -1;
+      if (tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
+    } else {
+      if (tEncodeI32(&encoder, 0) < 0) return -1;
+    }
   }
   if (tEncodeI32(&encoder, strlen(pReq->sql)) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
@@ -4032,9 +4037,10 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR
   if (tDecodeI8(&decoder, &pReq->withMeta) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->subDbName) < 0) return -1;
   if (TOPIC_SUB_TYPE__DB == pReq->subType) {
-  } else if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
-    if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;
   } else {
+    if (TOPIC_SUB_TYPE__TABLE == pReq->subType) {
+      if (tDecodeCStrTo(&decoder, pReq->subStbName) < 0) return -1;
+    }
     if (tDecodeI32(&decoder, &astLen) < 0) return -1;
     if (astLen > 0) {
       pReq->ast = taosMemoryCalloc(1, astLen + 1);
@@ -4057,7 +4063,7 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR
 
 void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
   taosMemoryFreeClear(pReq->sql);
-  if (TOPIC_SUB_TYPE__COLUMN == pReq->subType) {
+  if (TOPIC_SUB_TYPE__DB != pReq->subType) {
     taosMemoryFreeClear(pReq->ast);
   }
 }

source/common/src/trow.c

@@ -126,6 +126,9 @@ void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
     case TSDB_DATA_TYPE_JSON:
       printf("JSON ");
       break;
+    case TSDB_DATA_TYPE_GEOMETRY:
+      printf("GEOMETRY ");
+      break;
     case TSDB_DATA_TYPE_VARBINARY:
       printf("VARBIN ");
       break;
@@ -353,7 +356,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
           }
         } else {
           varDataLen += sizeof(VarDataLenT);
-          if (pTColumn->type == TSDB_DATA_TYPE_VARCHAR) {
+          if (pTColumn->type == TSDB_DATA_TYPE_VARCHAR || pTColumn->type == TSDB_DATA_TYPE_GEOMETRY) {
             varDataLen += CHAR_BYTES;
             if (maxVarDataLen < CHAR_BYTES + sizeof(VarDataLenT)) {
               maxVarDataLen = CHAR_BYTES + sizeof(VarDataLenT);

source/dnode/mnode/impl/inc/mndDb.h

@@ -32,6 +32,7 @@ bool    mndIsDbReady(SMnode *pMnode, SDbObj *pDb);
 
 SSdbRaw    *mndDbActionEncode(SDbObj *pDb);
 const char *mndGetDbStr(const char *src);
+const char *mndGetStableStr(const char *src);
 
 int32_t mndProcessCompactDbReq(SRpcMsg *pReq);