Merge branch 'szhou/continue-coing' of github.com:taosdata/TDengine into szhou/continue-coing

Jenkinsfile2

@@ -314,9 +314,9 @@ def pre_test_build_win() {
         cd %WIN_CONNECTOR_ROOT%
         python.exe -m pip install --upgrade pip
         python -m pip uninstall taospy -y 
-        python -m pip install taospy==2.7.10
+        python -m pip install taospy==2.7.12
         python -m pip uninstall taos-ws-py -y 
-        python -m pip install taos-ws-py==0.2.8
+        python -m pip install taos-ws-py==0.2.9
 	xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
     '''
     return 1

cmake/cmake.define

@@ -83,6 +83,16 @@ ELSE ()
     SET(TAOS_LIB taos)
 ENDIF ()
 
+# build TSZ by default
+IF ("${TSZ_ENABLED}" MATCHES "false")
+  set(VAR_TSZ "" CACHE INTERNAL "global variant empty" )
+ELSE()
+  # define add 
+  MESSAGE(STATUS "build with TSZ enabled")
+  ADD_DEFINITIONS(-DTD_TSZ)
+  set(VAR_TSZ "TSZ" CACHE INTERNAL "global variant tsz" )
+ENDIF()
+
 IF (TD_WINDOWS)
     MESSAGE("${Yellow} set compiler flag for Windows! ${ColourReset}")
     SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi /MTd")

cmake/cmake.platform

@@ -195,6 +195,20 @@ if (TD_LINUX)
   ELSE() 
     set(TD_DEPS_DIR "x86")
   ENDIF()
+elseif (TD_DARWIN)
+  IF (TD_ARM_64 OR TD_ARM_32)
+    set(TD_DEPS_DIR "darwin/arm")
+  ELSE ()
+    set(TD_DEPS_DIR "darwin/x64")
+  ENDIF ()
+elseif (TD_WINDOWS)
+  IF (TD_WINDOWS_64)
+    set(TD_DEPS_DIR "win/x64")
+  ELSEIF (TD_WINDOWS_32)
+    set(TD_DEPS_DIR "win/i386")
+  ENDIF ()
+else ()
+    MESSAGE(FATAL_ERROR "unsupported platform")
 endif()
 MESSAGE(STATUS "DEPS_DIR: " ${TD_DEPS_DIR})
 

cmake/curl_CMakeLists.txt.in

@@ -1,6 +1,7 @@
 # curl
 ExternalProject_Add(curl
         URL  https://curl.se/download/curl-8.2.1.tar.gz
+        URL_HASH MD5=b25588a43556068be05e1624e0e74d41
         DOWNLOAD_NO_PROGRESS 1
         DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download"
         #GIT_REPOSITORY https://github.com/curl/curl.git

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

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

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

@@ -142,8 +142,15 @@ TDengine currently supports timestamp, number, character, Boolean type, and the
 | BINARY            | byte array         |
 | NCHAR             | java.lang.String   |
 | JSON              | java.lang.String   |
+| VARBINARY         | byte[]             |
+| GEOMETRY          | byte[]             |
 
 **Note**: Only TAG supports JSON types
+Due to historical reasons, the BINARY type data in TDengine is not truly binary data and is no longer recommended for use. Please use VARBINARY type instead.  
+GEOMETRY type is binary data in little endian byte order, which complies with the WKB specification. For detailed information, please refer to [Data Type] (/tao-sql/data-type/#Data Types)  
+For WKB specifications, please refer to [Well Known Binary (WKB)]（ https://libgeos.org/specifications/wkb/ ）  
+For Java connector, the jts library can be used to easily create GEOMETRY type objects, serialize them, and write them to TDengine. Here is an example [Geometry example]（https://github.com/taosdata/TDengine/blob/3.0/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/GeometryDemo.java）  
+
 
 ## Installation Steps
 
@@ -354,7 +361,7 @@ The configuration parameters in properties are as follows.
 - TSDBDriver.PROPERTY_KEY_CONFIG_DIR: only works when using JDBC native connection. Client configuration file directory path, default value `/etc/taos` on Linux OS, default value `C:/TDengine/cfg` on Windows OS, default value `/etc/taos` on macOS.
 - TSDBDriver.PROPERTY_KEY_CHARSET: In the character set used by the client, the default value is the system character set.
 - TSDBDriver.PROPERTY_KEY_LOCALE: this only takes effect when using JDBC native connection. Client language environment, the default value is system current locale.
-- TSDBDriver.PROPERTY_KEY_TIME_ZONE: only takes effect when using JDBC native connection. In the time zone used by the client, the default value is the system's current time zone.
+- TSDBDriver.PROPERTY_KEY_TIME_ZONE: only takes effect when using JDBC native connection. In the time zone used by the client, the default value is the system's current time zone. Due to historical reasons, we only support some specifications of the POSIX standard, such as UTC-8 (representing timezone Shanghai in China), GMT-7, Europe/Paris.
 - TSDBDriver.HTTP_CONNECT_TIMEOUT: REST connection timeout in milliseconds, the default value is 60000 ms. It only takes effect when using JDBC REST connection.
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket timeout in milliseconds, the default value is 60000 ms. It only takes effect when using JDBC REST connection and batchfetch is false.
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: message transmission timeout in milliseconds, the default value is 60000 ms. It only takes effect when using JDBC REST connection and batchfetch is true.
@@ -456,13 +463,15 @@ public class ParameterBindingDemo {
 
     private static final String host = "127.0.0.1";
     private static final Random random = new Random(System.currentTimeMillis());
-    private static final int BINARY_COLUMN_SIZE = 20;
+    private static final int BINARY_COLUMN_SIZE = 50;
     private static final String[] schemaList = {
             "create table stable1(ts timestamp, f1 tinyint, f2 smallint, f3 int, f4 bigint) tags(t1 tinyint, t2 smallint, t3 int, t4 bigint)",
             "create table stable2(ts timestamp, f1 float, f2 double) tags(t1 float, t2 double)",
             "create table stable3(ts timestamp, f1 bool) tags(t1 bool)",
             "create table stable4(ts timestamp, f1 binary(" + BINARY_COLUMN_SIZE + ")) tags(t1 binary(" + BINARY_COLUMN_SIZE + "))",
-            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))"
+            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable6(ts timestamp, f1 varbinary(" + BINARY_COLUMN_SIZE + ")) tags(t1 varbinary(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable7(ts timestamp, f1 geometry(" + BINARY_COLUMN_SIZE + ")) tags(t1 geometry(" + BINARY_COLUMN_SIZE + "))",
     };
     private static final int numOfSubTable = 10, numOfRow = 10;
 
@@ -474,21 +483,20 @@ public class ParameterBindingDemo {
         init(conn);
 
         bindInteger(conn);
-
         bindFloat(conn);
-
         bindBoolean(conn);
-
         bindBytes(conn);
-
         bindString(conn);
+        bindVarbinary(conn);
+        bindGeometry(conn);
 
+        clean(conn);
         conn.close();
     }
 
     private static void init(Connection conn) throws SQLException {
+        clean(conn);
         try (Statement stmt = conn.createStatement()) {
-            stmt.execute("drop database if exists test_parabind");
             stmt.execute("create database if not exists test_parabind");
             stmt.execute("use test_parabind");
             for (int i = 0; i < schemaList.length; i++) {
@@ -496,6 +504,11 @@ public class ParameterBindingDemo {
             }
         }
     }
+    private static void clean(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists test_parabind");
+        }
+    }
 
     private static void bindInteger(Connection conn) throws SQLException {
         String sql = "insert into ? using stable1 tags(?,?,?,?) values(?,?,?,?,?)";
@@ -674,10 +687,84 @@ public class ParameterBindingDemo {
             pstmt.columnDataExecuteBatch();
         }
     }
+
+    private static void bindVarbinary(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable6 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t6_" + i);
+                // set tags
+                byte[] bTag = new byte[]{0,2,3,4,5};
+                bTag[0] = (byte) i;
+                pstmt.setTagVarbinary(0, bTag);
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    byte[] v = new byte[]{0,2,3,4,5,6};
+                    v[0] = (byte)j;
+                    f1List.add(v);
+                }
+                pstmt.setVarbinary(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindGeometry(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable7 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            byte[] g1 = StringUtils.hexToBytes("0101000000000000000000F03F0000000000000040");
+            byte[] g2 = StringUtils.hexToBytes("0102000020E610000002000000000000000000F03F000000000000004000000000000008400000000000001040");
+            List<byte[]> listGeo = new ArrayList<>();
+            listGeo.add(g1);
+            listGeo.add(g2);
+
+            for (int i = 1; i <= 2; i++) {
+                // set table name
+                pstmt.setTableName("t7_" + i);
+                // set tags
+                pstmt.setTagGeometry(0, listGeo.get(i - 1));
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    f1List.add(listGeo.get(i - 1));
+                }
+                pstmt.setGeometry(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
 }
 ```
 
-**Note**: both setString and setNString require the user to declare the width of the corresponding column in the size parameter of the table definition
+**Note**: both String and byte[] require the user to declare the width of the corresponding column in the size parameter of the table definition
 
 The methods to set VALUES columns:
 
@@ -692,6 +779,8 @@ public void setByte(int columnIndex, ArrayList<Byte> list) throws SQLException
 public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
 public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
+public void setVarbinary(int columnIndex, ArrayList<byte[]> list, int size) throws SQLException
+public void setGeometry(int columnIndex, ArrayList<byte[]> list, int size) throws SQLException
 ```
 
 </TabItem>
@@ -880,6 +969,9 @@ public void setTagFloat(int index, float value)
 public void setTagDouble(int index, double value)
 public void setTagString(int index, String value)
 public void setTagNString(int index, String value)
+public void setTagJson(int index, String value)
+public void setTagVarbinary(int index, byte[] value)
+public void setTagGeometry(int index, byte[] value)
 ```
 
 ### Schemaless Writing

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

@@ -731,16 +731,6 @@ The charset that takes effect is UTF-8.
 | Value Range   | 0: not change; 1: change by modification                                      |
 | Default Value | 0                                                                             |
 
-### keepTimeOffset
-
-| Attribute     | Description               |
-| ------------- | ------------------------- |
-| Applicable    | Server Only               |
-| Meaning       | Latency of data migration |
-| Unit          | hour                      |
-| Value Range   | 0-23                      |
-| Default Value | 0                         |
-
 ### tmqMaxTopicNum
 
 | Attribute     | Description               |
@@ -807,4 +797,4 @@ The charset that takes effect is UTF-8.
 | 53  |          udf           | Yes                    | Yes                          |                         |
 | 54  |     enableCoreFile     | Yes                    | Yes                          |                         |
 | 55  |    ttlChangeOnWrite    | No                     | Yes                          |                         |
-| 56  |     keepTimeOffset     | Yes                    | Yes                          |                         |
+| 56  |     keepTimeOffset     | Yes                    | Yes(discarded since 3.2.0.0) |                         |

docs/examples/java/pom.xml

@@ -22,7 +22,7 @@
     <dependency>
       <groupId>com.taosdata.jdbc</groupId>
       <artifactId>taos-jdbcdriver</artifactId>
-      <version>3.2.4</version>
+      <version>3.2.7-SNAPSHOT</version>
     </dependency>
     <!--    ANCHOR_END: dep-->
     <dependency>

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

@@ -23,22 +23,30 @@ import CDemo from "./_sub_c.mdx";
 
 为了实现上述功能，TDengine 会为 WAL (Write-Ahead-Log) 文件自动创建索引以支持快速随机访问，并提供了灵活可配置的文件切换与保留机制：用户可以按需指定 WAL 文件保留的时间以及大小（详见 create database 语句）。通过以上方式将 WAL 改造成了一个保留事件到达顺序的、可持久化的存储引擎（但由于 TSDB 具有远比 WAL 更高的压缩率，我们不推荐保留太长时间，一般来说，不超过几天）。 对于以 topic 形式创建的查询，TDengine 将对接 WAL 而不是 TSDB 作为其存储引擎。在消费时，TDengine 根据当前消费进度从 WAL 直接读取数据，并使用统一的查询引擎实现过滤、变换等操作，将数据推送给消费者。
 
-本文档不对消息队列本身的基础知识做介绍，如果需要了解，请自行搜索。
+下面为关于数据订阅的一些说明，需要对TDengine的架构有一些了解，结合各个语言链接器的接口使用。
+- 一个消费组消费同一个topic下的所有数据，不同消费组之间相互独立；
+- 一个消费组消费同一个topic所有的vgroup，消费组可由多个消费者组成，但一个vgroup仅被一个消费者消费，如果消费者数量超过了vgroup数量，多余的消费者不消费数据；
+- 在服务端每个vgroup仅保存一个offset，每个vgroup的offset是单调递增的，但不一定连续。各个vgroup的offset之间没有关联；
+- 每次poll服务端会返回一个结果block，该block属于一个vgroup，可能包含多个wal版本的数据，可以通过 offset 接口获得是该block第一条记录的offset；
+- 一个消费组如果从未commit过offset，当其成员消费者重启重新拉取数据时，均从参数auto.offset.reset设定值开始消费；在一个消费者生命周期中，客户端本地记录了最近一次拉取数据的offset，不会拉取重复数据；
+- 消费者如果异常终止（没有调用tmq_close），需等约12秒后触发其所属消费组rebalance，该消费者在服务端状态变为LOST，约1天后该消费者自动被删除；正常退出，退出后就会删除消费者；新增消费者，需等约2秒触发rebalance，该消费者在服务端状态变为ready；
+- 消费组rebalance会对该组所有ready状态的消费者成员重新进行vgroup分配，消费者仅能对自己负责的vgroup进行assignment/seek/commit/poll操作；
+- 消费者可利用 position 获得当前消费的offset，并seek到指定offset，重新消费；
+- seek将position指向指定offset，不执行commit操作，一旦seek成功，可poll拉取指定offset及以后的数据；
+- seek 操作之前须调用 assignment 接口获取该consumer的vgroup ID和offset范围。seek 操作会检测vgroup ID 和 offset是否合法，如非法将报错；
+- position是获取当前的消费位置，是下次要取的位置，不是当前消费到的位置
+- commit是提交消费位置，不带参数的话，是提交当前消费位置（下次要取的位置，不是当前消费到的位置），带参数的话，是提交参数里的位置（也即下次退出重启后要取的位置）
+- seek是设置consumer消费位置，seek到哪，position就返回哪，都是下次要取的位置
+- seek不会影响commit，commit不影响seek，相互独立，两个是不同的概念
+- begin接口为wal 第一条数据的offset，end 接口为wal 最后一条数据的offset + 1
+- offset接口获取的是记录所在结果block块里的第一条数据的offset，当seek至该offset时，将消费到这个block里的全部数据。参见第四点；
+- 由于存在 WAL 过期删除机制，即使seek 操作成功，poll数据时有可能offset已失效。如果poll 的offset 小于 WAL 最小版本号，将会从WAL最小版本号消费；
+- 数据订阅是从 WAL 消费数据，如果一些 WAL 文件被基于 WAL 保留策略删除，则已经删除的 WAL 文件中的数据就无法再消费到。需要根据业务需要在创建数据库时合理设置 `WAL_RETENTION_PERIOD` 或 `WAL_RETENTION_SIZE` ，并确保应用及时消费数据，这样才不会产生数据丢失的现象。数据订阅的行为与 Kafka 等广泛使用的消息队列类产品的行为相似；
 
-说明（以c接口为例）：
-1. 一个消费组消费同一个topic下的所有数据，不同消费组之间相互独立；
-2. 一个消费组消费同一个topic所有的vgroup，消费组可由多个消费者组成，但一个vgroup仅被一个消费者消费，如果消费者数量超过了vgroup数量，多余的消费者不消费数据；
-3. 在服务端每个vgroup仅保存一个offset，每个vgroup的offset是单调递增的，但不一定连续。各个vgroup的offset之间没有关联；
-4. 每次poll服务端会返回一个结果block，该block属于一个vgroup，可能包含多个wal版本的数据，可以通过 tmq_get_vgroup_offset 接口获得是该block第一条记录的offset；
-5. 一个消费组如果从未commit过offset，当其成员消费者重启重新拉取数据时，均从参数auto.offset.reset设定值开始消费；在一个消费者生命周期中，客户端本地记录了最近一次拉取数据的offset，不会拉取重复数据；
-6. 消费者如果异常终止（没有调用tmq_close），需等约12秒后触发其所属消费组rebalance，该消费者在服务端状态变为LOST，约1天后该消费者自动被删除；正常退出，退出后就会删除消费者；新增消费者，需等约2秒触发rebalance，该消费者在服务端状态变为ready；
-7. 消费组rebalance会对该组所有ready状态的消费者成员重新进行vgroup分配，消费者仅能对自己负责的vgroup进行assignment/seek/commit/poll操作；
-8. 消费者可利用 tmq_position 获得当前消费的offset，并seek到指定offset，重新消费；
-9. seek将position指向指定offset，不执行commit操作，一旦seek成功，可poll拉取指定offset及以后的数据；
-10. seek 操作之前须调用 tmq_get_topic_assignment 接口获取该consumer的vgroup ID和offset范围。seek 操作会检测vgroup ID 和 offset是否合法，如非法将报错；
-11. tmq_get_vgroup_offset接口获取的是记录所在结果block块里的第一条数据的offset，当seek至该offset时，将消费到这个block里的全部数据。参见第四点；
-12. 由于存在 WAL 过期删除机制，即使seek 操作成功，poll数据时有可能offset已失效。如果poll 的offset 小于 WAL 最小版本号，将会从WAL最小版本号消费；
-13. 数据订阅是从 WAL 消费数据，如果一些 WAL 文件被基于 WAL 保留策略删除，则已经删除的 WAL 文件中的数据就无法再消费到。需要根据业务需要在创建数据库时合理设置 `WAL_RETENTION_PERIOD` 或 `WAL_RETENTION_SIZE` ，并确保应用及时消费数据，这样才不会产生数据丢失的现象。数据订阅的行为与 Kafka 等广泛使用的消息队列类产品的行为相似；
+本文档不对消息队列本身的知识做更多的介绍，如果需要了解，请自行搜索。
+
+从3.2.0.0版本开始，数据订阅支持vnode迁移和分裂。
+由于数据订阅依赖wal文件，而在vnode迁移和分裂的过程中，wal并不会同步过去，所以迁移或分裂后，之前没消费完的wal数据后消费不到。所以请保证之前把数据全部消费完后，再进行vnode迁移或分裂，否则，消费会丢失数据。
 
 ## 主要数据结构和 API
 

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

@@ -142,8 +142,14 @@ TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对
 | BINARY            | byte array         |
 | NCHAR             | java.lang.String   |
 | JSON              | java.lang.String   |
+| VARBINARY         | byte[]             |
+| GEOMETRY          | byte[]             |
 
-**注意**：JSON 类型仅在 tag 中支持。
+**注意**：JSON 类型仅在 tag 中支持。  
+由于历史原因，TDengine中的BINARY底层不是真正的二进制数据，已不建议使用。请用VARBINARY类型代替。  
+GEOMETRY类型是little endian字节序的二进制数据，符合WKB规范。详细信息请参考 [数据类型](/taos-sql/data-type/#数据类型)  
+WKB规范请参考[Well-Known Binary (WKB)](https://libgeos.org/specifications/wkb/)  
+对于java连接器，可以使用jts库来方便的创建GEOMETRY类型对象，序列化后写入TDengine，这里有一个样例[Geometry示例](https://github.com/taosdata/TDengine/blob/3.0/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/GeometryDemo.java)  
 
 ## 安装步骤
 
@@ -357,7 +363,7 @@ properties 中的配置参数如下：
 - TSDBDriver.PROPERTY_KEY_CONFIG_DIR：仅在使用 JDBC 原生连接时生效。客户端配置文件目录路径，Linux OS 上默认值 `/etc/taos`，Windows OS 上默认值 `C:/TDengine/cfg`。
 - TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
 - TSDBDriver.PROPERTY_KEY_LOCALE：仅在使用 JDBC 原生连接时生效。 客户端语言环境，默认值系统当前 locale。
-- TSDBDriver.PROPERTY_KEY_TIME_ZONE：仅在使用 JDBC 原生连接时生效。 客户端使用的时区，默认值为系统当前时区。
+- TSDBDriver.PROPERTY_KEY_TIME_ZONE：仅在使用 JDBC 原生连接时生效。 客户端使用的时区，默认值为系统当前时区。因为历史的原因，我们只支持POSIX标准的部分规范，如UTC-8(代表中国上上海), GMT-8，Asia/Shanghai 这几种形式。
 - TSDBDriver.HTTP_CONNECT_TIMEOUT: 连接超时时间，单位 ms， 默认值为 60000。仅在 REST 连接时生效。
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket 超时时间，单位 ms，默认值为 60000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: 消息超时时间, 单位 ms， 默认值为 60000。 仅在 REST 连接且 batchfetch 设置为 true 时生效。
@@ -459,13 +465,15 @@ public class ParameterBindingDemo {
 
     private static final String host = "127.0.0.1";
     private static final Random random = new Random(System.currentTimeMillis());
-    private static final int BINARY_COLUMN_SIZE = 30;
+    private static final int BINARY_COLUMN_SIZE = 50;
     private static final String[] schemaList = {
             "create table stable1(ts timestamp, f1 tinyint, f2 smallint, f3 int, f4 bigint) tags(t1 tinyint, t2 smallint, t3 int, t4 bigint)",
             "create table stable2(ts timestamp, f1 float, f2 double) tags(t1 float, t2 double)",
             "create table stable3(ts timestamp, f1 bool) tags(t1 bool)",
             "create table stable4(ts timestamp, f1 binary(" + BINARY_COLUMN_SIZE + ")) tags(t1 binary(" + BINARY_COLUMN_SIZE + "))",
-            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))"
+            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable6(ts timestamp, f1 varbinary(" + BINARY_COLUMN_SIZE + ")) tags(t1 varbinary(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable7(ts timestamp, f1 geometry(" + BINARY_COLUMN_SIZE + ")) tags(t1 geometry(" + BINARY_COLUMN_SIZE + "))",
     };
     private static final int numOfSubTable = 10, numOfRow = 10;
 
@@ -477,21 +485,20 @@ public class ParameterBindingDemo {
         init(conn);
 
         bindInteger(conn);
-
         bindFloat(conn);
-
         bindBoolean(conn);
-
         bindBytes(conn);
-
         bindString(conn);
+        bindVarbinary(conn);
+        bindGeometry(conn);
 
+        clean(conn);
         conn.close();
     }
 
     private static void init(Connection conn) throws SQLException {
+        clean(conn);
         try (Statement stmt = conn.createStatement()) {
-            stmt.execute("drop database if exists test_parabind");
             stmt.execute("create database if not exists test_parabind");
             stmt.execute("use test_parabind");
             for (int i = 0; i < schemaList.length; i++) {
@@ -499,6 +506,11 @@ public class ParameterBindingDemo {
             }
         }
     }
+    private static void clean(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists test_parabind");
+        }
+    }
 
     private static void bindInteger(Connection conn) throws SQLException {
         String sql = "insert into ? using stable1 tags(?,?,?,?) values(?,?,?,?,?)";
@@ -677,10 +689,84 @@ public class ParameterBindingDemo {
             pstmt.columnDataExecuteBatch();
         }
     }
+
+    private static void bindVarbinary(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable6 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t6_" + i);
+                // set tags
+                byte[] bTag = new byte[]{0,2,3,4,5};
+                bTag[0] = (byte) i;
+                pstmt.setTagVarbinary(0, bTag);
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    byte[] v = new byte[]{0,2,3,4,5,6};
+                    v[0] = (byte)j;
+                    f1List.add(v);
+                }
+                pstmt.setVarbinary(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindGeometry(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable7 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            byte[] g1 = StringUtils.hexToBytes("0101000000000000000000F03F0000000000000040");
+            byte[] g2 = StringUtils.hexToBytes("0102000020E610000002000000000000000000F03F000000000000004000000000000008400000000000001040");
+            List<byte[]> listGeo = new ArrayList<>();
+            listGeo.add(g1);
+            listGeo.add(g2);
+
+            for (int i = 1; i <= 2; i++) {
+                // set table name
+                pstmt.setTableName("t7_" + i);
+                // set tags
+                pstmt.setTagGeometry(0, listGeo.get(i - 1));
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    f1List.add(listGeo.get(i - 1));
+                }
+                pstmt.setGeometry(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
 }
 ```
 
-**注**：setString 和 setNString 都要求用户在 size 参数里声明表定义中对应列的列宽
+**注**：字符串和数组类型都要求用户在 size 参数里声明表定义中对应列的列宽。
 
 用于设定 VALUES 数据列的取值的方法总共有：
 
@@ -695,6 +781,8 @@ public void setByte(int columnIndex, ArrayList<Byte> list) throws SQLException
 public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
 public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
+public void setVarbinary(int columnIndex, ArrayList<byte[]> list, int size) throws SQLException
+public void setGeometry(int columnIndex, ArrayList<byte[]> list, int size) throws SQLException
 ```
 
 </TabItem>
@@ -883,6 +971,9 @@ public void setTagFloat(int index, float value)
 public void setTagDouble(int index, double value)
 public void setTagString(int index, String value)
 public void setTagNString(int index, String value)
+public void setTagJson(int index, String value)
+public void setTagVarbinary(int index, byte[] value)
+public void setTagGeometry(int index, byte[] value)
 ```
 
 ### 无模式写入

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

@@ -716,16 +716,6 @@ charset 的有效值是 UTF-8。
 | 取值范围 | 0: 不改变；1：改变                   |
 | 缺省值   | 0                                    |
 
-### keepTimeOffset
-
-| 属性     | 说明           |
-| -------- | -------------- |
-| 适用范围 | 仅服务端适用   |
-| 含义     | 迁移操作的延时 |
-| 单位     | 小时           |
-| 取值范围 | 0-23           |
-| 缺省值   | 0              |
-
 ### tmqMaxTopicNum
 
 | 属性     | 说明                        |
@@ -803,7 +793,7 @@ charset 的有效值是 UTF-8。
 | 53  |          udf           | 是              | 是                              |                    |
 | 54  |     enableCoreFile     | 是              | 是                              |                    |
 | 55  |    ttlChangeOnWrite    | 否              | 是                              |                    |
-| 56  |     keepTimeOffset     | 是              | 是                              |                    |
+| 56  |     keepTimeOffset     | 否              | 是（从3.2.0.0开始，该配置废弃） |                    |
 
 ## 2.x->3.0 的废弃参数
 

examples/JDBC/JDBCDemo/pom.xml

@@ -11,13 +11,20 @@
 
     <properties>
         <project.assembly.dir>src/main/resources/assembly</project.assembly.dir>
+        <java.version>1.8</java.version>
+
     </properties>
 
     <dependencies>
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>3.0.0</version>
+            <version>3.2.7</version>
+        </dependency>
+        <dependency>
+            <groupId>org.locationtech.jts</groupId>
+            <artifactId>jts-core</artifactId>
+            <version>1.19.0</version>
         </dependency>
     </dependencies>
 
@@ -68,12 +75,12 @@
                     </execution>
 
                     <execution>
-                        <id>SubscribeDemo</id>
+                        <id>GeometryDemo</id>
                         <configuration>
-                            <finalName>SubscribeDemo</finalName>
+                            <finalName>GeometryDemo</finalName>
                             <archive>
                                 <manifest>
-                                    <mainClass>com.taosdata.example.SubscribeDemo</mainClass>
+                                    <mainClass>com.taosdata.example.GeometryDemo</mainClass>
                                 </manifest>
                             </archive>
                             <descriptorRefs>

examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/ConsumerLoop.java

@@ -0,0 +1,94 @@
+package com.taosdata.example;
+
+import com.taosdata.jdbc.tmq.ConsumerRecord;
+import com.taosdata.jdbc.tmq.ConsumerRecords;
+import com.taosdata.jdbc.tmq.ReferenceDeserializer;
+import com.taosdata.jdbc.tmq.TaosConsumer;
+
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class ConsumerLoop {
+    private final TaosConsumer<ResultBean> consumer;
+    private final List<String> topics;
+    private final AtomicBoolean shutdown;
+    private final CountDownLatch shutdownLatch;
+
+    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");
+        this.shutdown = new AtomicBoolean(false);
+        this.shutdownLatch = new CountDownLatch(1);
+    }
+
+    public abstract void process(ResultBean result);
+
+    public void pollData() throws SQLException {
+        try {
+            consumer.subscribe(topics);
+
+            while (!shutdown.get()) {
+                ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
+                for (ConsumerRecord<ResultBean> record : records) {
+                    ResultBean bean = record.value();
+                    process(bean);
+                }
+            }
+            consumer.unsubscribe();
+        } finally {
+            consumer.close();
+            shutdownLatch.countDown();
+        }
+    }
+
+    public void shutdown() throws InterruptedException {
+        shutdown.set(true);
+        shutdownLatch.await();
+    }
+
+    public static class ResultDeserializer extends ReferenceDeserializer<ResultBean> {
+
+    }
+
+    public static class ResultBean {
+        private Timestamp ts;
+        private int speed;
+
+        public Timestamp getTs() {
+            return ts;
+        }
+
+        public void setTs(Timestamp ts) {
+            this.ts = ts;
+        }
+
+        public int getSpeed() {
+            return speed;
+        }
+
+        public void setSpeed(int speed) {
+            this.speed = speed;
+        }
+    }
+}

examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/GeometryDemo.java

@@ -0,0 +1,190 @@
+package com.taosdata.example;
+
+import com.taosdata.jdbc.TSDBPreparedStatement;
+import org.locationtech.jts.geom.*;
+import org.locationtech.jts.io.ByteOrderValues;
+import org.locationtech.jts.io.ParseException;
+import org.locationtech.jts.io.WKBReader;
+import org.locationtech.jts.io.WKBWriter;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.Properties;
+
+public class GeometryDemo {
+    private static String host = "localhost";
+    private static final String dbName = "test";
+    private static final String tbName = "weather";
+    private static final String user = "root";
+    private static final String password = "taosdata";
+
+    private Connection connection;
+
+    public static void main(String[] args) throws SQLException {
+        for (int i = 0; i < args.length; i++) {
+            if ("-host".equalsIgnoreCase(args[i]) && i < args.length - 1)
+                host = args[++i];
+        }
+        if (host == null) {
+            printHelp();
+        }
+        GeometryDemo demo = new GeometryDemo();
+        demo.init();
+        demo.createDatabase();
+        demo.useDatabase();
+        demo.dropTable();
+        demo.createTable();
+
+        demo.insert();
+        demo.stmtInsert();
+        demo.select();
+
+        demo.dropTable();
+        demo.close();
+    }
+
+    private void init() {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=" + user + "&password=" + password;
+        // get connection
+        try {
+            Properties properties = new Properties();
+            properties.setProperty("charset", "UTF-8");
+            properties.setProperty("locale", "en_US.UTF-8");
+            properties.setProperty("timezone", "UTC-8");
+            System.out.println("get connection starting...");
+            connection = DriverManager.getConnection(url, properties);
+            if (connection != null)
+                System.out.println("[ OK ] Connection established.");
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void createDatabase() {
+        String sql = "create database if not exists " + dbName;
+        execute(sql);
+    }
+
+    private void useDatabase() {
+        String sql = "use " + dbName;
+        execute(sql);
+    }
+
+    private void dropTable() {
+        final String sql = "drop table if exists " + dbName + "." + tbName + "";
+        execute(sql);
+    }
+
+    private void createTable() {
+        final String sql = "create table if not exists " + dbName + "." + tbName + " (ts timestamp, temperature float, humidity int, location geometry(50))";
+        execute(sql);
+    }
+
+    private void insert() {
+        final String sql = "insert into " + dbName + "." + tbName + " (ts, temperature, humidity, location) values(now, 20.5, 34, 'POINT(1 2)')";
+        execute(sql);
+    }
+
+    private void stmtInsert() throws SQLException {
+        TSDBPreparedStatement preparedStatement = (TSDBPreparedStatement) connection.prepareStatement("insert into " + dbName + "." + tbName + " values (?, ?, ?, ?)");
+
+        long current = System.currentTimeMillis();
+        ArrayList<Long> tsList = new ArrayList<>();
+        tsList.add(current);
+        tsList.add(current + 1);
+        preparedStatement.setTimestamp(0, tsList);
+        ArrayList<Float> tempList = new ArrayList<>();
+        tempList.add(20.1F);
+        tempList.add(21.2F);
+        preparedStatement.setFloat(1, tempList);
+        ArrayList<Integer> humList = new ArrayList<>();
+        humList.add(30);
+        humList.add(31);
+        preparedStatement.setInt(2, humList);
+
+
+        ArrayList<byte[]> list = new ArrayList<>();
+        GeometryFactory gf = new GeometryFactory();
+        Point p1 = gf.createPoint(new Coordinate(1,2));
+        p1.setSRID(1234);
+
+        // NOTE: TDengine current version only support 2D dimension and little endian byte order
+        WKBWriter w = new WKBWriter(2, ByteOrderValues.LITTLE_ENDIAN, true);
+        byte[] wkb = w.write(p1);
+        list.add(wkb);
+
+        Coordinate[] coordinates = { new Coordinate(10, 20),
+                                     new Coordinate(30, 40)};
+        LineString lineString = gf.createLineString(coordinates);
+        lineString.setSRID(2345);
+        byte[] wkb2 = w.write(lineString);
+        list.add(wkb2);
+
+        preparedStatement.setGeometry(3, list, 50);
+
+        preparedStatement.columnDataAddBatch();
+        preparedStatement.columnDataExecuteBatch();
+    }
+
+    private void select() {
+        final String sql = "select * from " + dbName + "." + tbName;
+        executeQuery(sql);
+    }
+
+    private void close() {
+        try {
+            if (connection != null) {
+                this.connection.close();
+                System.out.println("connection closed.");
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void executeQuery(String sql) {
+        long start = System.currentTimeMillis();
+        try (Statement statement = connection.createStatement()) {
+            ResultSet resultSet = statement.executeQuery(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, true, (end - start));
+
+            while (resultSet.next()){
+                byte[] result1 = resultSet.getBytes(4);
+                WKBReader reader = new WKBReader();
+                Geometry g1 = reader.read(result1);
+                System.out.println("GEO OBJ: " + g1 + ", SRID: " + g1.getSRID());
+            }
+
+        } catch (SQLException e) {
+            long end = System.currentTimeMillis();
+            printSql(sql, false, (end - start));
+            e.printStackTrace();
+        } catch (ParseException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void printSql(String sql, boolean succeed, long cost) {
+        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
+    }
+
+    private void execute(String sql) {
+        long start = System.currentTimeMillis();
+        try (Statement statement = connection.createStatement()) {
+            boolean execute = statement.execute(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, true, (end - start));
+        } catch (SQLException e) {
+            long end = System.currentTimeMillis();
+            printSql(sql, false, (end - start));
+            e.printStackTrace();
+        }
+    }
+
+    private static void printHelp() {
+        System.out.println("Usage: java -jar JDBCDemo.jar -host <hostname>");
+        System.exit(0);
+    }
+
+}

examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/ParameterBindingDemo.java

@@ -0,0 +1,316 @@
+package com.taosdata.example;
+
+import com.taosdata.jdbc.TSDBPreparedStatement;
+import com.taosdata.jdbc.utils.StringUtils;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class ParameterBindingDemo {
+
+    private static final String host = "127.0.0.1";
+    private static final Random random = new Random(System.currentTimeMillis());
+    private static final int BINARY_COLUMN_SIZE = 50;
+    private static final String[] schemaList = {
+            "create table stable1(ts timestamp, f1 tinyint, f2 smallint, f3 int, f4 bigint) tags(t1 tinyint, t2 smallint, t3 int, t4 bigint)",
+            "create table stable2(ts timestamp, f1 float, f2 double) tags(t1 float, t2 double)",
+            "create table stable3(ts timestamp, f1 bool) tags(t1 bool)",
+            "create table stable4(ts timestamp, f1 binary(" + BINARY_COLUMN_SIZE + ")) tags(t1 binary(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable6(ts timestamp, f1 varbinary(" + BINARY_COLUMN_SIZE + ")) tags(t1 varbinary(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable7(ts timestamp, f1 geometry(" + BINARY_COLUMN_SIZE + ")) tags(t1 geometry(" + BINARY_COLUMN_SIZE + "))",
+    };
+    private static final int numOfSubTable = 10, numOfRow = 10;
+
+    public static void main(String[] args) throws SQLException {
+
+        String jdbcUrl = "jdbc:TAOS://" + host + ":6030/";
+        Connection conn = DriverManager.getConnection(jdbcUrl, "root", "taosdata");
+
+        init(conn);
+
+        bindInteger(conn);
+        bindFloat(conn);
+        bindBoolean(conn);
+        bindBytes(conn);
+        bindString(conn);
+        bindVarbinary(conn);
+        bindGeometry(conn);
+
+        clean(conn);
+        conn.close();
+    }
+
+    private static void init(Connection conn) throws SQLException {
+        clean(conn);
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("create database if not exists test_parabind");
+            stmt.execute("use test_parabind");
+            for (int i = 0; i < schemaList.length; i++) {
+                stmt.execute(schemaList[i]);
+            }
+        }
+    }
+    private static void clean(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists test_parabind");
+        }
+    }
+
+    private static void bindInteger(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable1 tags(?,?,?,?) values(?,?,?,?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t1_" + i);
+                // set tags
+                pstmt.setTagByte(0, Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
+                pstmt.setTagShort(1, Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
+                pstmt.setTagInt(2, random.nextInt(Integer.MAX_VALUE));
+                pstmt.setTagLong(3, random.nextLong());
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<Byte> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++)
+                    f1List.add(Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
+                pstmt.setByte(1, f1List);
+
+                ArrayList<Short> f2List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++)
+                    f2List.add(Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
+                pstmt.setShort(2, f2List);
+
+                ArrayList<Integer> f3List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++)
+                    f3List.add(random.nextInt(Integer.MAX_VALUE));
+                pstmt.setInt(3, f3List);
+
+                ArrayList<Long> f4List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++)
+                    f4List.add(random.nextLong());
+                pstmt.setLong(4, f4List);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute column
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindFloat(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable2 tags(?,?) values(?,?,?)";
+
+        TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class);
+
+        for (int i = 1; i <= numOfSubTable; i++) {
+            // set table name
+            pstmt.setTableName("t2_" + i);
+            // set tags
+            pstmt.setTagFloat(0, random.nextFloat());
+            pstmt.setTagDouble(1, random.nextDouble());
+            // set columns
+            ArrayList<Long> tsList = new ArrayList<>();
+            long current = System.currentTimeMillis();
+            for (int j = 0; j < numOfRow; j++)
+                tsList.add(current + j);
+            pstmt.setTimestamp(0, tsList);
+
+            ArrayList<Float> f1List = new ArrayList<>();
+            for (int j = 0; j < numOfRow; j++)
+                f1List.add(random.nextFloat());
+            pstmt.setFloat(1, f1List);
+
+            ArrayList<Double> f2List = new ArrayList<>();
+            for (int j = 0; j < numOfRow; j++)
+                f2List.add(random.nextDouble());
+            pstmt.setDouble(2, f2List);
+
+            // add column
+            pstmt.columnDataAddBatch();
+        }
+        // execute
+        pstmt.columnDataExecuteBatch();
+        // close if no try-with-catch statement is used
+        pstmt.close();
+    }
+
+    private static void bindBoolean(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable3 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t3_" + i);
+                // set tags
+                pstmt.setTagBoolean(0, random.nextBoolean());
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<Boolean> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++)
+                    f1List.add(random.nextBoolean());
+                pstmt.setBoolean(1, f1List);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindBytes(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable4 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t4_" + i);
+                // set tags
+                pstmt.setTagString(0, new String("abc"));
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<String> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    f1List.add(new String("abc"));
+                }
+                pstmt.setString(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindString(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable5 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t5_" + i);
+                // set tags
+                pstmt.setTagNString(0, "California.SanFrancisco");
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<String> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    f1List.add("California.LosAngeles");
+                }
+                pstmt.setNString(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindVarbinary(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable6 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t6_" + i);
+                // set tags
+                byte[] bTag = new byte[]{0,2,3,4,5};
+                bTag[0] = (byte) i;
+                pstmt.setTagVarbinary(0, bTag);
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    byte[] v = new byte[]{0,2,3,4,5,6};
+                    v[0] = (byte)j;
+                    f1List.add(v);
+                }
+                pstmt.setVarbinary(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+
+    private static void bindGeometry(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable7 tags(?) values(?,?)";
+
+        try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
+
+            byte[] g1 = StringUtils.hexToBytes("0101000000000000000000F03F0000000000000040");
+            byte[] g2 = StringUtils.hexToBytes("0102000020E610000002000000000000000000F03F000000000000004000000000000008400000000000001040");
+            List<byte[]> listGeo = new ArrayList<>();
+            listGeo.add(g1);
+            listGeo.add(g2);
+
+            for (int i = 1; i <= 2; i++) {
+                // set table name
+                pstmt.setTableName("t7_" + i);
+                // set tags
+                pstmt.setTagGeometry(0, listGeo.get(i - 1));
+
+                // set columns
+                ArrayList<Long> tsList = new ArrayList<>();
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++)
+                    tsList.add(current + j);
+                pstmt.setTimestamp(0, tsList);
+
+                ArrayList<byte[]> f1List = new ArrayList<>();
+                for (int j = 0; j < numOfRow; j++) {
+                    f1List.add(listGeo.get(i - 1));
+                }
+                pstmt.setGeometry(1, f1List, BINARY_COLUMN_SIZE);
+
+                // add column
+                pstmt.columnDataAddBatch();
+            }
+            // execute
+            pstmt.columnDataExecuteBatch();
+        }
+    }
+}

examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/SubscribeDemo.java

@@ -1,74 +0,0 @@
-package com.taosdata.example;
-
-import com.taosdata.jdbc.TSDBConnection;
-import com.taosdata.jdbc.TSDBDriver;
-import com.taosdata.jdbc.TSDBResultSet;
-import com.taosdata.jdbc.TSDBSubscribe;
-
-import java.sql.DriverManager;
-import java.sql.ResultSetMetaData;
-import java.util.Properties;
-import java.util.concurrent.TimeUnit;
-
-public class SubscribeDemo {
-    private static final String usage = "java -jar SubscribeDemo.jar -host <hostname> -database <database name> -topic <topic> -sql <sql>";
-
-    public static void main(String[] args) {
-        // parse args from command line
-        String host = "", database = "", topic = "", sql = "";
-        for (int i = 0; i < args.length; i++) {
-            if ("-host".equalsIgnoreCase(args[i]) && i < args.length - 1) {
-                host = args[++i];
-            }
-            if ("-database".equalsIgnoreCase(args[i]) && i < args.length - 1) {
-                database = args[++i];
-            }
-            if ("-topic".equalsIgnoreCase(args[i]) && i < args.length - 1) {
-                topic = args[++i];
-            }
-            if ("-sql".equalsIgnoreCase(args[i]) && i < args.length - 1) {
-                sql = args[++i];
-            }
-        }
-        if (host.isEmpty() || database.isEmpty() || topic.isEmpty() || sql.isEmpty()) {
-            System.out.println(usage);
-            return;
-        }
-
-        try {
-            Properties properties = new Properties();
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-            final String url = "jdbc:TAOS://" + host + ":6030/" + database + "?user=root&password=taosdata";
-            // get TSDBConnection
-            TSDBConnection connection = (TSDBConnection) DriverManager.getConnection(url, properties);
-            // create TSDBSubscribe
-            TSDBSubscribe sub = connection.subscribe(topic, sql, false);
-
-            int total = 0;
-            while (true) {
-                TSDBResultSet rs = sub.consume();
-                int count = 0;
-                ResultSetMetaData meta = rs.getMetaData();
-                while (rs.next()) {
-                    for (int i = 1; i <= meta.getColumnCount(); i++) {
-                        System.out.print(meta.getColumnLabel(i) + ": " + rs.getString(i) + "\t");
-                    }
-                    System.out.println();
-                    count++;
-                }
-                total += count;
-//                System.out.printf("%d rows consumed, total %d\n", count, total);
-                if (total >= 10)
-                    break;
-                TimeUnit.SECONDS.sleep(1);
-            }
-            sub.close(false);
-            connection.close();
-        } catch (Exception e) {
-            System.out.println("host: " + host + ", database: " + database + ", topic: " + topic + ", sql: " + sql);
-            e.printStackTrace();
-        }
-    }
-}

examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/WSParameterBindingDemo.java

@@ -0,0 +1,170 @@
+package com.taosdata.example;
+
+import com.taosdata.jdbc.ws.TSWSPreparedStatement;
+
+import java.sql.*;
+import java.util.Random;
+
+public class WSParameterBindingDemo {
+    private static final String host = "127.0.0.1";
+    private static final Random random = new Random(System.currentTimeMillis());
+    private static final int BINARY_COLUMN_SIZE = 30;
+    private static final String[] schemaList = {
+            "create table stable1(ts timestamp, f1 tinyint, f2 smallint, f3 int, f4 bigint) tags(t1 tinyint, t2 smallint, t3 int, t4 bigint)",
+            "create table stable2(ts timestamp, f1 float, f2 double) tags(t1 float, t2 double)",
+            "create table stable3(ts timestamp, f1 bool) tags(t1 bool)",
+            "create table stable4(ts timestamp, f1 binary(" + BINARY_COLUMN_SIZE + ")) tags(t1 binary(" + BINARY_COLUMN_SIZE + "))",
+            "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))"
+    };
+    private static final int numOfSubTable = 10, numOfRow = 10;
+
+    public static void main(String[] args) throws SQLException {
+
+        String jdbcUrl = "jdbc:TAOS-RS://" + host + ":6041/?batchfetch=true";
+        Connection conn = DriverManager.getConnection(jdbcUrl, "root", "taosdata");
+
+        init(conn);
+
+        bindInteger(conn);
+
+        bindFloat(conn);
+
+        bindBoolean(conn);
+
+        bindBytes(conn);
+
+        bindString(conn);
+
+        conn.close();
+    }
+
+    private static void init(Connection conn) throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists test_ws_parabind");
+            stmt.execute("create database if not exists test_ws_parabind");
+            stmt.execute("use test_ws_parabind");
+            for (int i = 0; i < schemaList.length; i++) {
+                stmt.execute(schemaList[i]);
+            }
+        }
+    }
+
+    private static void bindInteger(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable1 tags(?,?,?,?) values(?,?,?,?,?)";
+
+        try (TSWSPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSWSPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t1_" + i);
+                // set tags
+                pstmt.setTagByte(1, Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
+                pstmt.setTagShort(2, Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
+                pstmt.setTagInt(3, random.nextInt(Integer.MAX_VALUE));
+                pstmt.setTagLong(4, random.nextLong());
+                // set columns
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++) {
+                    pstmt.setTimestamp(1, new Timestamp(current + j));
+                    pstmt.setByte(2, Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
+                    pstmt.setShort(3, Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
+                    pstmt.setInt(4, random.nextInt(Integer.MAX_VALUE));
+                    pstmt.setLong(5, random.nextLong());
+                    pstmt.addBatch();
+                }
+                pstmt.executeBatch();
+            }
+        }
+    }
+
+    private static void bindFloat(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable2 tags(?,?) values(?,?,?)";
+
+        try(TSWSPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSWSPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t2_" + i);
+                // set tags
+                pstmt.setTagFloat(1, random.nextFloat());
+                pstmt.setTagDouble(2, random.nextDouble());
+                // set columns
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++) {
+                    pstmt.setTimestamp(1, new Timestamp(current + j));
+                    pstmt.setFloat(2, random.nextFloat());
+                    pstmt.setDouble(3, random.nextDouble());
+                    pstmt.addBatch();
+                }
+                pstmt.executeBatch();
+            }
+        }
+    }
+
+    private static void bindBoolean(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable3 tags(?) values(?,?)";
+
+        try (TSWSPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSWSPreparedStatement.class)) {
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t3_" + i);
+                // set tags
+                pstmt.setTagBoolean(1, random.nextBoolean());
+                // set columns
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++) {
+                    pstmt.setTimestamp(1, new Timestamp(current + j));
+                    pstmt.setBoolean(2, random.nextBoolean());
+                    pstmt.addBatch();
+                }
+                pstmt.executeBatch();
+            }
+        }
+    }
+
+    private static void bindBytes(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable4 tags(?) values(?,?)";
+
+        try (TSWSPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSWSPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t4_" + i);
+                // set tags
+                pstmt.setTagString(1, new String("abc"));
+
+                // set columns
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++) {
+                    pstmt.setTimestamp(1, new Timestamp(current + j));
+                    pstmt.setString(2, "abc");
+                    pstmt.addBatch();
+                }
+                pstmt.executeBatch();
+            }
+        }
+    }
+
+    private static void bindString(Connection conn) throws SQLException {
+        String sql = "insert into ? using stable5 tags(?) values(?,?)";
+
+        try (TSWSPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSWSPreparedStatement.class)) {
+
+            for (int i = 1; i <= numOfSubTable; i++) {
+                // set table name
+                pstmt.setTableName("t5_" + i);
+                // set tags
+                pstmt.setTagNString(1, "California.SanFrancisco");
+
+                // set columns
+                long current = System.currentTimeMillis();
+                for (int j = 0; j < numOfRow; j++) {
+                    pstmt.setTimestamp(0, new Timestamp(current + j));
+                    pstmt.setNString(1, "California.SanFrancisco");
+                    pstmt.addBatch();
+                }
+                pstmt.executeBatch();
+            }
+        }
+    }
+}

include/client/taos.h

@@ -125,7 +125,8 @@ typedef enum {
 
 typedef enum {
   TAOS_NOTIFY_PASSVER = 0,
-  TAOS_NOTIFY_WHITELIST_VER = 1
+  TAOS_NOTIFY_WHITELIST_VER = 1,
+  TAOS_NOTIFY_USER_DROPPED = 2,
 } TAOS_NOTIFY_TYPE;
 
 #define RET_MSG_LENGTH 1024
@@ -244,7 +245,7 @@ typedef enum {
   TAOS_CONN_MODE_BI = 0,
 } TAOS_CONN_MODE;
 
-DLL_EXPORT int taos_set_mode(TAOS* taos, int mode, int value);
+DLL_EXPORT int taos_set_conn_mode(TAOS* taos, int mode, int value);
 /*  --------------------------schemaless INTERFACE------------------------------- */
 
 DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
@@ -318,6 +319,7 @@ DLL_EXPORT int32_t   tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t
 DLL_EXPORT int64_t   tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId);  // The current offset is the offset of the last consumed message + 1
 DLL_EXPORT int64_t   tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId);
 
+DLL_EXPORT TAOS       *tmq_get_connect(tmq_t *tmq);
 DLL_EXPORT const char *tmq_get_table_name(TAOS_RES *res);
 DLL_EXPORT tmq_res_t   tmq_get_res_type(TAOS_RES *res);
 DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);

include/common/tglobal.h

@@ -145,6 +145,7 @@ extern bool    tsUseAdapter;
 extern int32_t tsMetaCacheMaxSize;
 extern int32_t tsSlowLogThreshold;
 extern int32_t tsSlowLogScope;
+extern int32_t tsTimeSeriesThreshold;
 
 // client
 extern int32_t tsMinSlidingTime;
@@ -159,10 +160,11 @@ extern char buildinfo[];
 
 // lossy
 extern char     tsLossyColumns[];
-extern double   tsFPrecision;
+extern float    tsFPrecision;
 extern double   tsDPrecision;
 extern uint32_t tsMaxRange;
 extern uint32_t tsCurRange;
+extern bool     tsIfAdtFse;
 extern char     tsCompressor[];
 
 // tfs
@@ -206,7 +208,6 @@ extern int32_t tsRpcRetryInterval;
 extern bool    tsDisableStream;
 extern int64_t tsStreamBufferSize;
 extern bool    tsFilterScalarMode;
-extern int32_t tsKeepTimeOffset;
 extern int32_t tsMaxStreamBackendCache;
 extern int32_t tsPQSortMemThreshold;
 extern int32_t tsResolveFQDNRetryTime;

include/common/tgrant.h

@@ -30,6 +30,8 @@ extern "C" {
 #define GRANTS_COL_MAX_LEN 196
 #endif
 
+#define GRANT_HEART_BEAT_MIN 2
+
 typedef enum {
   TSDB_GRANT_ALL,
   TSDB_GRANT_TIME,
@@ -49,6 +51,9 @@ typedef enum {
 } EGrantType;
 
 int32_t grantCheck(EGrantType grant);
+#ifdef TD_ENTERPRISE
+int32_t grantAlterActiveCode(const char* old, const char* new, char* out, int8_t type);
+#endif
 
 #ifndef GRANTS_CFG
 #ifdef TD_ENTERPRISE

include/common/tmsg.h

@@ -959,7 +959,7 @@ typedef struct {
   int8_t    superAuth;
   int8_t    sysInfo;
   int8_t    enable;
-  int8_t    reserve;
+  int8_t    dropped;
   SHashObj* createdDbs;
   SHashObj* readDbs;
   SHashObj* writeDbs;
@@ -1096,6 +1096,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;
@@ -1133,6 +1134,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t walFsyncPeriod;
   int8_t  walLevel;
   int8_t  strict;
@@ -1239,6 +1241,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;
@@ -1464,6 +1467,11 @@ typedef struct {
   int32_t learnerProgress;  // use one reservered
 } SVnodeLoad;
 
+typedef struct {
+  int32_t vgId;
+  int64_t nTimeSeries;
+} SVnodeLoadLite;
+
 typedef struct {
   int8_t  syncState;
   int64_t syncTerm;
@@ -1511,6 +1519,16 @@ int32_t tSerializeSStatusReq(void* buf, int32_t bufLen, SStatusReq* pReq);
 int32_t tDeserializeSStatusReq(void* buf, int32_t bufLen, SStatusReq* pReq);
 void    tFreeSStatusReq(SStatusReq* pReq);
 
+typedef struct {
+  int32_t dnodeId;
+  int64_t clusterId;
+  SArray* pVloads;
+} SNotifyReq;
+
+int32_t tSerializeSNotifyReq(void* buf, int32_t bufLen, SNotifyReq* pReq);
+int32_t tDeserializeSNotifyReq(void* buf, int32_t bufLen, SNotifyReq* pReq);
+void    tFreeSNotifyReq(SNotifyReq* pReq);
+
 typedef struct {
   int32_t dnodeId;
   int64_t clusterId;
@@ -1576,6 +1594,7 @@ typedef struct {
   int32_t  daysToKeep0;
   int32_t  daysToKeep1;
   int32_t  daysToKeep2;
+  int32_t  keepTimeOffset;
   int32_t  minRows;
   int32_t  maxRows;
   int32_t  walFsyncPeriod;
@@ -1655,6 +1674,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t walFsyncPeriod;
   int8_t  walLevel;
   int8_t  strict;

include/common/tmsgdef.h

@@ -179,8 +179,7 @@ enum { // WARN: new msg should be appended to segment tail
   TD_DEF_MSG_TYPE(TDMT_MND_STREAM_HEARTBEAT, "stream-heartbeat", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_RETRIEVE_IP_WHITE, "retrieve-ip-white", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_USER_WHITELIST, "get-user-whitelist", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", NULL, NULL)
-
+  TD_DEF_MSG_TYPE(TDMT_MND_NOTIFY, "notify", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_BALANCE_VGROUP_LEADER, "balance-vgroup-leader", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_RESTORE_DNODE, "restore-dnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_PAUSE_STREAM, "pause-stream", NULL, NULL)
@@ -189,6 +188,8 @@ enum { // WARN: new msg should be appended to segment tail
   TD_DEF_MSG_TYPE(TDMT_MND_STREAM_BEGIN_CHECKPOINT, "stream-begin-checkpoint", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_STREAM_NODECHANGE_CHECK, "stream-nodechange-check", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TRIM_DB_TIMER, "trim-db-tmr", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_GRANT_NOTIFY, "grant-notify", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_VND_MSG)
   TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT, "submit", SSubmitReq, SSubmitRsp)

include/common/ttokendef.h

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

include/libs/executor/storageapi.h

@@ -142,6 +142,7 @@ typedef struct SSnapContext {
 typedef struct {
   int64_t uid;
   int64_t ctbNum;
+  int32_t colNum;
 } SMetaStbStats;
 
 // void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
@@ -285,8 +286,8 @@ typedef struct SStoreMeta {
 
   // 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* pVnode, int64_t uid, int64_t* numOfTables,
+      int32_t* numOfCols);  // 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);

include/libs/function/functionMgt.h

@@ -236,6 +236,7 @@ bool fmIsInterpPseudoColumnFunc(int32_t funcId);
 bool fmIsGroupKeyFunc(int32_t funcId);
 bool fmIsBlockDistFunc(int32_t funcId);
 bool fmIsConstantResFunc(SFunctionNode* pFunc);
+bool fmIsSkipScanCheckFunc(int32_t funcId);
 
 void getLastCacheDataType(SDataType* pType);
 SFunctionNode* createFunction(const char* pName, SNodeList* pParameterList);

include/libs/monitor/monitor.h

@@ -191,7 +191,7 @@ typedef struct {
 } SMonBmInfo;
 
 typedef struct {
-  SArray *pVloads;  // SVnodeLoad
+  SArray *pVloads;  // SVnodeLoad/SVnodeLoadLite
 } SMonVloadInfo;
 
 typedef struct {
@@ -206,6 +206,11 @@ typedef struct {
   bool        comp;
 } SMonCfg;
 
+typedef struct {
+  int8_t state;
+  tsem_t sem;
+} SDmNotifyHandle;
+
 int32_t monInit(const SMonCfg *pCfg);
 void    monCleanup();
 void    monRecordLog(int64_t ts, ELogLevel level, const char *content);

include/libs/nodes/cmdnodes.h

@@ -66,6 +66,7 @@ typedef struct SDatabaseOptions {
   int32_t     minRowsPerBlock;
   SNodeList*  pKeep;
   int64_t     keep[3];
+  int32_t     keepTimeOffset;
   int32_t     pages;
   int32_t     pagesize;
   int32_t     tsdbPageSize;

include/libs/nodes/nodes.h

@@ -124,6 +124,7 @@ int32_t    nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc);
 int32_t    nodesListPushFront(SNodeList* pList, SNode* pNode);
 SListCell* nodesListErase(SNodeList* pList, SListCell* pCell);
 void       nodesListInsertList(SNodeList* pTarget, SListCell* pPos, SNodeList* pSrc);
+void       nodesListInsertListAfterPos(SNodeList* pTarget, SListCell* pPos, SNodeList* pSrc);
 SNode*     nodesListGetNode(SNodeList* pList, int32_t index);
 SListCell* nodesListGetCell(SNodeList* pList, int32_t index);
 void       nodesDestroyList(SNodeList* pList);

include/libs/nodes/plannodes.h

@@ -293,6 +293,7 @@ typedef struct SPartitionLogicNode {
   SNodeList* pPartitionKeys;
   SNodeList* pTags;
   SNode*     pSubtable;
+  SNodeList* pAggFuncs;
 
   bool    needBlockOutputTsOrder;  // if true, partition output block will have ts order maintained
   int32_t pkTsColId;

include/libs/nodes/querynodes.h

@@ -537,6 +537,9 @@ int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);
 const char* operatorTypeStr(EOperatorType type);
 const char* logicConditionTypeStr(ELogicConditionType type);
 
+bool nodesIsStar(SNode* pNode);
+bool nodesIsTableStar(SNode* pNode);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/parser/parser.h

@@ -64,7 +64,7 @@ typedef struct SParseContext {
   SArray*          pTableMetaPos;    // sql table pos => catalog data pos
   SArray*          pTableVgroupPos;  // sql table pos => catalog data pos
   int64_t          allocatorId;
-  int32_t          biMode;
+  int8_t           biMode;
 } SParseContext;
 
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery);

include/os/osSemaphore.h

@@ -33,6 +33,17 @@ int tsem_timewait(tsem_t *sim, int64_t milis);
 int tsem_post(tsem_t *sem);
 int tsem_destroy(tsem_t *sem);
 
+#elif defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+#include <windows.h>
+
+#define tsem_t HANDLE
+
+int tsem_init(tsem_t *sem, int pshared, unsigned int value);
+int tsem_wait(tsem_t *sem);
+int tsem_timewait(tsem_t *sim, int64_t milis);
+int tsem_post(tsem_t *sem);
+int tsem_destroy(tsem_t *sem);
+
 #else
 
 #define tsem_t       sem_t

include/os/osThread.h

@@ -22,6 +22,15 @@
 extern "C" {
 #endif
 
+#if defined(WINDOWS) && !defined(__USE_PTHREAD)
+#include <windows.h>
+#define __USE_WIN_THREAD
+// https://learn.microsoft.com/en-us/windows/win32/winprog/using-the-windows-headers
+// #ifndef _WIN32_WINNT
+// #define _WIN32_WINNT 0x0600
+// #endif
+#endif
+
 #if !defined(WINDOWS) && !defined(_ALPINE)
 #ifndef __USE_XOPEN2K
 #define TD_USE_SPINLOCK_AS_MUTEX
@@ -29,6 +38,22 @@ typedef pthread_mutex_t pthread_spinlock_t;
 #endif
 #endif
 
+#ifdef __USE_WIN_THREAD
+typedef pthread_t          TdThread;           // pthread api
+typedef pthread_spinlock_t TdThreadSpinlock;   // pthread api
+typedef CRITICAL_SECTION   TdThreadMutex;      // windows api
+typedef HANDLE             TdThreadMutexAttr;  // windows api
+typedef struct {
+  SRWLOCK lock;
+  int8_t  excl;
+} TdThreadRwlock;                               // windows api
+typedef pthread_attr_t     TdThreadAttr;        // pthread api
+typedef pthread_once_t     TdThreadOnce;        // pthread api
+typedef HANDLE             TdThreadRwlockAttr;  // windows api
+typedef CONDITION_VARIABLE TdThreadCond;        // windows api
+typedef HANDLE             TdThreadCondAttr;    // windows api
+typedef pthread_key_t      TdThreadKey;         // pthread api
+#else
 typedef pthread_t            TdThread;
 typedef pthread_spinlock_t   TdThreadSpinlock;
 typedef pthread_mutex_t      TdThreadMutex;
@@ -40,11 +65,14 @@ typedef pthread_rwlockattr_t TdThreadRwlockAttr;
 typedef pthread_cond_t       TdThreadCond;
 typedef pthread_condattr_t   TdThreadCondAttr;
 typedef pthread_key_t        TdThreadKey;
+#endif
 
 #define taosThreadCleanupPush pthread_cleanup_push
 #define taosThreadCleanupPop  pthread_cleanup_pop
 
-#ifdef WINDOWS
+#if defined(WINDOWS) && !defined(__USE_PTHREAD)
+#define TD_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER_FORBID
+#elif defined(WINDOWS)
 #define TD_PTHREAD_MUTEX_INITIALIZER (TdThreadMutex)(-1)
 #else
 #define TD_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER

include/td_sz.h

@@ -0,0 +1,51 @@
+/*
+ * 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_SZ_H
+#define _TD_SZ_H
+#include "defines.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void cost_start();
+double cost_end(const char* tag);
+
+//
+// Init  success return 1 else 0
+//
+void tdszInit(float fPrecision, double dPrecision, unsigned int maxIntervals, unsigned int intervals, int ifAdtFse, const char* compressor);
+
+//
+// compress interface to tdengine return value is count of output with bytes
+//
+int tdszCompress(int type, const char * input, const int nelements, const char * output);
+
+//
+// decompress interface to tdengine return value is count of output with bytes
+//
+int tdszDecompress(int type, const char * input, int compressedSize, const int nelements, const char * output);
+
+//
+//  Exit call
+//
+void tdszExit();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ----- #ifndef _SZ_H  ----- */

include/util/taoserror.h

@@ -541,6 +541,13 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_GRANT_CPU_LIMITED             TAOS_DEF_ERROR_CODE(0, 0x080B)
 #define TSDB_CODE_GRANT_STABLE_LIMITED          TAOS_DEF_ERROR_CODE(0, 0x080C)
 #define TSDB_CODE_GRANT_TABLE_LIMITED           TAOS_DEF_ERROR_CODE(0, 0x080D)
+#define TSDB_CODE_GRANT_PAR_IVLD_ACTIVE         TAOS_DEF_ERROR_CODE(0, 0x080E)
+#define TSDB_CODE_GRANT_PAR_IVLD_KEY            TAOS_DEF_ERROR_CODE(0, 0x080F)
+#define TSDB_CODE_GRANT_PAR_DEC_IVLD_KEY        TAOS_DEF_ERROR_CODE(0, 0x0810)
+#define TSDB_CODE_GRANT_PAR_DEC_IVLD_KLEN       TAOS_DEF_ERROR_CODE(0, 0x0811)
+#define TSDB_CODE_GRANT_GEN_IVLD_KEY            TAOS_DEF_ERROR_CODE(0, 0x0812)
+#define TSDB_CODE_GRANT_GEN_APP_LIMIT           TAOS_DEF_ERROR_CODE(0, 0x0813)
+#define TSDB_CODE_GRANT_GEN_ENC_IVLD_KLEN       TAOS_DEF_ERROR_CODE(0, 0x0814)
 
 // sync
 // #define TSDB_CODE_SYN_INVALID_CONFIG         TAOS_DEF_ERROR_CODE(0, 0x0900) // 2.x

include/util/tcompression.h

@@ -54,8 +54,15 @@ extern "C" {
 #ifdef TD_TSZ
 extern bool lossyFloat;
 extern bool lossyDouble;
-int32_t     tsCompressInit();
-void        tsCompressExit();
+int32_t tsCompressInit(char* lossyColumns, float fPrecision, double dPrecision, uint32_t maxIntervals, uint32_t intervals,
+                       int32_t ifAdtFse, const char* compressor);
+
+void    tsCompressExit();
+
+int32_t tsCompressFloatLossyImp(const char *const input, const int32_t nelements, char *const output);
+int32_t tsDecompressFloatLossyImp(const char *const input, int32_t compressedSize, const int32_t nelements, char *const output);
+int32_t tsCompressDoubleLossyImp(const char *const input, const int32_t nelements, char *const output);
+int32_t tsDecompressDoubleLossyImp(const char *const input, int32_t compressedSize, const int32_t nelements, char *const output);
 
 static FORCE_INLINE int32_t tsCompressFloatLossy(const char *const input, int32_t inputSize, const int32_t nelements,
                                                  char *const output, int32_t outputSize, char algorithm,

include/util/tconfig.h

@@ -43,6 +43,7 @@ typedef enum {
   CFG_DTYPE_INT32,
   CFG_DTYPE_INT64,
   CFG_DTYPE_FLOAT,
+  CFG_DTYPE_DOUBLE,
   CFG_DTYPE_STRING,
   CFG_DTYPE_DIR,
   CFG_DTYPE_LOCALE,
@@ -64,6 +65,7 @@ typedef struct SConfigItem {
   union {
     bool    bval;
     float   fval;
+    double  dval;
     int32_t i32;
     int64_t i64;
     char   *str;
@@ -101,7 +103,8 @@ int32_t      cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfg
 int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scope);
 int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval, int8_t scope);
 int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval, int8_t scope);
-int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, double minval, double maxval, int8_t scope);
+int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, float minval, float maxval, int8_t scope);
+int32_t cfgAddDouble(SConfig *pCfg, const char *name, double defaultVal, double minval, double maxval, int8_t scope);
 int32_t cfgAddString(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope);
 int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope);
 int32_t cfgAddLocale(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope);

include/util/tdef.h

@@ -322,6 +322,9 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_KEEP                   (365000 * 1440)     // data in db to be reserved.
 #define TSDB_MAX_KEEP_NS                (365 * 292 * 1440)  // data in db to be reserved.
 #define TSDB_DEFAULT_KEEP               (3650 * 1440)       // ten years
+#define TSDB_MIN_KEEP_TIME_OFFSET       0
+#define TSDB_MAX_KEEP_TIME_OFFSET       23
+#define TSDB_DEFAULT_KEEP_TIME_OFFSET   0
 #define TSDB_MIN_MINROWS_FBLOCK         10
 #define TSDB_MAX_MINROWS_FBLOCK         1000000
 #define TSDB_DEFAULT_MINROWS_FBLOCK     100

packaging/cfg/taos.cfg

@@ -108,9 +108,6 @@
 # time period of keeping log files, in days
 # logKeepDays               0
 
-# unit Hour. Latency of data migration
-# keepTimeOffset            0
-
 
 ############ 3. Debug Flag and levels #############################################
 

packaging/tools/install.sh

@@ -33,14 +33,17 @@ adapterName="taosadapter"
 benchmarkName="taosBenchmark"
 dumpName="taosdump"
 demoName="taosdemo"
+xname="taosx"
 
 clientName2="taos"
 serverName2="${clientName2}d"
 configFile2="${clientName2}.cfg"
 productName2="TDengine"
 emailName2="taosdata.com"
+xname2="${clientName2}x"
 adapterName2="${clientName2}adapter"
 
+explorerName="${clientName2}-explorer"
 benchmarkName2="${clientName2}Benchmark"
 demoName2="${clientName2}demo"
 dumpName2="${clientName2}dump"
@@ -235,6 +238,12 @@ function install_bin() {
   [ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo}ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
 
   if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    ${csudo}rm -f ${bin_link_dir}/${xname2} || :
+    ${csudo}rm -f ${bin_link_dir}/${explorerName} || :
+
+    #Make link
+    [ -x ${install_main_dir}/bin/${xname2} ] && ${csudo}ln -sf ${install_main_dir}/bin/${xname2} ${bin_link_dir}/${xname2} || :
+    [ -x ${install_main_dir}/bin/${explorerName} ] && ${csudo}ln -sf ${install_main_dir}/bin/${explorerName} ${bin_link_dir}/${explorerName} || :
     [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript2} || :
   fi
 }
@@ -693,9 +702,29 @@ function clean_service_on_systemd() {
   fi
   ${csudo}systemctl disable tarbitratord &>/dev/null || echo &>/dev/null
   ${csudo}rm -f ${tarbitratord_service_config}
-  # if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
-  #     ${csudo}rm -f ${service_config_dir}/${serverName2}.service
-  # fi
+  
+  if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    x_service_config="${service_config_dir}/${xName2}.service"
+    if [ -e "$x_service_config" ]; then
+      if systemctl is-active --quiet ${xName2}; then
+        echo "${productName2} ${xName2} is running, stopping it..."
+        ${csudo}systemctl stop ${xName2} &>/dev/null || echo &>/dev/null
+      fi
+      ${csudo}systemctl disable ${xName2} &>/dev/null || echo &>/dev/null
+      ${csudo}rm -f ${x_service_config}
+    fi
+
+    explorer_service_config="${service_config_dir}/${explorerName2}.service"
+    if [ -e "$explorer_service_config" ]; then
+      if systemctl is-active --quiet ${explorerName2}; then
+        echo "${productName2} ${explorerName2} is running, stopping it..."
+        ${csudo}systemctl stop ${explorerName2} &>/dev/null || echo &>/dev/null
+      fi
+      ${csudo}systemctl disable ${explorerName2} &>/dev/null || echo &>/dev/null
+      ${csudo}rm -f ${explorer_service_config}
+      ${csudo}rm -f /etc/${clientName2}/explorer.toml
+    fi
+  fi
 }
 
 function install_service_on_systemd() {

packaging/tools/remove.sh

@@ -123,10 +123,11 @@ function clean_bin() {
   ${csudo}rm -f ${bin_link_dir}/set_core || :
   ${csudo}rm -f ${bin_link_dir}/TDinsight.sh || :
   ${csudo}rm -f ${bin_link_dir}/${keeperName2}      || :
-  # ${csudo}rm -f ${bin_link_dir}/${xName2}           || :
-  # ${csudo}rm -f ${bin_link_dir}/${explorerName2}    || :
+  
 
   if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    ${csudo}rm -f ${bin_link_dir}/${xName2}           || :
+    ${csudo}rm -f ${bin_link_dir}/${explorerName2}    || :
     ${csudo}rm -f ${bin_link_dir}/${clientName2} || :
     ${csudo}rm -f ${bin_link_dir}/${benchmarkName2} || :
     ${csudo}rm -f ${bin_link_dir}/${dumpName2} || :
@@ -194,27 +195,29 @@ function clean_service_on_systemd() {
     ${csudo}systemctl stop ${tarbitrator_service_name} &>/dev/null || echo &>/dev/null
   fi
   ${csudo}systemctl disable ${tarbitrator_service_name} &>/dev/null || echo &>/dev/null
+  
+  if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    x_service_config="${service_config_dir}/${xName2}.service"
+    if [ -e "$x_service_config" ]; then
+      if systemctl is-active --quiet ${xName2}; then
+        echo "${productName2} ${xName2} is running, stopping it..."
+        ${csudo}systemctl stop ${xName2} &>/dev/null || echo &>/dev/null
+      fi
+      ${csudo}systemctl disable ${xName2} &>/dev/null || echo &>/dev/null
+      ${csudo}rm -f ${x_service_config}
+    fi
 
-  # x_service_config="${service_config_dir}/${xName2}.service"
-  # if [ -e "$x_service_config" ]; then
-  #   if systemctl is-active --quiet ${xName2}; then
-  #     echo "${productName2} ${xName2} is running, stopping it..."
-  #     ${csudo}systemctl stop ${xName2} &>/dev/null || echo &>/dev/null
-  #   fi
-  #   ${csudo}systemctl disable ${xName2} &>/dev/null || echo &>/dev/null
-  #   ${csudo}rm -f ${x_service_config}
-  # fi
-
-  # explorer_service_config="${service_config_dir}/${explorerName2}.service"
-  # if [ -e "$explorer_service_config" ]; then
-  #   if systemctl is-active --quiet ${explorerName2}; then
-  #     echo "${productName2} ${explorerName2} is running, stopping it..."
-  #     ${csudo}systemctl stop ${explorerName2} &>/dev/null || echo &>/dev/null
-  #   fi
-  #   ${csudo}systemctl disable ${explorerName2} &>/dev/null || echo &>/dev/null
-  #   ${csudo}rm -f ${explorer_service_config}
-  #   ${csudo}rm -f /etc/${clientName2}/explorer.toml
-  # fi
+    explorer_service_config="${service_config_dir}/${explorerName2}.service"
+    if [ -e "$explorer_service_config" ]; then
+      if systemctl is-active --quiet ${explorerName2}; then
+        echo "${productName2} ${explorerName2} is running, stopping it..."
+        ${csudo}systemctl stop ${explorerName2} &>/dev/null || echo &>/dev/null
+      fi
+      ${csudo}systemctl disable ${explorerName2} &>/dev/null || echo &>/dev/null
+      ${csudo}rm -f ${explorer_service_config}
+      ${csudo}rm -f /etc/${clientName2}/explorer.toml
+    fi
+  fi
 }
 
 function clean_service_on_sysvinit() {

source/client/inc/clientInt.h

@@ -133,33 +133,37 @@ typedef struct {
   int32_t            ver;
   void*              param;
   __taos_notify_fn_t fp;
-} SPassInfo;
+} STscNotifyInfo;
+
+typedef STscNotifyInfo SPassInfo;
 
 typedef struct {
-  int64_t ver;
-  void* param;
+  int64_t            ver;
+  void*              param;
   __taos_notify_fn_t fp;
 } SWhiteListInfo;
 
 typedef struct STscObj {
-  char          user[TSDB_USER_LEN];
-  char          pass[TSDB_PASSWORD_LEN];
-  char          db[TSDB_DB_FNAME_LEN];
-  char          sVer[TSDB_VERSION_LEN];
-  char          sDetailVer[128];
-  int8_t        sysInfo;
-  int8_t        connType;
-  int32_t       acctId;
-  uint32_t      connId;
-  int64_t       id;         // ref ID returned by taosAddRef
-  TdThreadMutex mutex;      // used to protect the operation on db
-  int32_t       numOfReqs;  // number of sqlObj bound to this connection
-  int32_t       authVer;
-  SAppInstInfo* pAppInfo;
-  SHashObj*     pRequests;
-  SPassInfo     passInfo;
+  char           user[TSDB_USER_LEN];
+  char           pass[TSDB_PASSWORD_LEN];
+  char           db[TSDB_DB_FNAME_LEN];
+  char           sVer[TSDB_VERSION_LEN];
+  char           sDetailVer[128];
+  int8_t         sysInfo;
+  int8_t         connType;
+  int8_t         dropped;
+  int8_t         biMode;
+  int32_t        acctId;
+  uint32_t       connId;
+  int64_t        id;         // ref ID returned by taosAddRef
+  TdThreadMutex  mutex;      // used to protect the operation on db
+  int32_t        numOfReqs;  // number of sqlObj bound to this connection
+  int32_t        authVer;
+  SAppInstInfo*  pAppInfo;
+  SHashObj*      pRequests;
+  SPassInfo      passInfo;
   SWhiteListInfo whiteListInfo;
-  int8_t        biMode;
+  STscNotifyInfo userDroppedInfo;
 } STscObj;
 
 typedef struct STscDbg {

source/client/src/clientHb.c

@@ -96,6 +96,19 @@ static int32_t hbUpdateUserAuthInfo(SAppHbMgr *pAppHbMgr, SUserAuthBatchRsp *bat
         }
       }
 
+      if (pRsp->dropped == 1) {
+        if (atomic_val_compare_exchange_8(&pTscObj->dropped, 0, 1) == 0) {
+          if (pTscObj->userDroppedInfo.fp) {
+            SPassInfo *dropInfo = &pTscObj->userDroppedInfo;
+            if (dropInfo->fp) {
+              (*dropInfo->fp)(dropInfo->param, NULL, TAOS_NOTIFY_USER_DROPPED);
+            }
+          }
+        }
+        releaseTscObj(pReq->connKey.tscRid);
+        continue;
+      }
+
       pTscObj->authVer = pRsp->version;
 
       if (pTscObj->sysInfo != pRsp->sysInfo) {
@@ -842,7 +855,8 @@ SClientHbBatchReq *hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
     SClientHbKey *connKey = &pOneReq->connKey;
     STscObj      *pTscObj = (STscObj *)acquireTscObj(connKey->tscRid);
 
-    if (!pTscObj) {
+    if (!pTscObj || atomic_load_8(&pTscObj->dropped) == 1) {
+      if (pTscObj) releaseTscObj(connKey->tscRid);
       continue;
     }
 

source/client/src/clientImpl.c

@@ -297,7 +297,8 @@ int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtC
 
 int32_t execLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
   SRetrieveTableRsp* pRsp = NULL;
-  int32_t            code = qExecCommand(&pRequest->pTscObj->id, pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp, pRequest->pTscObj->biMode);
+  int8_t biMode = atomic_load_8(&pRequest->pTscObj->biMode);
+  int32_t            code = qExecCommand(&pRequest->pTscObj->id, pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp, biMode);
   if (TSDB_CODE_SUCCESS == code && NULL != pRsp) {
     code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp, false, true);
   }
@@ -2553,6 +2554,14 @@ static void fetchCallback(void* pResult, void* param, int32_t code) {
 }
 
 void taosAsyncFetchImpl(SRequestObj* pRequest, __taos_async_fn_t fp, void* param) {
+  if (pRequest->syncQuery && pRequest->body.param != param) {
+    if (pRequest->body.param) {
+      tsem_destroy(&((SSyncQueryParam *)pRequest->body.param)->sem);
+    }
+    taosMemoryFree(pRequest->body.param);
+    pRequest->syncQuery = false;
+  }
+  
   pRequest->body.fetchFp = fp;
   pRequest->body.param = param;
 

source/client/src/clientMain.c

@@ -147,6 +147,13 @@ int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type)
       taosThreadMutexUnlock(&pObj->mutex);
       break;
     }
+    case TAOS_NOTIFY_USER_DROPPED: {
+      taosThreadMutexLock(&pObj->mutex);
+      pObj->userDroppedInfo.fp = fp;
+      pObj->userDroppedInfo.param = param;
+      taosThreadMutexUnlock(&pObj->mutex);
+      break;
+    }
     default: {
       terrno = TSDB_CODE_INVALID_PARA;
       releaseTscObj(*(int64_t *)taos);
@@ -1832,7 +1839,7 @@ int taos_stmt_close(TAOS_STMT *stmt) {
   return stmtClose(stmt);
 }
 
-int taos_set_mode(TAOS* taos, int mode, int value) {
+int taos_set_conn_mode(TAOS* taos, int mode, int value) {
   if (taos == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
@@ -1848,6 +1855,9 @@ int taos_set_mode(TAOS* taos, int mode, int value) {
     case TAOS_CONN_MODE_BI:
       atomic_store_8(&pObj->biMode, value);
       break;
+    default:
+      tscError("not supported mode.");
+      return TSDB_CODE_INVALID_PARA;
   }
   return 0;
 }

source/client/src/clientRawBlockWrite.c

@@ -1411,7 +1411,7 @@ int taos_write_raw_block_with_fields(TAOS* taos, int rows, char* pData, const ch
   code = smlBuildOutput(pQuery, pVgHash);
   if (code != TSDB_CODE_SUCCESS) {
     uError("smlBuildOutput failed");
-    return code;
+    goto end;
   }
 
   launchQueryImpl(pRequest, pQuery, true, NULL);
@@ -1496,7 +1496,7 @@ int taos_write_raw_block(TAOS* taos, int rows, char* pData, const char* tbname)
   code = smlBuildOutput(pQuery, pVgHash);
   if (code != TSDB_CODE_SUCCESS) {
     uError("smlBuildOutput failed");
-    return code;
+    goto end;
   }
 
   launchQueryImpl(pRequest, pQuery, true, NULL);

source/client/src/clientTmq.c

@@ -1415,6 +1415,8 @@ static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopic
     STqOffsetVal offsetNew = {0};
     offsetNew.type = tmq->resetOffsetCfg;
 
+    tscInfo("consumer:0x%" PRIx64 ", update topic:%s, new numOfVgs:%d, num:%d, port:%d", tmq->consumerId, pTopic->topicName, vgNumGet, pVgEp->epSet.numOfEps,pVgEp->epSet.eps[pVgEp->epSet.inUse].port);
+
     SMqClientVg clientVg = {
         .pollCnt = 0,
         .vgId = pVgEp->vgId,
@@ -1766,7 +1768,7 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
         tscError("consumer:0x%" PRIx64 " msg from vgId:%d discarded, since %s", tmq->consumerId, pollRspWrapper->vgId, tstrerror(pRspWrapper->code));
         taosWLockLatch(&tmq->lock);
         SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
-        pVg->emptyBlockReceiveTs = taosGetTimestampMs();
+        if(pVg) pVg->emptyBlockReceiveTs = taosGetTimestampMs();
         taosWUnLockLatch(&tmq->lock);
       }
       setVgIdle(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
@@ -3104,3 +3106,10 @@ int32_t tmq_offset_seek(tmq_t* tmq, const char* pTopicName, int32_t vgId, int64_
 
   return code;
 }
+
+TAOS *tmq_get_connect(tmq_t *tmq){
+  if (tmq && tmq->pTscObj) {
+    return (TAOS *)(&(tmq->pTscObj->id));
+  }
+  return NULL;
+}

source/common/src/systable.c

@@ -106,6 +106,7 @@ static const SSysDbTableSchema userDBSchema[] = {
     {.name = "table_prefix", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
     {.name = "table_suffix", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
     {.name = "tsdb_pagesize", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
+    {.name = "keep_time_offset", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
 };
 
 static const SSysDbTableSchema userFuncSchema[] = {
@@ -309,7 +310,7 @@ static const SSysDbTableSchema userUserPrivilegesSchema[] = {
     {.name = "privilege", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
     {.name = "db_name", .bytes = TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
     {.name = "table_name", .bytes = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
-    {.name = "condition", .bytes = TSDB_PRIVILEDGE_CONDITION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false}, 
+    {.name = "condition", .bytes = TSDB_PRIVILEDGE_CONDITION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
 static const SSysTableMeta infosMeta[] = {

source/common/src/tdataformat.c

@@ -1557,11 +1557,13 @@ STSchema *tBuildTSchema(SSchema *aSchema, int32_t numOfCols, int32_t version) {
 
 // SColData ========================================
 void tColDataDestroy(void *ph) {
-  SColData *pColData = (SColData *)ph;
+  if (ph) {
+    SColData *pColData = (SColData *)ph;
 
-  tFree(pColData->pBitMap);
-  tFree(pColData->aOffset);
-  tFree(pColData->pData);
+    tFree(pColData->pBitMap);
+    tFree(pColData->aOffset);
+    tFree(pColData->pData);
+  }
 }
 
 void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) {

source/common/src/tglobal.c

@@ -20,6 +20,7 @@
 #include "tgrant.h"
 #include "tlog.h"
 #include "tmisce.h"
+#include "defines.h"
 
 #if defined(CUS_NAME) || defined(CUS_PROMPT) || defined(CUS_EMAIL)
 #include "cus_name.h"
@@ -144,6 +145,7 @@ bool    tsUseAdapter = false;
 int32_t tsMetaCacheMaxSize = -1;  // MB
 int32_t tsSlowLogThreshold = 3;   // seconds
 int32_t tsSlowLogScope = SLOW_LOG_TYPE_ALL;
+int32_t tsTimeSeriesThreshold = 50;
 
 /*
  * denote if the server needs to compress response message at the application layer to client, including query rsp,
@@ -211,14 +213,15 @@ int64_t tsTickPerMin[] = {60000L, 60000000L, 60000000000L};
  */
 int64_t tsTickPerHour[] = {3600000L, 3600000000L, 3600000000000L};
 
-// lossy compress 6
+// lossy compress 7
 char tsLossyColumns[32] = "";  // "float|double" means all float and double columns can be lossy compressed.  set empty
                                // can close lossy compress.
 // below option can take effect when tsLossyColumns not empty
-double   tsFPrecision = 1E-8;                   // float column precision
+float    tsFPrecision = 1E-8;                   // float column precision
 double   tsDPrecision = 1E-16;                  // double column precision
-uint32_t tsMaxRange = 500;                      // max range
-uint32_t tsCurRange = 100;                      // range
+uint32_t tsMaxRange = 500;                      // max quantization intervals
+uint32_t tsCurRange = 100;                      // current quantization intervals
+bool     tsIfAdtFse = false;                     // ADT-FSE algorithom or original huffman algorithom
 char     tsCompressor[32] = "ZSTD_COMPRESSOR";  // ZSTD_COMPRESSOR or GZIP_COMPRESSOR
 
 // udf
@@ -253,7 +256,6 @@ char    tsUdfdLdLibPath[512] = "";
 bool    tsDisableStream = false;
 int64_t tsStreamBufferSize = 128 * 1024 * 1024;
 bool    tsFilterScalarMode = false;
-int32_t tsKeepTimeOffset = 0;          // latency of data migration
 int     tsResolveFQDNRetryTime = 100;  // seconds
 
 char   tsS3Endpoint[TSDB_FQDN_LEN] = "<endpoint>";
@@ -264,6 +266,9 @@ char   tsS3BucketName[TSDB_FQDN_LEN] = "<bucketname>";
 char   tsS3AppId[TSDB_FQDN_LEN] = "<appid>";
 int8_t tsS3Enabled = false;
 
+int32_t tsS3BlockSize = 4096;     // number of tsdb pages
+int32_t tsS3BlockCacheSize = 16;  // number of blocks
+
 int32_t tsCheckpointInterval = 20;
 
 #ifndef _STORAGE
@@ -321,7 +326,9 @@ int32_t taosSetS3Cfg(SConfig *pCfg) {
   return 0;
 }
 
-struct SConfig *taosGetCfg() { return tsCfg; }
+struct SConfig *taosGetCfg() {
+  return tsCfg;
+}
 
 static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile,
                            char *apolloUrl) {
@@ -630,6 +637,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "trimVDbIntervalSec", tsTrimVDbIntervalSec, 1, 100000, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "uptimeInterval", tsUptimeInterval, 1, 100000, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "queryRsmaTolerance", tsQueryRsmaTolerance, 0, 900000, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "timeseriesThreshold", tsTimeSeriesThreshold, 0, 2000, CFG_SCOPE_SERVER) != 0) return -1;
 
   if (cfgAddInt64(pCfg, "walFsyncDataSizeLimit", tsWalFsyncDataSizeLimit, 100 * 1024 * 1024, INT64_MAX,
                   CFG_SCOPE_SERVER) != 0)
@@ -646,8 +654,15 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "cacheLazyLoadThreshold", tsCacheLazyLoadThreshold, 0, 100000, CFG_SCOPE_SERVER) != 0)
     return -1;
 
+  if (cfgAddString(pCfg, "LossyColumns", tsLossyColumns, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddFloat(pCfg, "FPrecision", tsFPrecision, 0.0f, 100000.0f, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddDouble(pCfg, "DPrecision", tsDPrecision, 0.0f, 1000000.0f, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "MaxRange", tsMaxRange, 0, 65536, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "CurRange", tsCurRange, 0, 65536, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddBool(pCfg, "IfAdtFse", tsIfAdtFse, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddString(pCfg, "Compressor", tsCompressor, CFG_SCOPE_SERVER) != 0) return -1;
+
   if (cfgAddBool(pCfg, "filterScalarMode", tsFilterScalarMode, CFG_SCOPE_SERVER) != 0) return -1;
-  if (cfgAddInt32(pCfg, "keepTimeOffset", tsKeepTimeOffset, 0, 23, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxStreamBackendCache", tsMaxStreamBackendCache, 16, 1024, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "pqSortMemThreshold", tsPQSortMemThreshold, 1, 10240, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddInt32(pCfg, "resolveFQDNRetryTime", tsResolveFQDNRetryTime, 1, 10240, 0) != 0) return -1;
@@ -655,6 +670,8 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddString(pCfg, "s3Accesskey", tsS3AccessKey, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddString(pCfg, "s3Endpoint", tsS3Endpoint, CFG_SCOPE_SERVER) != 0) return -1;
   if (cfgAddString(pCfg, "s3BucketName", tsS3BucketName, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "s3BlockSize", tsS3BlockSize, 2048, 1024 * 1024, CFG_SCOPE_SERVER) != 0) return -1;
+  if (cfgAddInt32(pCfg, "s3BlockCacheSize", tsS3BlockCacheSize, 4, 1024 * 1024, CFG_SCOPE_SERVER) != 0) return -1;
 
   // min free disk space used to check if the disk is full [50MB, 1GB]
   if (cfgAddInt64(pCfg, "minDiskFreeSize", tsMinDiskFreeSize, TFS_MIN_DISK_FREE_SIZE, 1024 * 1024 * 1024,
@@ -1036,6 +1053,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsTrimVDbIntervalSec = cfgGetItem(pCfg, "trimVDbIntervalSec")->i32;
   tsUptimeInterval = cfgGetItem(pCfg, "uptimeInterval")->i32;
   tsQueryRsmaTolerance = cfgGetItem(pCfg, "queryRsmaTolerance")->i32;
+  tsTimeSeriesThreshold = cfgGetItem(pCfg, "timeseriesThreshold")->i32;
 
   tsWalFsyncDataSizeLimit = cfgGetItem(pCfg, "walFsyncDataSizeLimit")->i64;
 
@@ -1060,16 +1078,27 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
 
   tsCacheLazyLoadThreshold = cfgGetItem(pCfg, "cacheLazyLoadThreshold")->i32;
 
+  tstrncpy(tsLossyColumns, cfgGetItem(pCfg, "LossyColumns")->str, sizeof(tsLossyColumns));
+  tsFPrecision = cfgGetItem(pCfg, "FPrecision")->fval;
+  tsDPrecision = cfgGetItem(pCfg, "DPrecision")->dval;
+  tsMaxRange = cfgGetItem(pCfg, "MaxRange")->i32;
+  tsCurRange = cfgGetItem(pCfg, "CurRange")->i32;
+  tsIfAdtFse = cfgGetItem(pCfg, "IfAdtFse")->bval;
+  tstrncpy(tsCompressor, cfgGetItem(pCfg, "Compressor")->str, sizeof(tsCompressor));
+
+
   tsDisableStream = cfgGetItem(pCfg, "disableStream")->bval;
   tsStreamBufferSize = cfgGetItem(pCfg, "streamBufferSize")->i64;
 
   tsFilterScalarMode = cfgGetItem(pCfg, "filterScalarMode")->bval;
-  tsKeepTimeOffset = cfgGetItem(pCfg, "keepTimeOffset")->i32;
   tsMaxStreamBackendCache = cfgGetItem(pCfg, "maxStreamBackendCache")->i32;
   tsPQSortMemThreshold = cfgGetItem(pCfg, "pqSortMemThreshold")->i32;
   tsResolveFQDNRetryTime = cfgGetItem(pCfg, "resolveFQDNRetryTime")->i32;
   tsMinDiskFreeSize = cfgGetItem(pCfg, "minDiskFreeSize")->i64;
 
+  tsS3BlockSize = cfgGetItem(pCfg, "s3BlockSize")->i32;
+  tsS3BlockCacheSize = cfgGetItem(pCfg, "s3BlockCacheSize")->i32;
+
   GRANT_CFG_GET;
   return 0;
 }
@@ -1448,6 +1477,8 @@ int32_t taosApplyLocalCfg(SConfig *pCfg, char *name) {
         tqDebugFlag = cfgGetItem(pCfg, "tqDebugFlag")->i32;
       } else if (strcasecmp("ttlFlushThreshold", name) == 0) {
         tsTtlFlushThreshold = cfgGetItem(pCfg, "ttlFlushThreshold")->i32;
+      } else if (strcasecmp("timeseriesThreshold", name) == 0) {
+        tsTimeSeriesThreshold = cfgGetItem(pCfg, "timeseriesThreshold")->i32;
       }
       break;
     }
@@ -1643,10 +1674,17 @@ void taosCfgDynamicOptions(const char *option, const char *value) {
     return;
   }
 
-  if (strcasecmp(option, "keepTimeOffset") == 0) {
-    int32_t newKeepTimeOffset = atoi(value);
-    uInfo("keepTimeOffset set from %d to %d", tsKeepTimeOffset, newKeepTimeOffset);
-    tsKeepTimeOffset = newKeepTimeOffset;
+  if (strcasecmp(option, "s3BlockSize") == 0) {
+    int32_t newS3BlockSize = atoi(value);
+    uInfo("s3BlockSize set from %d to %d", tsS3BlockSize, newS3BlockSize);
+    tsS3BlockSize = newS3BlockSize;
+    return;
+  }
+
+  if (strcasecmp(option, "s3BlockCacheSize") == 0) {
+    int32_t newS3BlockCacheSize = atoi(value);
+    uInfo("s3BlockCacheSize set from %d to %d", tsS3BlockCacheSize, newS3BlockCacheSize);
+    tsS3BlockCacheSize = newS3BlockCacheSize;
     return;
   }
 

source/common/src/tmsg.c

@@ -1035,6 +1035,68 @@ int32_t tDeserializeSMDropFullTextReq(void *buf, int32_t bufLen, SMDropFullTextR
   return 0;
 }
 
+int32_t tSerializeSNotifyReq(void *buf, int32_t bufLen, SNotifyReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+
+  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->clusterId) < 0) return -1;
+
+  int32_t nVgroup = taosArrayGetSize(pReq->pVloads);
+  if (tEncodeI32(&encoder, nVgroup) < 0) return -1;
+  for (int32_t i = 0; i < nVgroup; ++i) {
+    SVnodeLoadLite *vload = TARRAY_GET_ELEM(pReq->pVloads, i);
+    if (tEncodeI32(&encoder, vload->vgId) < 0) return -1;
+    if (tEncodeI64(&encoder, vload->nTimeSeries) < 0) return -1;
+  }
+
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSNotifyReq(void *buf, int32_t bufLen, SNotifyReq *pReq) {
+  int32_t  code = TSDB_CODE_INVALID_MSG;
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) goto _exit;
+  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) goto _exit;
+  if (tDecodeI64(&decoder, &pReq->clusterId) < 0) goto _exit;
+  int32_t nVgroup = 0;
+  if (tDecodeI32(&decoder, &nVgroup) < 0) goto _exit;
+  if (nVgroup > 0) {
+    pReq->pVloads = taosArrayInit(nVgroup, sizeof(SVnodeLoadLite));
+    if (!pReq->pVloads) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
+    for (int32_t i = 0; i < nVgroup; ++i) {
+      SVnodeLoadLite vload;
+      if (tDecodeI32(&decoder, &(vload.vgId)) < 0) goto _exit;
+      if (tDecodeI64(&decoder, &(vload.nTimeSeries)) < 0) goto _exit;
+      taosArrayPush(pReq->pVloads, &vload);
+    }
+  }
+
+  code = 0;
+  
+_exit:
+  tEndDecode(&decoder);
+  tDecoderClear(&decoder);
+  return code;
+}
+
+void tFreeSNotifyReq(SNotifyReq *pReq) {
+  if (pReq) {
+    taosArrayDestroy(pReq->pVloads);
+  }
+}
+
 int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
@@ -1652,7 +1714,7 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
   if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1;
   if (tEncodeI8(pEncoder, pRsp->sysInfo) < 0) return -1;
   if (tEncodeI8(pEncoder, pRsp->enable) < 0) return -1;
-  if (tEncodeI8(pEncoder, pRsp->reserve) < 0) return -1;
+  if (tEncodeI8(pEncoder, pRsp->dropped) < 0) return -1;
   if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1;
 
   int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
@@ -1767,7 +1829,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
   if (tDecodeI8(pDecoder, &pRsp->superAuth) < 0) goto _err;
   if (tDecodeI8(pDecoder, &pRsp->sysInfo) < 0) goto _err;
   if (tDecodeI8(pDecoder, &pRsp->enable) < 0) goto _err;
-  if (tDecodeI8(pDecoder, &pRsp->reserve) < 0) goto _err;
+  if (tDecodeI8(pDecoder, &pRsp->dropped) < 0) goto _err;
   if (tDecodeI32(pDecoder, &pRsp->version) < 0) goto _err;
 
   int32_t numOfCreatedDbs = 0;
@@ -2632,6 +2694,7 @@ int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
     if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
   }
   if (tEncodeI32(&encoder, pReq->tsdbPageSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -2694,6 +2757,11 @@ int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq)
 
   if (tDecodeI32(&decoder, &pReq->tsdbPageSize) < 0) return -1;
 
+  pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -2731,6 +2799,7 @@ int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
   // 2nd modification
   if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->walRetentionSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -2774,6 +2843,10 @@ int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
     pReq->walRetentionPeriod = -1;
     pReq->walRetentionSize = -1;
   }
+  pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1;
+  }
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -3400,6 +3473,7 @@ int32_t tDeserializeSVTrimDbReq(void *buf, int32_t bufLen, SVTrimDbReq *pReq) {
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->timestamp) < 0) return -1;
+
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -3501,6 +3575,7 @@ int32_t tSerializeSDbCfgRspImpl(SEncoder *encoder, const SDbCfgRsp *pRsp) {
   }
   if (tEncodeI8(encoder, pRsp->schemaless) < 0) return -1;
   if (tEncodeI16(encoder, pRsp->sstTrigger) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->keepTimeOffset) < 0) return -1;
 
   return 0;
 }
@@ -3569,6 +3644,10 @@ int32_t tDeserializeSDbCfgRspImpl(SDecoder *decoder, SDbCfgRsp *pRsp) {
   }
   if (tDecodeI8(decoder, &pRsp->schemaless) < 0) return -1;
   if (tDecodeI16(decoder, &pRsp->sstTrigger) < 0) return -1;
+  pRsp->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
+  if (!tDecodeIsEnd(decoder)) {
+    if (tDecodeI32(decoder, &pRsp->keepTimeOffset) < 0) return -1;
+  }
 
   return 0;
 }
@@ -4618,6 +4697,7 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
     if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
   }
   if (tEncodeI32(&encoder, pReq->changeVersion) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1;
 
   tEndEncode(&encoder);
 
@@ -4707,6 +4787,10 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
   if (!tDecodeIsEnd(&decoder)) {
     if (tDecodeI32(&decoder, &pReq->changeVersion) < 0) return -1;
   }
+  pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1;
+  }
 
   tEndDecode(&decoder);
   tDecoderClear(&decoder);
@@ -4866,6 +4950,7 @@ int32_t tSerializeSAlterVnodeConfigReq(void *buf, int32_t bufLen, SAlterVnodeCon
   // 2nd modification
   if (tEncodeI32(&encoder, pReq->walRetentionPeriod) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->walRetentionSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->keepTimeOffset) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -4912,6 +4997,11 @@ int32_t tDeserializeSAlterVnodeConfigReq(void *buf, int32_t bufLen, SAlterVnodeC
     if (tDecodeI32(&decoder, &pReq->walRetentionPeriod) < 0) return -1;
     if (tDecodeI32(&decoder, &pReq->walRetentionSize) < 0) return -1;
   }
+  pReq->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI32(&decoder, &pReq->keepTimeOffset) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
   tDecoderClear(&decoder);
   return 0;

source/dnode/mgmt/mgmt_dnode/CMakeLists.txt

@@ -3,11 +3,22 @@ add_library(mgmt_dnode STATIC ${MGMT_DNODE})
 if (DEFINED GRANT_CFG_INCLUDE_DIR)
   add_definitions(-DGRANTS_CFG)
 endif()
+
+IF (NOT BUILD_DM_MODULE)
+  MESSAGE(STATUS "NOT BUILD_DM_MODULE")
+  target_link_directories(
+    mgmt_dnode
+    PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/dm_static"
+  )
+ELSE()
+  MESSAGE(STATUS "BUILD_DM_MODULE")  
+ENDIF()
+
 target_include_directories(
     mgmt_dnode
     PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
     PUBLIC "${GRANT_CFG_INCLUDE_DIR}"
 )
 target_link_libraries(
-    mgmt_dnode node_util
+    mgmt_dnode node_util dmodule
 )

source/dnode/mgmt/mgmt_dnode/inc/dmInt.h

@@ -28,6 +28,7 @@ typedef struct SDnodeMgmt {
   const char            *path;
   const char            *name;
   TdThread               statusThread;
+  TdThread               notifyThread;
   TdThread               monitorThread;
   TdThread               crashReportThread;
   SSingleWorker          mgmtWorker;
@@ -36,6 +37,7 @@ typedef struct SDnodeMgmt {
   ProcessDropNodeFp      processDropNodeFp;
   SendMonitorReportFp    sendMonitorReportFp;
   GetVnodeLoadsFp        getVnodeLoadsFp;
+  GetVnodeLoadsFp        getVnodeLoadsLiteFp;
   GetMnodeLoadsFp        getMnodeLoadsFp;
   GetQnodeLoadsFp        getQnodeLoadsFp;
   int32_t                statusSeq;
@@ -44,17 +46,21 @@ typedef struct SDnodeMgmt {
 // dmHandle.c
 SArray *dmGetMsgHandles();
 void    dmSendStatusReq(SDnodeMgmt *pMgmt);
+void    dmSendNotifyReq(SDnodeMgmt *pMgmt);
 int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmProcessRetrieve(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmProcessGrantReq(void *pInfo, SRpcMsg *pMsg);
+int32_t dmProcessGrantNotify(void *pInfo, SRpcMsg *pMsg);
 
 // dmWorker.c
 int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);
 int32_t dmStartStatusThread(SDnodeMgmt *pMgmt);
 void    dmStopStatusThread(SDnodeMgmt *pMgmt);
+int32_t dmStartNotifyThread(SDnodeMgmt *pMgmt);
+void    dmStopNotifyThread(SDnodeMgmt *pMgmt);
 int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt);
 void    dmStopMonitorThread(SDnodeMgmt *pMgmt);
 int32_t dmStartCrashReportThread(SDnodeMgmt *pMgmt);

source/dnode/mgmt/mgmt_dnode/src/dmHandle.c

@@ -170,6 +170,36 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   dmProcessStatusRsp(pMgmt, &rpcRsp);
 }
 
+void dmSendNotifyReq(SDnodeMgmt *pMgmt) {
+  SNotifyReq req = {0};
+
+  taosThreadRwlockRdlock(&pMgmt->pData->lock);
+  req.dnodeId = pMgmt->pData->dnodeId;
+  taosThreadRwlockUnlock(&pMgmt->pData->lock);
+
+  req.clusterId = pMgmt->pData->clusterId;
+
+  SMonVloadInfo vinfo = {0};
+  (*pMgmt->getVnodeLoadsLiteFp)(&vinfo);
+  req.pVloads = vinfo.pVloads;
+
+  int32_t contLen = tSerializeSNotifyReq(NULL, 0, &req);
+  void   *pHead = rpcMallocCont(contLen);
+  tSerializeSNotifyReq(pHead, contLen, &req);
+  tFreeSNotifyReq(&req);
+
+  SRpcMsg rpcMsg = {.pCont = pHead,
+                    .contLen = contLen,
+                    .msgType = TDMT_MND_NOTIFY,
+                    .info.ahandle = (void *)0x9527,
+                    .info.refId = 0,
+                    .info.noResp = 1};
+
+  SEpSet epSet = {0};
+  dmGetMnodeEpSet(pMgmt->pData, &epSet);
+  rpcSendRequest(pMgmt->msgCb.clientRpc, &epSet, &rpcMsg, NULL);
+}
+
 int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   dError("auth rsp is received, but not supported yet");
   return 0;
@@ -395,6 +425,7 @@ SArray *dmGetMsgHandles() {
 
   // Requests handled by MNODE
   if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT_NOTIFY, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_AUTH_RSP, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
 
   code = 0;

source/dnode/mgmt/mgmt_dnode/src/dmInt.c

@@ -15,11 +15,17 @@
 
 #define _DEFAULT_SOURCE
 #include "dmInt.h"
+#include "libs/function/tudf.h"
 
 static int32_t dmStartMgmt(SDnodeMgmt *pMgmt) {
   if (dmStartStatusThread(pMgmt) != 0) {
     return -1;
   }
+#if defined(TD_ENTERPRISE) && !defined(_TD_DARWIN_64)
+  if (dmStartNotifyThread(pMgmt) != 0) {
+    return -1;
+  }
+#endif
   if (dmStartMonitorThread(pMgmt) != 0) {
     return -1;
   }
@@ -33,6 +39,7 @@ static void dmStopMgmt(SDnodeMgmt *pMgmt) {
   pMgmt->pData->stopped = true;
   dmStopMonitorThread(pMgmt);
   dmStopStatusThread(pMgmt);
+  dmStopNotifyThread(pMgmt);
   dmStopCrashReportThread(pMgmt);
 }
 
@@ -52,6 +59,7 @@ static int32_t dmOpenMgmt(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   pMgmt->processDropNodeFp = pInput->processDropNodeFp;
   pMgmt->sendMonitorReportFp = pInput->sendMonitorReportFp;
   pMgmt->getVnodeLoadsFp = pInput->getVnodeLoadsFp;
+  pMgmt->getVnodeLoadsLiteFp = pInput->getVnodeLoadsLiteFp;
   pMgmt->getMnodeLoadsFp = pInput->getMnodeLoadsFp;
   pMgmt->getQnodeLoadsFp = pInput->getQnodeLoadsFp;
 

source/dnode/mgmt/mgmt_dnode/src/dmWorker.c

@@ -53,6 +53,31 @@ static void *dmStatusThreadFp(void *param) {
   return NULL;
 }
 
+SDmNotifyHandle dmNotifyHdl = {.state = 0};
+static void    *dmNotifyThreadFp(void *param) {
+  SDnodeMgmt *pMgmt = param;
+  setThreadName("dnode-notify");
+
+  if (tsem_init(&dmNotifyHdl.sem, 0, 0) != 0) {
+    return NULL;
+  }
+
+  bool wait = true;
+  while (1) {
+    if (pMgmt->pData->dropped || pMgmt->pData->stopped) break;
+    if (wait) tsem_wait(&dmNotifyHdl.sem);
+    atomic_store_8(&dmNotifyHdl.state, 1);
+    dmSendNotifyReq(pMgmt);
+    if (1 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 0)) {
+      wait = true;
+      continue;
+    }
+    wait = false;
+  }
+
+  return NULL;
+}
+
 static void *dmMonitorThreadFp(void *param) {
   SDnodeMgmt *pMgmt = param;
   int64_t     lastTime = taosGetTimestampMs();
@@ -132,7 +157,6 @@ static void *dmCrashReportThreadFp(void *param) {
   return NULL;
 }
 
-
 int32_t dmStartStatusThread(SDnodeMgmt *pMgmt) {
   TdThreadAttr thAttr;
   taosThreadAttrInit(&thAttr);
@@ -154,6 +178,29 @@ void dmStopStatusThread(SDnodeMgmt *pMgmt) {
   }
 }
 
+int32_t dmStartNotifyThread(SDnodeMgmt *pMgmt) {
+  TdThreadAttr thAttr;
+  taosThreadAttrInit(&thAttr);
+  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  if (taosThreadCreate(&pMgmt->notifyThread, &thAttr, dmNotifyThreadFp, pMgmt) != 0) {
+    dError("failed to create notify thread since %s", strerror(errno));
+    return -1;
+  }
+
+  taosThreadAttrDestroy(&thAttr);
+  tmsgReportStartup("dnode-notify", "initialized");
+  return 0;
+}
+
+void dmStopNotifyThread(SDnodeMgmt *pMgmt) {
+  if (taosCheckPthreadValid(pMgmt->notifyThread)) {
+    tsem_post(&dmNotifyHdl.sem);
+    taosThreadJoin(pMgmt->notifyThread, NULL);
+    taosThreadClear(&pMgmt->notifyThread);
+  }
+  tsem_destroy(&dmNotifyHdl.sem);
+}
+
 int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) {
   TdThreadAttr thAttr;
   taosThreadAttrInit(&thAttr);
@@ -204,7 +251,6 @@ void dmStopCrashReportThread(SDnodeMgmt *pMgmt) {
   }
 }
 
-
 static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   SDnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
@@ -251,6 +297,9 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
     case TDMT_MND_GRANT:
       code = dmProcessGrantReq(&pMgmt->pData->clusterId, pMsg);
       break;
+    case TDMT_MND_GRANT_NOTIFY:
+      code = dmProcessGrantNotify(NULL, pMsg);
+      break;
     default:
       terrno = TSDB_CODE_MSG_NOT_PROCESSED;
       dGError("msg:%p, not processed in mgmt queue", pMsg);

source/dnode/mgmt/mgmt_mnode/src/mmHandle.c

@@ -178,6 +178,7 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_MND_KILL_CONN, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_HEARTBEAT, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_STATUS, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_NOTIFY, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_SYSTABLE_RETRIEVE, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_AUTH, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_SHOW_VARIABLES, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;

source/dnode/mgmt/mgmt_qnode/src/qmInt.c

@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "qmInt.h"
+#include "libs/function/tudf.h"
 
 static int32_t qmRequire(const SMgmtInputOpt *pInput, bool *required) {
   return dmReadFile(pInput->path, pInput->name, required);

source/dnode/mgmt/mgmt_snode/src/smInt.c

@@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "smInt.h"
 #include "libs/function/function.h"
+#include "libs/function/tudf.h"
 
 static int32_t smRequire(const SMgmtInputOpt *pInput, bool *required) {
   return dmReadFile(pInput->path, pInput->name, required);

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -40,6 +40,28 @@ void vmGetVnodeLoads(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo, bool isReset) {
   taosThreadRwlockUnlock(&pMgmt->lock);
 }
 
+void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) {
+  pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoadLite));
+  if (!pInfo->pVloads) return;
+
+  taosThreadRwlockRdlock(&pMgmt->lock);
+
+  void *pIter = taosHashIterate(pMgmt->hash, NULL);
+  while (pIter) {
+    SVnodeObj **ppVnode = pIter;
+    if (ppVnode == NULL || *ppVnode == NULL) continue;
+
+    SVnodeObj     *pVnode = *ppVnode;
+    SVnodeLoadLite vload = {0};
+    if (vnodeGetLoadLite(pVnode->pImpl, &vload) == 0) {
+      taosArrayPush(pInfo->pVloads, &vload);
+    }
+    pIter = taosHashIterate(pMgmt->hash, pIter);
+  }
+
+  taosThreadRwlockUnlock(&pMgmt->lock);
+}
+
 void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) {
   SMonVloadInfo vloads = {0};
   vmGetVnodeLoads(pMgmt, &vloads, true);
@@ -104,6 +126,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->tsdbCfg.keep0 = pCreate->daysToKeep0;
   pCfg->tsdbCfg.keep1 = pCreate->daysToKeep1;
   pCfg->tsdbCfg.keep2 = pCreate->daysToKeep2;
+  pCfg->tsdbCfg.keepTimeOffset = pCreate->keepTimeOffset;
   pCfg->tsdbCfg.minRows = pCreate->minRows;
   pCfg->tsdbCfg.maxRows = pCreate->maxRows;
   for (size_t i = 0; i < taosArrayGetSize(pCreate->pRetensions); ++i) {
@@ -209,15 +232,15 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   dInfo(
       "vgId:%d, vnode management handle msgType:%s, start to create vnode, page:%d pageSize:%d buffer:%d szPage:%d "
       "szBuf:%" PRIu64 ", cacheLast:%d cacheLastSize:%d sstTrigger:%d tsdbPageSize:%d %d dbname:%s dbId:%" PRId64
-      ", days:%d keep0:%d keep1:%d keep2:%d tsma:%d precision:%d compression:%d minRows:%d maxRows:%d"
+      ", days:%d keep0:%d keep1:%d keep2:%d keepTimeOffset%d tsma:%d precision:%d compression:%d minRows:%d maxRows:%d"
       ", wal fsync:%d level:%d retentionPeriod:%d retentionSize:%" PRId64 " rollPeriod:%d segSize:%" PRId64
       ", hash method:%d begin:%u end:%u prefix:%d surfix:%d replica:%d selfIndex:%d "
       "learnerReplica:%d learnerSelfIndex:%d strict:%d changeVersion:%d",
       req.vgId, TMSG_INFO(pMsg->msgType), req.pages, req.pageSize, req.buffer, req.pageSize * 1024,
       (uint64_t)req.buffer * 1024 * 1024, req.cacheLast, req.cacheLastSize, req.sstTrigger, req.tsdbPageSize,
       req.tsdbPageSize * 1024, req.db, req.dbUid, req.daysPerFile, req.daysToKeep0, req.daysToKeep1, req.daysToKeep2,
-      req.isTsma, req.precision, req.compression, req.minRows, req.maxRows, req.walFsyncPeriod, req.walLevel,
-      req.walRetentionPeriod, req.walRetentionSize, req.walRollPeriod, req.walSegmentSize, req.hashMethod,
+      req.keepTimeOffset, req.isTsma, req.precision, req.compression, req.minRows, req.maxRows, req.walFsyncPeriod,
+      req.walLevel, req.walRetentionPeriod, req.walRetentionSize, req.walRollPeriod, req.walSegmentSize, req.hashMethod,
       req.hashBegin, req.hashEnd, req.hashPrefix, req.hashSuffix, req.replica, req.selfIndex, req.learnerReplica,
       req.learnerSelfIndex, req.strict, req.changeVersion);
 
@@ -366,7 +389,7 @@ int32_t vmProcessAlterVnodeTypeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   dInfo("node:%s, catched up leader, continue to process alter-node-type-request", pMgmt->name);
 
   int32_t vgId = req.vgId;
-  dInfo("vgId:%d, start to alter vnode type replica:%d selfIndex:%d strict:%d changeVersion:%d", 
+  dInfo("vgId:%d, start to alter vnode type replica:%d selfIndex:%d strict:%d changeVersion:%d",
         vgId, req.replica, req.selfIndex, req.strict, req.changeVersion);
   for (int32_t i = 0; i < req.replica; ++i) {
     SReplica *pReplica = &req.replicas[i];
@@ -427,7 +450,7 @@ int32_t vmProcessAlterVnodeTypeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     dError("vgId:%d, failed to open vnode at %s since %s", vgId, path, terrstr());
     return -1;
   }
-  
+
   if (vmOpenVnode(pMgmt, &wrapperCfg, pImpl) != 0) {
     dError("vgId:%d, failed to open vnode mgmt since %s", vgId, terrstr());
     return -1;
@@ -486,7 +509,7 @@ int32_t vmProcessCheckLearnCatchupReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 
   dInfo("vgId:%d, vnode management handle msgType:%s, end to process check-learner-catchup-request",
           req.vgId, TMSG_INFO(pMsg->msgType));
-  
+
   return 0;
 }
 

source/dnode/mgmt/mgmt_vnode/src/vmInt.c

@@ -17,6 +17,7 @@
 #include "vmInt.h"
 #include "tfs.h"
 #include "vnd.h"
+#include "libs/function/tudf.h"
 
 int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
   STfs   *pTfs = pMgmt->pTfs;

source/dnode/mgmt/node_mgmt/inc/dmMgmt.h

@@ -95,6 +95,10 @@ void          dmCleanupDnode(SDnode *pDnode);
 SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType nType);
 int32_t       dmMarkWrapper(SMgmtWrapper *pWrapper);
 void          dmReleaseWrapper(SMgmtWrapper *pWrapper);
+int32_t       dmInitVars(SDnode *pDnode);
+void          dmClearVars(SDnode *pDnode);
+int32_t       dmInitModule(SDnode *pDnode);
+bool          dmRequireNode(SDnode *pDnode, SMgmtWrapper *pWrapper);
 SMgmtInputOpt dmBuildMgmtInputOpt(SMgmtWrapper *pWrapper);
 void          dmSetStatus(SDnode *pDnode, EDndRunStatus stype);
 void          dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pMsg);
@@ -119,6 +123,7 @@ int32_t dmProcessNodeMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 // dmMonitor.c
 void dmSendMonitorReport();
 void dmGetVnodeLoads(SMonVloadInfo *pInfo);
+void dmGetVnodeLoadsLite(SMonVloadInfo *pInfo);
 void dmGetMnodeLoads(SMonMloadInfo *pInfo);
 void dmGetQnodeLoads(SQnodeLoad *pInfo);
 

source/dnode/mgmt/node_mgmt/inc/dmNodes.h

@@ -35,6 +35,7 @@ void smGetMonitorInfo(void *pMgmt, SMonSmInfo *pInfo);
 void bmGetMonitorInfo(void *pMgmt, SMonBmInfo *pInfo);
 
 void vmGetVnodeLoads(void *pMgmt, SMonVloadInfo *pInfo, bool isReset);
+void vmGetVnodeLoadsLite(void *pMgmt, SMonVloadInfo *pInfo);
 void mmGetMnodeLoads(void *pMgmt, SMonMloadInfo *pInfo);
 void qmGetQnodeLoads(void *pMgmt, SQnodeLoad *pInfo);
 

source/dnode/mgmt/node_mgmt/src/dmEnv.c

@@ -16,24 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dmMgmt.h"
 #include "audit.h"
-
-#define STR_CASE_CMP(s, d)   (0 == strcasecmp((s), (d)))
-#define STR_STR_CMP(s, d)    (strstr((s), (d)))
-#define STR_INT_CMP(s, d, c) (taosStr2Int32(s, 0, 10) c(d))
-#define STR_STR_SIGN         ("ia")
-#define DM_INIT_MON()                   \
-  do {                                  \
-    code = (int32_t)(2147483648 | 298); \
-    strncpy(stName, tsVersionName, 64); \
-    monCfg.maxLogs = tsMonitorMaxLogs;  \
-    monCfg.port = tsMonitorPort;        \
-    monCfg.server = tsMonitorFqdn;      \
-    monCfg.comp = tsMonitorComp;        \
-    if (monInit(&monCfg) != 0) {        \
-      if (terrno != 0) code = terrno;   \
-      goto _exit;                       \
-    }                                   \
-  } while (0)
+#include "libs/function/tudf.h"
 
 #define DM_INIT_AUDIT()                 \
   do {                                  \
@@ -45,15 +28,7 @@
     }                                   \
   } while (0)
 
-#define DM_ERR_RTN(c) \
-  do {                \
-    code = (c);       \
-    goto _exit;       \
-  } while (0)
-
 static SDnode      globalDnode = {0};
-static const char *dmOS[10] = {"Ubuntu",  "CentOS Linux", "Red Hat", "Debian GNU", "CoreOS",
-                               "FreeBSD", "openSUSE",     "SLES",    "Fedora",     "macOS"};
 
 SDnode *dmInstance() { return &globalDnode; }
 
@@ -76,30 +51,14 @@ static int32_t dmInitSystem() {
 static int32_t dmInitMonitor() {
   int32_t code = 0;
   SMonCfg monCfg = {0};
-  char    reName[64] = {0};
-  char    stName[64] = {0};
-  char    ver[64] = {0};
 
-  DM_INIT_MON();
-
-  if (STR_STR_CMP(stName, STR_STR_SIGN)) {
-    DM_ERR_RTN(0);
-  }
-  if (taosGetOsReleaseName(reName, stName, ver, 64) != 0) {
-    DM_ERR_RTN(code);
-  }
-  if (STR_CASE_CMP(stName, dmOS[0])) {
-    if (STR_INT_CMP(ver, 17, >)) {
-      DM_ERR_RTN(0);
-    }
-  } else if (STR_CASE_CMP(stName, dmOS[1])) {
-    if (STR_INT_CMP(ver, 6, >)) {
-      DM_ERR_RTN(0);
-    }
-  } else if (STR_STR_CMP(stName, dmOS[2]) || STR_STR_CMP(stName, dmOS[3]) || STR_STR_CMP(stName, dmOS[4]) ||
-             STR_STR_CMP(stName, dmOS[5]) || STR_STR_CMP(stName, dmOS[6]) || STR_STR_CMP(stName, dmOS[7]) ||
-             STR_STR_CMP(stName, dmOS[8]) || STR_STR_CMP(stName, dmOS[9])) {
-    DM_ERR_RTN(0);
+  monCfg.maxLogs = tsMonitorMaxLogs;
+  monCfg.port = tsMonitorPort;
+  monCfg.server = tsMonitorFqdn;
+  monCfg.comp = tsMonitorComp;
+  if (monInit(&monCfg) != 0) {
+    if (terrno != 0) code = terrno;
+    goto _exit;
   }
 
 _exit:
@@ -419,6 +378,7 @@ SMgmtInputOpt dmBuildMgmtInputOpt(SMgmtWrapper *pWrapper) {
       .processDropNodeFp = dmProcessDropNodeReq,
       .sendMonitorReportFp = dmSendMonitorReport,
       .getVnodeLoadsFp = dmGetVnodeLoads,
+      .getVnodeLoadsLiteFp = dmGetVnodeLoadsLite,
       .getMnodeLoadsFp = dmGetMnodeLoads,
       .getQnodeLoadsFp = dmGetQnodeLoads,
   };

source/dnode/mgmt/node_mgmt/src/dmMgmt.c

@@ -19,88 +19,10 @@
 #include "index.h"
 #include "qworker.h"
 #include "tstream.h"
-
-static bool dmRequireNode(SDnode *pDnode, SMgmtWrapper *pWrapper) {
-  SMgmtInputOpt input = dmBuildMgmtInputOpt(pWrapper);
-
-  bool    required = false;
-  int32_t code = (*pWrapper->func.requiredFp)(&input, &required);
-  if (!required) {
-    dDebug("node:%s, does not require startup", pWrapper->name);
-  } else {
-    dDebug("node:%s, required to startup", pWrapper->name);
-  }
-
-  return required;
-}
-
-static int32_t dmInitVars(SDnode *pDnode) {
-  SDnodeData *pData = &pDnode->data;
-  pData->dnodeId = 0;
-  pData->clusterId = 0;
-  pData->dnodeVer = 0;
-  pData->updateTime = 0;
-  pData->rebootTime = taosGetTimestampMs();
-  pData->dropped = 0;
-  pData->stopped = 0;
-
-  pData->dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (pData->dnodeHash == NULL) {
-    dError("failed to init dnode hash");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (dmReadEps(pData) != 0) {
-    dError("failed to read file since %s", terrstr());
-    return -1;
-  }
-
-  if (pData->dropped) {
-    dError("dnode will not start since its already dropped");
-    return -1;
-  }
-
-  taosThreadRwlockInit(&pData->lock, NULL);
-  taosThreadMutexInit(&pDnode->mutex, NULL);
-  return 0;
-}
-
-static void dmClearVars(SDnode *pDnode) {
-  for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    taosMemoryFreeClear(pWrapper->path);
-    taosThreadRwlockDestroy(&pWrapper->lock);
-  }
-  if (pDnode->lockfile != NULL) {
-    taosUnLockFile(pDnode->lockfile);
-    taosCloseFile(&pDnode->lockfile);
-    pDnode->lockfile = NULL;
-  }
-
-  SDnodeData *pData = &pDnode->data;
-  taosThreadRwlockWrlock(&pData->lock);
-  if (pData->oldDnodeEps != NULL) {
-    if (dmWriteEps(pData) == 0) {
-      dmRemoveDnodePairs(pData);
-    }
-    taosArrayDestroy(pData->oldDnodeEps);
-    pData->oldDnodeEps = NULL;
-  }
-  if (pData->dnodeEps != NULL) {
-    taosArrayDestroy(pData->dnodeEps);
-    pData->dnodeEps = NULL;
-  }
-  if (pData->dnodeHash != NULL) {
-    taosHashCleanup(pData->dnodeHash);
-    pData->dnodeHash = NULL;
-  }
-  taosThreadRwlockUnlock(&pData->lock);
-
-  taosThreadRwlockDestroy(&pData->lock);
-  taosThreadMutexDestroy(&pDnode->mutex);
-  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
-}
+#ifdef TD_TSZ
+#include "tglobal.h"
+#include "tcompression.h"
+#endif
 
 int32_t dmInitDnode(SDnode *pDnode) {
   dDebug("start to create dnode");
@@ -111,6 +33,11 @@ int32_t dmInitDnode(SDnode *pDnode) {
     goto _OVER;
   }
 
+#ifdef TD_TSZ
+  // compress module init
+  tsCompressInit(tsLossyColumns, tsFPrecision, tsDPrecision, tsMaxRange, tsCurRange, (int)tsIfAdtFse, tsCompressor);
+#endif
+
   pDnode->wrappers[DNODE].func = dmGetMgmtFunc();
   pDnode->wrappers[MNODE].func = mmGetMgmtFunc();
   pDnode->wrappers[VNODE].func = vmGetMgmtFunc();
@@ -134,22 +61,12 @@ int32_t dmInitDnode(SDnode *pDnode) {
     pWrapper->required = dmRequireNode(pDnode, pWrapper);
   }
 
-  if (dmInitMsgHandle(pDnode) != 0) {
-    dError("failed to init msg handles since %s", terrstr());
-    goto _OVER;
-  }
-
   pDnode->lockfile = dmCheckRunning(tsDataDir);
   if (pDnode->lockfile == NULL) {
     goto _OVER;
   }
 
-  if (dmInitServer(pDnode) != 0) {
-    dError("failed to init transport since %s", terrstr());
-    goto _OVER;
-  }
-
-  if (dmInitClient(pDnode) != 0) {
+  if(dmInitModule(pDnode) != 0) {
     goto _OVER;
   }
 
@@ -180,6 +97,12 @@ void dmCleanupDnode(SDnode *pDnode) {
   streamMetaCleanup();
   indexCleanup();
   taosConvDestroy();
+
+#ifdef TD_TSZ
+  // compress destroy
+  tsCompressExit();
+#endif
+
   dDebug("dnode is closed, ptr:%p", pDnode);
 }
 

source/dnode/mgmt/node_mgmt/src/dmMonitor.c

@@ -119,6 +119,17 @@ void dmGetVnodeLoads(SMonVloadInfo *pInfo) {
   }
 }
 
+void dmGetVnodeLoadsLite(SMonVloadInfo *pInfo) {
+  SDnode       *pDnode = dmInstance();
+  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
+  if (dmMarkWrapper(pWrapper) == 0) {
+    if (pWrapper->pMgmt != NULL) {
+      vmGetVnodeLoadsLite(pWrapper->pMgmt, pInfo);
+    }
+    dmReleaseWrapper(pWrapper);
+  }
+}
+
 void dmGetMnodeLoads(SMonMloadInfo *pInfo) {
   SDnode       *pDnode = dmInstance();
   SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];

source/dnode/mgmt/node_util/inc/dmUtil.h

@@ -40,7 +40,6 @@
 #include "tfs.h"
 #include "wal.h"
 
-#include "libs/function/tudf.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -94,6 +93,7 @@ typedef int32_t (*ProcessAlterNodeTypeFp)(EDndNodeType ntype, SRpcMsg *pMsg);
 
 typedef struct {
   int32_t        dnodeId;
+  int32_t        engineVer;
   int64_t        clusterId;
   int64_t        dnodeVer;
   int64_t        updateTime;
@@ -121,6 +121,7 @@ typedef struct {
   ProcessDropNodeFp   processDropNodeFp;
   SendMonitorReportFp sendMonitorReportFp;
   GetVnodeLoadsFp     getVnodeLoadsFp;
+  GetVnodeLoadsFp     getVnodeLoadsLiteFp;
   GetMnodeLoadsFp     getMnodeLoadsFp;
   GetQnodeLoadsFp     getQnodeLoadsFp;
 } SMgmtInputOpt;
@@ -171,6 +172,9 @@ int32_t   dmReadFile(const char *path, const char *name, bool *pDeployed);
 int32_t   dmWriteFile(const char *path, const char *name, bool deployed);
 TdFilePtr dmCheckRunning(const char *dataDir);
 
+// dmodule.c
+int32_t dmInitDndInfo(SDnodeData *pData);
+
 // dmEps.c
 int32_t dmReadEps(SDnodeData *pData);
 int32_t dmWriteEps(SDnodeData *pData);

source/dnode/mgmt/node_util/src/dmEps.c

@@ -57,6 +57,8 @@ static int32_t dmDecodeEps(SJson *pJson, SDnodeData *pData) {
   if (code < 0) return -1;
   tjsonGetNumberValue(pJson, "dnodeVer", pData->dnodeVer, code);
   if (code < 0) return -1;
+  tjsonGetNumberValue(pJson, "engineVer", pData->engineVer, code);
+  if (code < 0) return -1;
   tjsonGetNumberValue(pJson, "clusterId", pData->clusterId, code);
   if (code < 0) return -1;
   tjsonGetInt32ValueFromDouble(pJson, "dropped", pData->dropped, code);
@@ -96,7 +98,8 @@ int32_t dmReadEps(SDnodeData *pData) {
 
   pData->dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
   if (pData->dnodeEps == NULL) {
-    dError("failed to calloc dnodeEp array since %s", strerror(errno));
+    code = terrno;
+    dError("failed to calloc dnodeEp array since %s", terrstr());
     goto _OVER;
   }
 
@@ -184,6 +187,7 @@ _OVER:
 static int32_t dmEncodeEps(SJson *pJson, SDnodeData *pData) {
   if (tjsonAddDoubleToObject(pJson, "dnodeId", pData->dnodeId) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "dnodeVer", pData->dnodeVer) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "engineVer", pData->engineVer) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "clusterId", pData->clusterId) < 0) return -1;
   if (tjsonAddDoubleToObject(pJson, "dropped", pData->dropped) < 0) return -1;
 
@@ -218,8 +222,11 @@ int32_t dmWriteEps(SDnodeData *pData) {
   snprintf(realfile, sizeof(realfile), "%s%sdnode%sdnode.json", tsDataDir, TD_DIRSEP, TD_DIRSEP);
 
   terrno = TSDB_CODE_OUT_OF_MEMORY;
+
+  if((code == dmInitDndInfo(pData)) != 0) goto _OVER;
   pJson = tjsonCreateObject();
   if (pJson == NULL) goto _OVER;
+  pData->engineVer = tsVersion;
   if (dmEncodeEps(pJson, pData) != 0) goto _OVER;
   buffer = tjsonToString(pJson);
   if (buffer == NULL) goto _OVER;

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

@@ -312,6 +312,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;

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

@@ -32,11 +32,11 @@ void             mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub);
 
 int32_t mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName);
 
-static FORCE_INLINE int32_t mndMakePartitionKey(char *key, const char *cgroup, const char *topicName, int32_t vgId) {
-  return snprintf(key, TSDB_PARTITION_KEY_LEN, "%d:%s:%s", vgId, cgroup, topicName);
-}
+//static FORCE_INLINE int32_t mndMakePartitionKey(char *key, const char *cgroup, const char *topicName, int32_t vgId) {
+//  return snprintf(key, TSDB_PARTITION_KEY_LEN, "%d:%s:%s", vgId, cgroup, topicName);
+//}
 
-int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
+//int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
 int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
 int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub);
 

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

@@ -47,7 +47,7 @@ void    mndUserFreeObj(SUserObj *pUser);
 
 int64_t mndGetIpWhiteVer(SMnode *pMnode);
 
-void mndUpdateIpWhite(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock);
+void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock);
 
 int32_t mndRefreshUserIpWhiteList(SMnode *pMnode);
 

source/dnode/mnode/impl/src/mndConsumer.c

@@ -311,6 +311,34 @@ static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg) {
           taosArrayPush(pRebSub->removedConsumers, &pConsumer->consumerId);
         }
         taosRUnLockLatch(&pConsumer->lock);
+      }else{
+        int32_t newTopicNum = taosArrayGetSize(pConsumer->currentTopics);
+        for (int32_t i = 0; i < newTopicNum; i++) {
+          char *           topic = taosArrayGetP(pConsumer->currentTopics, i);
+          SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic);
+          if (pSub == NULL) {
+            continue;
+          }
+          taosRLockLatch(&pSub->lock);
+
+          // 2.2 iterate all vg assigned to the consumer of that topic
+          SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
+          int32_t        vgNum = taosArrayGetSize(pConsumerEp->vgs);
+
+          for (int32_t j = 0; j < vgNum; j++) {
+            SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
+            SVgObj * pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);
+            if (!pVgroup) {
+              char key[TSDB_SUBSCRIBE_KEY_LEN];
+              mndMakeSubscribeKey(key, pConsumer->cgroup, topic);
+              mndGetOrCreateRebSub(pRebMsg->rebSubHash, key);
+              mInfo("vnode splitted, vgId:%d rebalance will be triggered", pVgEp->vgId);
+            }
+            mndReleaseVgroup(pMnode, pVgroup);
+          }
+          taosRUnLockLatch(&pSub->lock);
+          mndReleaseSubscribe(pMnode, pSub);
+        }
       }
     } else if (status == MQ_CONSUMER_STATUS_LOST) {
       if (hbStatus > MND_CONSUMER_LOST_CLEAR_THRESHOLD) {   // clear consumer if lost a day
@@ -343,7 +371,7 @@ static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg) {
   }
 
   if (taosHashGetSize(pRebMsg->rebSubHash) != 0) {
-      mInfo("mq rebalance will be triggered");
+    mInfo("mq rebalance will be triggered");
     SRpcMsg rpcMsg = {
         .msgType = TDMT_MND_TMQ_DO_REBALANCE,
         .pCont = pRebMsg,
@@ -548,8 +576,8 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
 
       for (int32_t j = 0; j < vgNum; j++) {
         SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
-        char     offsetKey[TSDB_PARTITION_KEY_LEN];
-        mndMakePartitionKey(offsetKey, pConsumer->cgroup, topic, pVgEp->vgId);
+//        char     offsetKey[TSDB_PARTITION_KEY_LEN];
+//        mndMakePartitionKey(offsetKey, pConsumer->cgroup, topic, pVgEp->vgId);
 
         if(epoch == -1){
           SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);

source/dnode/mnode/impl/src/mndDb.c

@@ -34,7 +34,7 @@
 #include "audit.h"
 
 #define DB_VER_NUMBER   1
-#define DB_RESERVE_SIZE 46
+#define DB_RESERVE_SIZE 42
 
 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);
 static int32_t  mndDbActionInsert(SSdb *pSdb, SDbObj *pDb);
@@ -137,6 +137,7 @@ SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER)
   SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.keepTimeOffset, _OVER)
 
   SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
   SDB_SET_DATALEN(pRaw, dataPos, _OVER)
@@ -227,6 +228,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER)
   SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER)
   SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.keepTimeOffset, _OVER)
 
   SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
   taosInitRWLatch(&pDb->lock);
@@ -292,6 +294,7 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
   pOld->cfg.daysToKeep0 = pNew->cfg.daysToKeep0;
   pOld->cfg.daysToKeep1 = pNew->cfg.daysToKeep1;
   pOld->cfg.daysToKeep2 = pNew->cfg.daysToKeep2;
+  pOld->cfg.keepTimeOffset = pNew->cfg.keepTimeOffset;
   pOld->cfg.walFsyncPeriod = pNew->cfg.walFsyncPeriod;
   pOld->cfg.walLevel = pNew->cfg.walLevel;
   pOld->cfg.walRetentionPeriod = pNew->cfg.walRetentionPeriod;
@@ -368,6 +371,7 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
   if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return -1;
   if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return -1;
+  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return -1;
   if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return -1;
   if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return -1;
   if (pCfg->minRows > pCfg->maxRows) return -1;
@@ -413,6 +417,7 @@ static int32_t mndCheckInChangeDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
   if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return -1;
   if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return -1;
+  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return -1;
   if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return -1;
   if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return -1;
   if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return -1;
@@ -445,6 +450,7 @@ static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;
   if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep0;
   if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = pCfg->daysToKeep1;
+  if (pCfg->keepTimeOffset < 0) pCfg->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;
   if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MINROWS_FBLOCK;
   if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;
   if (pCfg->walFsyncPeriod < 0) pCfg->walFsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;
@@ -590,6 +596,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
       .daysToKeep0 = pCreate->daysToKeep0,
       .daysToKeep1 = pCreate->daysToKeep1,
       .daysToKeep2 = pCreate->daysToKeep2,
+      .keepTimeOffset = pCreate->keepTimeOffset,
       .minRows = pCreate->minRows,
       .maxRows = pCreate->maxRows,
       .walFsyncPeriod = pCreate->walFsyncPeriod,
@@ -680,7 +687,7 @@ _OVER:
 
 static void mndBuildAuditDetailInt32(char* detail, char* tmp, char* format, int32_t para){
   if(para > 0){
-    if(strlen(detail) > 0) strcat(detail, ", "); 
+    if(strlen(detail) > 0) strcat(detail, ", ");
     sprintf(tmp, format, para);
     strcat(detail, tmp);
   }
@@ -688,7 +695,7 @@ static void mndBuildAuditDetailInt32(char* detail, char* tmp, char* format, int3
 
 static void mndBuildAuditDetailInt64(char* detail, char* tmp, char* format, int64_t para){
   if(para > 0){
-    if(strlen(detail) > 0) strcat(detail, ", "); 
+    if(strlen(detail) > 0) strcat(detail, ", ");
     sprintf(tmp, format, para);
     strcat(detail, tmp);
   }
@@ -763,6 +770,7 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep0:%d", createReq.daysToKeep0);
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep1:%d", createReq.daysToKeep1);
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep2:%d", createReq.daysToKeep2);
+  mndBuildAuditDetailInt32(detail, tmp, "keepTimeOffset:%d", createReq.keepTimeOffset);
   mndBuildAuditDetailInt32(detail, tmp, "hashPrefix:%d", createReq.hashPrefix);
   mndBuildAuditDetailInt32(detail, tmp, "hashSuffix:%d", createReq.hashSuffix);
   mndBuildAuditDetailInt32(detail, tmp, "ignoreExist:%d", createReq.ignoreExist);
@@ -785,7 +793,7 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
   mndBuildAuditDetailInt32(detail, tmp, "walRetentionSize:%" PRId64, createReq.walRetentionSize);
   mndBuildAuditDetailInt32(detail, tmp, "walRollPeriod:%d", createReq.walRollPeriod);
   mndBuildAuditDetailInt32(detail, tmp, "walSegmentSize:%" PRId64, createReq.walSegmentSize);
-  
+
   SName name = {0};
   tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB);
 
@@ -841,6 +849,11 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
     terrno = 0;
   }
 
+  if (pAlter->keepTimeOffset >= 0 && pAlter->keepTimeOffset != pDb->cfg.keepTimeOffset) {
+    pDb->cfg.keepTimeOffset = pAlter->keepTimeOffset;
+    terrno = 0;
+  }
+
   if (pAlter->walFsyncPeriod >= 0 && pAlter->walFsyncPeriod != pDb->cfg.walFsyncPeriod) {
     pDb->cfg.walFsyncPeriod = pAlter->walFsyncPeriod;
     terrno = 0;
@@ -1046,6 +1059,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep0:%d", alterReq.daysToKeep0);
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep1:%d", alterReq.daysToKeep1);
   mndBuildAuditDetailInt32(detail, tmp, "daysToKeep2:%d", alterReq.daysToKeep2);
+  mndBuildAuditDetailInt32(detail, tmp, "keepTimeOffset:%d", alterReq.keepTimeOffset);
   mndBuildAuditDetailInt32(detail, tmp, "minRows:%d", alterReq.minRows);
   mndBuildAuditDetailInt32(detail, tmp, "pages:%d", alterReq.pages);
   mndBuildAuditDetailInt32(detail, tmp, "pageSize:%d", alterReq.pageSize);
@@ -1087,6 +1101,7 @@ static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {
   cfgRsp->daysToKeep0 = pDb->cfg.daysToKeep0;
   cfgRsp->daysToKeep1 = pDb->cfg.daysToKeep1;
   cfgRsp->daysToKeep2 = pDb->cfg.daysToKeep2;
+  cfgRsp->keepTimeOffset = pDb->cfg.keepTimeOffset;
   cfgRsp->minRows = pDb->cfg.minRows;
   cfgRsp->maxRows = pDb->cfg.maxRows;
   cfgRsp->walFsyncPeriod = pDb->cfg.walFsyncPeriod;
@@ -1129,7 +1144,7 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
 
     mndDumpDbCfgInfo(&cfgRsp, pDb);
   }
-  
+
   int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);
   void   *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
@@ -1559,14 +1574,14 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       if (pDbCacheInfo->vgVersion >= vgVersion) {
         continue;
       }
-      
+
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
       memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
 
       mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);
       rsp.useDbRsp->vgVersion = vgVersion++;
-      
+
       rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
 
       taosArrayPush(batchRsp.pArray, &rsp);
@@ -1587,7 +1602,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
 
     int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
 
-    if (pDbCacheInfo->vgVersion >= pDb->vgVersion && 
+    if (pDbCacheInfo->vgVersion >= pDb->vgVersion &&
         pDbCacheInfo->cfgVersion >= pDb->cfgVersion &&
         numOfTable == pDbCacheInfo->numOfTable &&
         pDbCacheInfo->stateTs == pDb->stateTs) {
@@ -1609,7 +1624,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       mndDumpDbCfgInfo(rsp.cfgRsp, pDb);
     }
 
-    if (pDbCacheInfo->vgVersion < pDb->vgVersion || 
+    if (pDbCacheInfo->vgVersion < pDb->vgVersion ||
         numOfTable != pDbCacheInfo->numOfTable ||
         pDbCacheInfo->stateTs != pDb->stateTs) {
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
@@ -2013,6 +2028,9 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false);
   }
 
   taosMemoryFree(buf);

source/dnode/mnode/impl/src/mndDnode.c

@@ -71,6 +71,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq);
 static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq);
 static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp);
 static int32_t mndProcessStatusReq(SRpcMsg *pReq);
+static int32_t mndProcessNotifyReq(SRpcMsg *pReq);
 static int32_t mndProcessRestoreDnodeReq(SRpcMsg *pReq);
 
 static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
@@ -80,6 +81,12 @@ static void    mndCancelGetNextDnode(SMnode *pMnode, void *pIter);
 
 static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pInMCfgReq, int32_t opLen, int32_t *pOutValue);
 
+#ifdef _GRANT
+int32_t mndUpdClusterInfo(SRpcMsg *pReq);
+#else
+static int32_t mndUpdClusterInfo(SRpcMsg *pReq) { return 0; }
+#endif
+
 int32_t mndInitDnode(SMnode *pMnode) {
   SSdbTable table = {
       .sdbType = SDB_DNODE,
@@ -97,6 +104,7 @@ int32_t mndInitDnode(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_CONFIG_DNODE, mndProcessConfigDnodeReq);
   mndSetMsgHandle(pMnode, TDMT_DND_CONFIG_DNODE_RSP, mndProcessConfigDnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_MND_STATUS, mndProcessStatusReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_NOTIFY, mndProcessNotifyReq);
   mndSetMsgHandle(pMnode, TDMT_MND_DNODE_LIST, mndProcessDnodeListReq);
   mndSetMsgHandle(pMnode, TDMT_MND_SHOW_VARIABLES, mndProcessShowVariablesReq);
   mndSetMsgHandle(pMnode, TDMT_MND_RESTORE_DNODE, mndProcessRestoreDnodeReq);
@@ -139,7 +147,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
 
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
   code = 0;
-  mndUpdateIpWhite(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
 
 _OVER:
   mndTransDrop(pTrans);
@@ -543,6 +551,10 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
   mGTrace("dnode:%d, status received, accessTimes:%d check:%d online:%d reboot:%d changed:%d statusSeq:%d", pDnode->id,
           pDnode->accessTimes, needCheck, online, reboot, dnodeChanged, statusReq.statusSeq);
 
+  if (reboot) {
+    tsGrantHBInterval = GRANT_HEART_BEAT_MIN;
+  }
+
   for (int32_t v = 0; v < taosArrayGetSize(statusReq.pVloads); ++v) {
     SVnodeLoad *pVload = taosArrayGet(statusReq.pVloads, v);
 
@@ -676,6 +688,41 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 _OVER:
   mndReleaseDnode(pMnode, pDnode);
   taosArrayDestroy(statusReq.pVloads);
+  mndUpdClusterInfo(pReq);
+  return code;
+}
+
+static int32_t mndProcessNotifyReq(SRpcMsg *pReq) {
+  SMnode    *pMnode = pReq->info.node;
+  SNotifyReq notifyReq = {0};
+  int32_t    code = 0;
+
+  if ((code = tDeserializeSNotifyReq(pReq->pCont, pReq->contLen, &notifyReq)) != 0) {
+    terrno = code;
+    goto _OVER;
+  }
+
+  int64_t clusterid = mndGetClusterId(pMnode);
+  if (notifyReq.clusterId != 0 && notifyReq.clusterId != clusterid) {
+    code = TSDB_CODE_MND_DNODE_DIFF_CLUSTER;
+    mWarn("dnode:%d, its clusterid:%" PRId64 " differ from current cluster:%" PRId64 " since %s", notifyReq.dnodeId,
+          notifyReq.clusterId, clusterid, tstrerror(code));
+    goto _OVER;
+  }
+
+  int32_t nVgroup = taosArrayGetSize(notifyReq.pVloads);
+  for (int32_t v = 0; v < nVgroup; ++v) {
+    SVnodeLoadLite *pVload = taosArrayGet(notifyReq.pVloads, v);
+
+    SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVload->vgId);
+    if (pVgroup != NULL) {
+      pVgroup->numOfTimeSeries = pVload->nTimeSeries;
+      mndReleaseVgroup(pMnode, pVgroup);
+    }
+  }
+_OVER:
+  mndUpdClusterInfo(pReq);
+  tFreeSNotifyReq(&notifyReq);
   return code;
 }
 
@@ -705,7 +752,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
   code = 0;
 
-  mndUpdateIpWhite(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
 _OVER:
   mndTransDrop(pTrans);
   sdbFreeRaw(pRaw);
@@ -716,7 +763,9 @@ static int32_t mndConfigDnode(SMnode *pMnode, SRpcMsg *pReq, SMCfgDnodeReq *pCfg
   SSdbRaw   *pRaw = NULL;
   STrans    *pTrans = NULL;
   SDnodeObj *pDnode = NULL;
+  SArray    *failRecord = NULL;
   bool       cfgAll = pCfgReq->dnodeId == -1;
+  int32_t    cfgAllErr = 0;
   int32_t    iter = 0;
 
   SSdb *pSdb = pMnode->pSdb;
@@ -730,28 +779,64 @@ static int32_t mndConfigDnode(SMnode *pMnode, SRpcMsg *pReq, SMCfgDnodeReq *pCfg
       goto _OVER;
     }
 
+    SDnodeObj tmpDnode = *pDnode;
+    if (action == DND_ACTIVE_CODE) {
+#ifndef TD_CHECK_ACTIVE
+      strncpy(tmpDnode.active, pCfgReq->value, TSDB_ACTIVE_KEY_LEN);
+#else
+      if (grantAlterActiveCode(pDnode->active, pCfgReq->value, tmpDnode.active, 0) != 0) {
+        if (TSDB_CODE_DUP_KEY != terrno) {
+          mError("dnode:%d, config dnode:%d, app:%p config:%s value:%s failed since %s", pDnode->id, pCfgReq->dnodeId,
+                 pReq->info.ahandle, pCfgReq->config, pCfgReq->value, terrstr());
+          if (cfgAll) {  // alter all dnodes:
+            if (!failRecord) failRecord = taosArrayInit(1, sizeof(int32_t));
+            if (failRecord) taosArrayPush(failRecord, &pDnode->id);
+            if (0 == cfgAllErr) cfgAllErr = terrno;  // output 1st terrno.
+          }
+        } else {
+          terrno = 0;  // no action for dup active code
+        }
+        if (cfgAll) continue;
+        goto _OVER;
+      }
+#endif
+    } else if (action == DND_CONN_ACTIVE_CODE) {
+#ifndef TD_CHECK_ACTIVE
+      strncpy(tmpDnode.connActive, pCfgReq->value, TSDB_CONN_ACTIVE_KEY_LEN);
+#else
+      if (grantAlterActiveCode(pDnode->connActive, pCfgReq->value, tmpDnode.connActive, 1) != 0) {
+        if (TSDB_CODE_DUP_KEY != terrno) {
+          mError("dnode:%d, config dnode:%d, app:%p config:%s value:%s failed since %s", pDnode->id, pCfgReq->dnodeId,
+                 pReq->info.ahandle, pCfgReq->config, pCfgReq->value, terrstr());
+          if (cfgAll) {
+            if (!failRecord) failRecord = taosArrayInit(1, sizeof(int32_t));
+            if (failRecord) taosArrayPush(failRecord, &pDnode->id);
+            if (0 == cfgAllErr) cfgAllErr = terrno;
+          }
+        } else {
+          terrno = 0;
+        }
+        if (cfgAll) continue;
+        goto _OVER;
+      }
+#endif
+    } else {
+      terrno = TSDB_CODE_INVALID_CFG;
+      goto _OVER;
+    }
+
     if (!pTrans) {
       pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "config-dnode");
       if (!pTrans) goto _OVER;
       if (mndTrancCheckConflict(pMnode, pTrans) != 0) goto _OVER;
     }
 
-    SDnodeObj tmpDnode = *pDnode;
-    if (action == DND_ACTIVE_CODE) {
-      strncpy(tmpDnode.active, pCfgReq->value, TSDB_ACTIVE_KEY_LEN);
-    } else if (action == DND_CONN_ACTIVE_CODE) {
-      strncpy(tmpDnode.connActive, pCfgReq->value, TSDB_CONN_ACTIVE_KEY_LEN);
-    } else {
-      terrno = TSDB_CODE_INVALID_CFG;
-      goto _OVER;
-    }
-
     pRaw = mndDnodeActionEncode(&tmpDnode);
     if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
     pRaw = NULL;
 
-    mInfo("dnode:%d, config dnode, cfg:%d, app:%p config:%s value:%s", pDnode->id, pCfgReq->dnodeId, pReq->info.ahandle,
+    mInfo("dnode:%d, config dnode:%d, app:%p config:%s value:%s", pDnode->id, pCfgReq->dnodeId, pReq->info.ahandle,
           pCfgReq->config, pCfgReq->value);
 
     if (cfgAll) {
@@ -769,12 +854,19 @@ static int32_t mndConfigDnode(SMnode *pMnode, SRpcMsg *pReq, SMCfgDnodeReq *pCfg
 _OVER:
   if (cfgAll) {
     sdbRelease(pSdb, pDnode);
+    if (cfgAllErr != 0) terrno = cfgAllErr;
+    int32_t nFail = taosArrayGetSize(failRecord);
+    if (nFail > 0) {
+      mError("config dnode, cfg:%d, app:%p config:%s value:%s. total:%d, fail:%d", pCfgReq->dnodeId, pReq->info.ahandle,
+             pCfgReq->config, pCfgReq->value, iter, nFail);
+    }
   } else {
     mndReleaseDnode(pMnode, pDnode);
   }
   sdbCancelFetch(pSdb, pIter);
   mndTransDrop(pTrans);
   sdbFreeRaw(pRaw);
+  taosArrayDestroy(failRecord);
   return terrno;
 }
 
@@ -998,7 +1090,7 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
 
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
-  mndUpdateIpWhite(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1);
   code = 0;
 
 _OVER:
@@ -1144,20 +1236,6 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
     strcpy(dcfgReq.config, "monitor");
     snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag);
-  } else if (strncasecmp(cfgReq.config, "keeptimeoffset", 14) == 0) {
-    int32_t optLen = strlen("keeptimeoffset");
-    int32_t flag = -1;
-    int32_t code = mndMCfgGetValInt32(&cfgReq, optLen, &flag);
-    if (code < 0) return code;
-
-    if (flag < 0 || flag > 23) {
-      mError("dnode:%d, failed to config keepTimeOffset since value:%d. Valid range: [0, 23]", cfgReq.dnodeId, flag);
-      terrno = TSDB_CODE_INVALID_CFG;
-      return -1;
-    }
-
-    strcpy(dcfgReq.config, "keeptimeoffset");
-    snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag);
   } else if (strncasecmp(cfgReq.config, "ttlpushinterval", 14) == 0) {
     int32_t optLen = strlen("ttlpushinterval");
     int32_t flag = -1;
@@ -1229,7 +1307,8 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
     snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%s", cfgReq.value);
 
     if (mndConfigDnode(pMnode, pReq, &cfgReq, opt) != 0) {
-      mError("dnode:%d, failed to config activeCode since %s", cfgReq.dnodeId, terrstr());
+      mError("dnode:%d, failed to config activeCode since %s. conf:%s, val:%s", cfgReq.dnodeId, terrstr(),
+             cfgReq.config, cfgReq.value);
       return -1;
     }
     return 0;

source/dnode/mnode/impl/src/mndGrant.c

@@ -129,7 +129,8 @@ void    grantParseParameter() { mError("can't parsed parameter k"); }
 void    grantReset(SMnode *pMnode, EGrantType grant, uint64_t value) {}
 void    grantAdd(EGrantType grant, uint64_t value) {}
 void    grantRestore(EGrantType grant, uint64_t value) {}
-int32_t dmProcessGrantReq(void* pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
+int32_t dmProcessGrantReq(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
+int32_t dmProcessGrantNotify(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
 
 #endif
 

source/dnode/mnode/impl/src/mndPrivilege.c

@@ -77,7 +77,7 @@ int32_t mndSetUserAuthRsp(SMnode *pMnode, SUserObj *pUser, SGetUserAuthRsp *pRsp
   return 0;
 }
 
-int32_t mndEnableIpWhiteList(SMnode *pMnode) { return 1; }
+int32_t mndEnableIpWhiteList(SMnode *pMnode) { return 0; }
 
 int32_t mndFetchIpWhiteList(SIpWhiteList *ipList, char **buf) {
   *buf = NULL;

source/dnode/mnode/impl/src/mndStb.c

@@ -1678,6 +1678,10 @@ static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, SArray
     return -1;
   }
 
+  if ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) != 0) {
+    return -1;
+  }
+
   pNew->numOfColumns = pNew->numOfColumns + ncols;
   if (mndAllocStbSchemas(pOld, pNew) != 0) {
     return -1;

source/dnode/mnode/impl/src/mndSubscribe.c

@@ -361,8 +361,71 @@ static void transferVgroupsForConsumers(SMqRebOutputObj *pOutput, SHashObj *pHas
   }
 }
 
+static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput){
+  int32_t totalVgNum = 0;
+  SVgObj* pVgroup = NULL;
+  void* pIter = NULL;
+  SArray* newVgs = taosArrayInit(0, POINTER_BYTES);
+  while (1) {
+    pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
+    if (pIter == NULL) {
+      break;
+    }
+
+    if (!mndVgroupInDb(pVgroup, pOutput->pSub->dbUid)) {
+      sdbRelease(pMnode->pSdb, pVgroup);
+      continue;
+    }
+
+    totalVgNum++;
+    SMqVgEp* pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
+    pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);
+    pVgEp->vgId = pVgroup->vgId;
+    taosArrayPush(newVgs, &pVgEp);
+    sdbRelease(pMnode->pSdb, pVgroup);
+  }
+
+  pIter = NULL;
+  while (1) {
+    pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);
+    if (pIter == NULL) break;
+    SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;
+
+    int32_t j = 0;
+    while (j < taosArrayGetSize(pConsumerEp->vgs)) {
+      SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
+      bool find = false;
+      for(int32_t k = 0; k < taosArrayGetSize(newVgs); k++){
+        SMqVgEp *pnewVgEp = taosArrayGetP(newVgs, k);
+        if(pVgEp->vgId == pnewVgEp->vgId){
+          tDeleteSMqVgEp(pnewVgEp);
+          taosArrayRemove(newVgs, k);
+          find = true;
+          break;
+        }
+      }
+      if(!find){
+        mInfo("processRemoveAddVgs old vgId:%d", pVgEp->vgId);
+        tDeleteSMqVgEp(pVgEp);
+        taosArrayRemove(pConsumerEp->vgs, j);
+        continue;
+      }
+      j++;
+    }
+  }
+
+  if(taosArrayGetSize(pOutput->pSub->unassignedVgs) == 0 && taosArrayGetSize(newVgs) != 0){
+    taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs);
+    mInfo("processRemoveAddVgs add new vg num:%d", (int)taosArrayGetSize(newVgs));
+    taosArrayDestroy(newVgs);
+  }else{
+    taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp);
+  }
+  return totalVgNum;
+}
+
 static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
-  int32_t     totalVgNum = pOutput->pSub->vgNum;
+  int32_t totalVgNum = processRemoveAddVgs(pMnode, pOutput);
   const char *pSubKey = pOutput->pSub->key;
 
   int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);
@@ -771,6 +834,29 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) {
   return 0;
 }
 
+static int32_t sendDeleteSubToVnode(SMqSubscribeObj *pSub, STrans *pTrans){
+  // iter all vnode to delete handle
+  int32_t sz = taosArrayGetSize(pSub->unassignedVgs);
+  for (int32_t i = 0; i < sz; i++) {
+    SMqVgEp       *pVgEp = taosArrayGetP(pSub->unassignedVgs, i);
+    SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq));
+    pReq->head.vgId = htonl(pVgEp->vgId);
+    pReq->vgId = pVgEp->vgId;
+    pReq->consumerId = -1;
+    memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
+    STransAction action = {0};
+    action.epSet = pVgEp->epSet;
+    action.pCont = pReq;
+    action.contLen = sizeof(SMqVDeleteReq);
+    action.msgType = TDMT_VND_TMQ_DELETE_SUB;
+    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+      taosMemoryFree(pReq);
+      return -1;
+    }
+  }
+  return 0;
+}
+
 static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {
   SMnode          *pMnode = pMsg->info.node;
   SMDropCgroupReq  dropReq = {0};
@@ -831,6 +917,11 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {
 
   mInfo("trans:%d, used to drop cgroup:%s on topic %s", pTrans->id, dropReq.cgroup, dropReq.topic);
 
+  code = sendDeleteSubToVnode(pSub, pTrans);
+  if (code != 0) {
+    goto end;
+  }
+
   if (mndSetDropSubCommitLogs(pMnode, pTrans, pSub) < 0) {
     mError("cgroup %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr());
     code = -1;
@@ -1065,33 +1156,33 @@ int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj
   return 0;
 }
 
-int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
-  int32_t code = 0;
-  SSdb   *pSdb = pMnode->pSdb;
-
-  void            *pIter = NULL;
-  SMqSubscribeObj *pSub = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pIter, (void **)&pSub);
-    if (pIter == NULL) break;
-
-    if (pSub->dbUid != pDb->uid) {
-      sdbRelease(pSdb, pSub);
-      continue;
-    }
-
-    if (mndSetDropSubCommitLogs(pMnode, pTrans, pSub) < 0) {
-      sdbRelease(pSdb, pSub);
-      sdbCancelFetch(pSdb, pIter);
-      code = -1;
-      break;
-    }
-
-    sdbRelease(pSdb, pSub);
-  }
-
-  return code;
-}
+//int32_t mndDropSubByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
+//  int32_t code = 0;
+//  SSdb   *pSdb = pMnode->pSdb;
+//
+//  void            *pIter = NULL;
+//  SMqSubscribeObj *pSub = NULL;
+//  while (1) {
+//    pIter = sdbFetch(pSdb, SDB_SUBSCRIBE, pIter, (void **)&pSub);
+//    if (pIter == NULL) break;
+//
+//    if (pSub->dbUid != pDb->uid) {
+//      sdbRelease(pSdb, pSub);
+//      continue;
+//    }
+//
+//    if (mndSetDropSubCommitLogs(pMnode, pTrans, pSub) < 0) {
+//      sdbRelease(pSdb, pSub);
+//      sdbCancelFetch(pSdb, pIter);
+//      code = -1;
+//      break;
+//    }
+//
+//    sdbRelease(pSdb, pSub);
+//  }
+//
+//  return code;
+//}
 
 int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) {
   SSdb   *pSdb = pMnode->pSdb;
@@ -1117,25 +1208,10 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName)
       sdbCancelFetch(pSdb, pIter);
       return -1;
     }
-    int32_t sz = taosArrayGetSize(pSub->unassignedVgs);
-    for (int32_t i = 0; i < sz; i++) {
-      SMqVgEp       *pVgEp = taosArrayGetP(pSub->unassignedVgs, i);
-      SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq));
-      pReq->head.vgId = htonl(pVgEp->vgId);
-      pReq->vgId = pVgEp->vgId;
-      pReq->consumerId = -1;
-      memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
-      STransAction action = {0};
-      action.epSet = pVgEp->epSet;
-      action.pCont = pReq;
-      action.contLen = sizeof(SMqVDeleteReq);
-      action.msgType = TDMT_VND_TMQ_DELETE_SUB;
-      if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-        taosMemoryFree(pReq);
-        sdbRelease(pSdb, pSub);
-        sdbCancelFetch(pSdb, pIter);
-        return -1;
-      }
+    if (sendDeleteSubToVnode(pSub, pTrans) != 0) {
+      sdbRelease(pSdb, pSub);
+      sdbCancelFetch(pSdb, pIter);
+      return -1;
     }
 
     if (mndSetDropSubRedoLogs(pMnode, pTrans, pSub) < 0) {

source/dnode/mnode/impl/src/mndUser.c

@@ -58,6 +58,7 @@ static int32_t  mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBloc
 static void     mndCancelGetNextPrivileges(SMnode *pMnode, void *pIter);
 SHashObj       *mndFetchAllIpWhite(SMnode *pMnode);
 static int32_t  mndProcesSRetrieveIpWhiteReq(SRpcMsg *pReq);
+bool            mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8_t type);
 
 void ipWhiteMgtUpdateAll(SMnode *pMnode);
 typedef struct {
@@ -80,7 +81,7 @@ void ipWhiteMgtCleanup() {
   taosThreadRwlockDestroy(&ipWhiteMgt.rw);
 }
 
-int32_t ipWhiteMgtUpdate(char *user, SIpWhiteList *pNew) {
+int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) {
   bool update = true;
   taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   SIpWhiteList **ppList = taosHashGet(ipWhiteMgt.pIpWhiteTab, user, strlen(user));
@@ -98,6 +99,25 @@ int32_t ipWhiteMgtUpdate(char *user, SIpWhiteList *pNew) {
       taosHashPut(ipWhiteMgt.pIpWhiteTab, user, strlen(user), &p, sizeof(void *));
     }
   }
+  SArray *fqdns = mndGetAllDnodeFqdns(pMnode);
+
+  for (int i = 0; i < taosArrayGetSize(fqdns); i++) {
+    char *fqdn = taosArrayGetP(fqdns, i);
+    update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, TSDB_DEFAULT_USER, fqdn, IP_WHITE_ADD);
+    update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, IP_WHITE_ADD);
+  }
+
+  for (int i = 0; i < taosArrayGetSize(fqdns); i++) {
+    char *fqdn = taosArrayGetP(fqdns, i);
+    taosMemoryFree(fqdn);
+  }
+  taosArrayDestroy(fqdns);
+
+  // for (int i = 0; i < taosArrayGetSize(pUserNames); i++) {
+  //   taosMemoryFree(taosArrayGetP(pUserNames, i));
+  // }
+  // taosArrayDestroy(pUserNames);
+
   if (update) ipWhiteMgt.ver++;
 
   taosThreadRwlockUnlock(&ipWhiteMgt.rw);
@@ -193,17 +213,17 @@ int64_t mndGetIpWhiteVer(SMnode *pMnode) {
   int64_t ver = 0;
   taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   if (ipWhiteMgt.ver == 0) {
-    // user and dnode r
+    // get user and dnode ip white list
     ipWhiteMgtUpdateAll(pMnode);
     ipWhiteMgt.ver = taosGetTimestampMs();
   }
   ver = ipWhiteMgt.ver;
   taosThreadRwlockUnlock(&ipWhiteMgt.rw);
-  mDebug("ip-white-list on mnode ver: %" PRId64 "", ver);
 
   if (mndEnableIpWhiteList(pMnode) == 0 || tsEnableWhiteList == false) {
-    return 0;
+    ver = 0;
   }
+  mDebug("ip-white-list on mnode ver: %" PRId64 "", ver);
   return ver;
 }
 
@@ -282,7 +302,7 @@ int32_t mndRefreshUserIpWhiteList(SMnode *pMnode) {
 
   return 0;
 }
-void mndUpdateIpWhite(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock) {
+void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock) {
   if (lock) {
     taosThreadRwlockWrlock(&ipWhiteMgt.rw);
     if (ipWhiteMgt.ver == 0) {
@@ -293,6 +313,20 @@ void mndUpdateIpWhite(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_
   }
 
   bool update = mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, user, fqdn, type);
+
+  void *pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, NULL);
+  while (pIter) {
+    size_t klen = 0;
+    char  *key = taosHashGetKey(pIter, &klen);
+
+    char *keyDup = taosMemoryCalloc(1, klen + 1);
+    memcpy(keyDup, key, klen);
+    update |= mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, keyDup, fqdn, type);
+    taosMemoryFree(keyDup);
+
+    pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, pIter);
+  }
+
   if (update) ipWhiteMgt.ver++;
 
   if (lock) taosThreadRwlockUnlock(&ipWhiteMgt.rw);
@@ -1178,7 +1212,7 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
     mndTransDrop(pTrans);
     goto _OVER;
   }
-  ipWhiteMgtUpdate(userObj.user, userObj.pIpWhiteList);
+  ipWhiteMgtUpdate(pMnode, userObj.user, userObj.pIpWhiteList);
   taosMemoryFree(userObj.pIpWhiteList);
 
   mndTransDrop(pTrans);
@@ -1346,7 +1380,7 @@ static int32_t mndAlterUser(SMnode *pMnode, SUserObj *pOld, SUserObj *pNew, SRpc
     mndTransDrop(pTrans);
     return -1;
   }
-  ipWhiteMgtUpdate(pNew->user, pNew->pIpWhiteList);
+  ipWhiteMgtUpdate(pMnode, pNew->user, pNew->pIpWhiteList);
   mndTransDrop(pTrans);
   return 0;
 }
@@ -2289,6 +2323,11 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
   for (int32_t i = 0; i < numOfUses; ++i) {
     SUserObj *pUser = mndAcquireUser(pMnode, pUsers[i].user);
     if (pUser == NULL) {
+      if (TSDB_CODE_MND_USER_NOT_EXIST == terrno) {
+        SGetUserAuthRsp rsp = {.dropped = 1};
+        memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
+        taosArrayPush(batchRsp.pArray, &rsp);
+      }
       mError("user:%s, failed to auth user since %s", pUsers[i].user, terrstr());
       continue;
     }

source/dnode/mnode/impl/src/mndVgroup.c

@@ -165,7 +165,7 @@ SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
   if(dataPos + sizeof(int32_t) + VGROUP_RESERVE_SIZE <= pRaw->dataLen){
     SDB_GET_INT32(pRaw, dataPos, &pVgroup->syncConfChangeVer, _OVER)
   }
-  
+
   SDB_GET_RESERVE(pRaw, dataPos, VGROUP_RESERVE_SIZE, _OVER)
 
   terrno = 0;
@@ -261,6 +261,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   createReq.daysToKeep0 = pDb->cfg.daysToKeep0;
   createReq.daysToKeep1 = pDb->cfg.daysToKeep1;
   createReq.daysToKeep2 = pDb->cfg.daysToKeep2;
+  createReq.keepTimeOffset = pDb->cfg.keepTimeOffset;
   createReq.minRows = pDb->cfg.minRows;
   createReq.maxRows = pDb->cfg.maxRows;
   createReq.walFsyncPeriod = pDb->cfg.walFsyncPeriod;
@@ -377,6 +378,7 @@ static void *mndBuildAlterVnodeConfigReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pV
   alterReq.daysToKeep0 = pDb->cfg.daysToKeep0;
   alterReq.daysToKeep1 = pDb->cfg.daysToKeep1;
   alterReq.daysToKeep2 = pDb->cfg.daysToKeep2;
+  alterReq.keepTimeOffset = pDb->cfg.keepTimeOffset;
   alterReq.walFsyncPeriod = pDb->cfg.walFsyncPeriod;
   alterReq.walLevel = pDb->cfg.walLevel;
   alterReq.strict = pDb->cfg.strict;
@@ -956,19 +958,19 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
           snprintf(role, sizeof(role), "%s%s", syncStr(pVgroup->vnodeGid[i].syncState), star);
           /*
           mInfo("db:%s, learner progress:%d", pDb->name, pVgroup->vnodeGid[i].learnerProgress);
-          
+
           if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEARNER) {
             if(pVgroup->vnodeGid[i].learnerProgress < 0){
-              snprintf(role, sizeof(role), "%s-", 
+              snprintf(role, sizeof(role), "%s-",
                 syncStr(pVgroup->vnodeGid[i].syncState));
-                
+
             }
             else if(pVgroup->vnodeGid[i].learnerProgress >= 100){
-              snprintf(role, sizeof(role), "%s--", 
+              snprintf(role, sizeof(role), "%s--",
                 syncStr(pVgroup->vnodeGid[i].syncState));
             }
             else{
-              snprintf(role, sizeof(role), "%s%d", 
+              snprintf(role, sizeof(role), "%s%d",
                 syncStr(pVgroup->vnodeGid[i].syncState), pVgroup->vnodeGid[i].learnerProgress);
             }
           }
@@ -1391,7 +1393,7 @@ int32_t mndAddAlterVnodeConfirmAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
   return 0;
 }
 
-int32_t mndAddChangeConfigAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, 
+int32_t mndAddChangeConfigAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
                                   SVgObj *pOldVgroup, SVgObj *pNewVgroup, int32_t dnodeId) {
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pNewVgroup);
@@ -1743,9 +1745,9 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
         terrno = TSDB_CODE_VND_META_DATA_UNSAFE_DELETE;
         return -1;
       }
-      
+
       SSdb   *pSdb = pMnode->pSdb;
-      void   *pIter = NULL; 
+      void   *pIter = NULL;
 
       while (1) {
         SStbObj *pStb = NULL;
@@ -2176,7 +2178,7 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
   sprintf(obj, "%d", req.vgId);
 
   char detail[1000] = {0};
-  sprintf(detail, "dnodeId1:%d, dnodeId2:%d, dnodeId3:%d", 
+  sprintf(detail, "dnodeId1:%d, dnodeId2:%d, dnodeId3:%d",
           req.dnodeId1, req.dnodeId2, req.dnodeId3);
 
   auditRecord(pReq, pMnode->clusterId, "RedistributeVgroup", obj, "", detail);
@@ -2224,7 +2226,7 @@ static void *mndBuildSForceBecomeFollowerReq(SMnode *pMnode, SVgObj *pVgroup, in
 
   tSerializeSForceBecomeFollowerReq((char *)pReq + sizeof(SMsgHead), contLen, &balanceReq);
   *pContLen = contLen;
-  return pReq;                                  
+  return pReq;
 }
 
 int32_t mndAddBalanceVgroupLeaderAction(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, int32_t dnodeId) {
@@ -2471,7 +2473,7 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
 
   mndTransSetSerial(pTrans);
 
-  mInfo("trans:%d, vgId:%d, alter vgroup, syncConfChangeVer:%d, version:%d, replica:%d", 
+  mInfo("trans:%d, vgId:%d, alter vgroup, syncConfChangeVer:%d, version:%d, replica:%d",
         pTrans->id, pVgroup->vgId, pVgroup->syncConfChangeVer, pVgroup->version, pVgroup->replica);
 
   if (newVgroup.replica == 1 && pNewDb->cfg.replications == 3) {
@@ -2488,15 +2490,15 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
     newVgroup.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_LEARNER;
     newVgroup.vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_LEARNER;
     if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0) return -1;
-    mInfo("trans:%d, vgId:%d, add change config, syncConfChangeVer:%d, version:%d, replica:%d", 
+    mInfo("trans:%d, vgId:%d, add change config, syncConfChangeVer:%d, version:%d, replica:%d",
         pTrans->id, pVgroup->vgId, newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
     if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[1]) != 0) return -1;
-    mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d", 
+    mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d",
         pTrans->id, pVgroup->vgId, newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
     if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[2]) != 0) return -1;
-    mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d", 
+    mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d",
         pTrans->id, pVgroup->vgId, newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
-   
+
 
     //check learner
     newVgroup.vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
@@ -2532,7 +2534,7 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
   } else if (newVgroup.replica == 3 && pNewDb->cfg.replications == 1) {
     mInfo("db:%s, vgId:%d, will remove 2 vnodes, vn:0 dnode:%d vn:1 dnode:%d vn:2 dnode:%d", pVgroup->dbName,
           pVgroup->vgId, pVgroup->vnodeGid[0].dnodeId, pVgroup->vnodeGid[1].dnodeId, pVgroup->vnodeGid[2].dnodeId);
-    
+
     SVnodeGid del1 = {0};
     if (mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del1) != 0) return -1;
 
@@ -2552,7 +2554,7 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
 
     SVnodeGid del2 = {0};
     if (mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del2) != 0) return -1;
-    
+
     if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0) return -1;
 
     if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
@@ -2672,14 +2674,14 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   SDbObj   dbObj = {0};
   SArray  *pArray = mndBuildDnodesArray(pMnode, 0);
 
-  int32_t numOfTopics = 0;
-  if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) {
-    goto _OVER;
-  }
-  if (numOfTopics > 0) {
-    terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
-    goto _OVER;
-  }
+//  int32_t numOfTopics = 0;
+//  if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) {
+//    goto _OVER;
+//  }
+//  if (numOfTopics > 0) {
+//    terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
+//    goto _OVER;
+//  }
 
   int32_t numOfStreams = 0;
   if (mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams) != 0) {

source/dnode/vnode/CMakeLists.txt

@@ -65,7 +65,8 @@ set(
     "src/tq/tqSink.c"
     "src/tq/tqCommit.c"
     "src/tq/tqStreamTask.c"
-    "src/tq/tqSnapshot.c"
+    "src/tq/tqHandleSnapshot.c"
+    "src/tq/tqCheckInfoSnapshot.c"
     "src/tq/tqOffsetSnapshot.c"
     "src/tq/tqStreamStateSnap.c"
     "src/tq/tqStreamTaskSnap.c"

source/dnode/vnode/inc/vnode.h

@@ -86,11 +86,13 @@ void   *vnodeGetIdx(void *pVnode);
 void   *vnodeGetIvtIdx(void *pVnode);
 
 int32_t vnodeGetCtbNum(SVnode *pVnode, int64_t suid, int64_t *num);
+int32_t vnodeGetStbColumnNum(SVnode *pVnode, tb_uid_t suid, int *num);
 int32_t vnodeGetTimeSeriesNum(SVnode *pVnode, int64_t *num);
 int32_t vnodeGetAllCtbNum(SVnode *pVnode, int64_t *num);
 
 void    vnodeResetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
+int32_t vnodeGetLoadLite(SVnode *pVnode, SVnodeLoadLite *pLoad);
 int32_t vnodeValidateTableHash(SVnode *pVnode, char *tableFName);
 
 int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg);
@@ -130,11 +132,12 @@ tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name);
 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);
-bool     metaTbInFilterCache(void *pVnode, tb_uid_t suid, int8_t type);
-int32_t  metaPutTbToFilterCache(void *pVnode, tb_uid_t suid, int8_t type);
-int32_t  metaSizeOfTbFilterCache(void *pVnode, int8_t type);
+bool     metaTbInFilterCache(SMeta *pMeta, const void* key, int8_t type);
+int32_t  metaPutTbToFilterCache(SMeta *pMeta, const void* key, int8_t type);
+int32_t  metaSizeOfTbFilterCache(SMeta *pMeta, int8_t type);
+int32_t  metaInitTbFilterCache(SMeta *pMeta);
 
-int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables);
+int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t *numOfCols);
 
 // tsdb
 typedef struct STsdbReader STsdbReader;
@@ -281,6 +284,7 @@ struct STsdbCfg {
   int32_t keep0;  // just for save config, don't use in tsdbRead/tsdbCommit/..., and use STsdbKeepCfg in STsdb instead
   int32_t keep1;  // just for save config, don't use in tsdbRead/tsdbCommit/..., and use STsdbKeepCfg in STsdb instead
   int32_t keep2;  // just for save config, don't use in tsdbRead/tsdbCommit/..., and use STsdbKeepCfg in STsdb instead
+  int32_t keepTimeOffset;  // just for save config, use STsdbKeepCfg in STsdb instead
   SRetention retentions[TSDB_RETENTION_MAX];
 };
 
@@ -288,10 +292,10 @@ typedef struct {
   int64_t numOfSTables;
   int64_t numOfCTables;
   int64_t numOfNTables;
-  int64_t numOfCmprTables;
+  int64_t numOfReportedTimeSeries;
   int64_t numOfNTimeSeries;
   int64_t numOfTimeSeries;
-  int64_t itvTimeSeries;
+  // int64_t itvTimeSeries;
   int64_t pointsWritten;
   int64_t totalStorage;
   int64_t compStorage;

source/dnode/vnode/src/inc/meta.h

@@ -71,7 +71,7 @@ int32_t metaCacheDrop(SMeta* pMeta, int64_t uid);
 int32_t metaStatsCacheUpsert(SMeta* pMeta, SMetaStbStats* pInfo);
 int32_t metaStatsCacheDrop(SMeta* pMeta, int64_t uid);
 int32_t metaStatsCacheGet(SMeta* pMeta, int64_t uid, SMetaStbStats* pInfo);
-void    metaUpdateStbStats(SMeta* pMeta, int64_t uid, int64_t delta);
+void    metaUpdateStbStats(SMeta* pMeta, int64_t uid, int64_t deltaCtb, int32_t deltaCol);
 int32_t metaUidFilterCacheGet(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, LRUHandle** pHandle);
 
 struct SMeta {

source/dnode/vnode/src/inc/tq.h

@@ -134,7 +134,7 @@ int32_t tqMetaOpen(STQ* pTq);
 int32_t tqMetaClose(STQ* pTq);
 int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle);
 int32_t tqMetaDeleteHandle(STQ* pTq, const char* key);
-int32_t tqMetaRestoreHandle(STQ* pTq);
+//int32_t tqMetaRestoreHandle(STQ* pTq);
 int32_t tqMetaSaveCheckInfo(STQ* pTq, const char* key, const void* value, int32_t vLen);
 int32_t tqMetaDeleteCheckInfo(STQ* pTq, const char* key);
 int32_t tqMetaRestoreCheckInfo(STQ* pTq);

source/dnode/vnode/src/inc/tsdb.h

@@ -380,6 +380,8 @@ struct STsdb {
   TdThreadMutex        lruMutex;
   SLRUCache           *biCache;
   TdThreadMutex        biMutex;
+  SLRUCache           *bCache;
+  TdThreadMutex        bMutex;
   struct STFileSystem *pFS;  // new
   SRocksCache          rCache;
 };
@@ -643,13 +645,19 @@ struct SRowMerger {
 };
 
 typedef struct {
-  char     *path;
-  int32_t   szPage;
-  int32_t   flag;
-  TdFilePtr pFD;
-  int64_t   pgno;
-  uint8_t  *pBuf;
-  int64_t   szFile;
+  char       *path;
+  int32_t     szPage;
+  int32_t     flag;
+  TdFilePtr   pFD;
+  int64_t     pgno;
+  uint8_t    *pBuf;
+  int64_t     szFile;
+  STsdb      *pTsdb;
+  const char *objName;
+  uint8_t     s3File;
+  int32_t     fid;
+  int64_t     cid;
+  int64_t     blkno;
 } STsdbFD;
 
 struct SDelFWriter {
@@ -716,9 +724,9 @@ typedef struct SSttBlockLoadCostInfo {
 } SSttBlockLoadCostInfo;
 
 typedef struct SSttBlockLoadInfo {
-  SBlockData blockData[2];     // buffered block data
-  int32_t    statisBlockIndex; // buffered statistics block index
-  void      *statisBlock;      // buffered statistics block data
+  SBlockData blockData[2];      // buffered block data
+  int32_t    statisBlockIndex;  // buffered statistics block index
+  void      *statisBlock;       // buffered statistics block data
   void      *pSttStatisBlkArray;
   SArray    *aSttBlk;
   int32_t    blockIndex[2];  // to denote the loaded block in the corresponding position.
@@ -861,6 +869,9 @@ int32_t tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h);
 int32_t tsdbCacheGetBlockIdx(SLRUCache *pCache, SDataFReader *pFileReader, LRUHandle **handle);
 int32_t tsdbBICacheRelease(SLRUCache *pCache, LRUHandle *h);
 
+int32_t tsdbCacheGetBlockS3(SLRUCache *pCache, STsdbFD *pFD, LRUHandle **handle);
+int32_t tsdbBCacheRelease(SLRUCache *pCache, LRUHandle *h);
+
 int32_t tsdbCacheDeleteLastrow(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);
 int32_t tsdbCacheDeleteLast(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);
 int32_t tsdbCacheDelete(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);

source/dnode/vnode/src/inc/vndCos.h

@@ -22,15 +22,21 @@
 extern "C" {
 #endif
 
-extern int8_t tsS3Enabled;
+#define S3_BLOCK_CACHE
+
+extern int8_t  tsS3Enabled;
+extern int32_t tsS3BlockSize;
+extern int32_t tsS3BlockCacheSize;
 
 int32_t s3Init();
 void    s3CleanUp();
 int32_t s3PutObjectFromFile(const char *file, const char *object);
+int32_t s3PutObjectFromFile2(const char *file, const char *object);
 void    s3DeleteObjectsByPrefix(const char *prefix);
 void    s3DeleteObjects(const char *object_name[], int nobject);
 bool    s3Exists(const char *object_name);
 bool    s3Get(const char *object_name, const char *path);
+int32_t s3GetObjectBlock(const char *object_name, int64_t offset, int64_t size, uint8_t **ppBlock);
 void    s3EvictCache(const char *path, long object_size);
 long    s3Size(const char *object_name);
 

source/dnode/vnode/src/inc/vnodeInt.h

@@ -69,6 +69,8 @@ typedef struct STqSnapReader      STqSnapReader;
 typedef struct STqSnapWriter      STqSnapWriter;
 typedef struct STqOffsetReader    STqOffsetReader;
 typedef struct STqOffsetWriter    STqOffsetWriter;
+typedef struct STqCheckInfoReader STqCheckInfoReader;
+typedef struct STqCheckInfoWriter STqCheckInfoWriter;
 typedef struct SStreamTaskReader  SStreamTaskReader;
 typedef struct SStreamTaskWriter  SStreamTaskWriter;
 typedef struct SStreamStateReader SStreamStateReader;
@@ -168,7 +170,8 @@ int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid);
 int metaAddIndexToSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq);
 int metaDropIndexFromSTable(SMeta* pMeta, int64_t version, SDropIndexReq* pReq);
 
-int64_t       metaGetTimeSeriesNum(SMeta* pMeta);
+int64_t       metaGetTimeSeriesNum(SMeta* pMeta, int type);
+void          metaUpdTimeSeriesNum(SMeta* pMeta);
 SMCtbCursor*  metaOpenCtbCursor(void* pVnode, tb_uid_t uid, int lock);
 int32_t       metaResumeCtbCursor(SMCtbCursor* pCtbCur, int8_t first);
 void          metaPauseCtbCursor(SMCtbCursor* pCtbCur);
@@ -308,6 +311,14 @@ int32_t tqSnapRead(STqSnapReader* pReader, uint8_t** ppData);
 int32_t tqSnapWriterOpen(STQ* pTq, int64_t sver, int64_t ever, STqSnapWriter** ppWriter);
 int32_t tqSnapWriterClose(STqSnapWriter** ppWriter, int8_t rollback);
 int32_t tqSnapWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData);
+// STqCheckInfoshotReader ==
+int32_t tqCheckInfoReaderOpen(STQ* pTq, int64_t sver, int64_t ever, STqCheckInfoReader** ppReader);
+int32_t tqCheckInfoReaderClose(STqCheckInfoReader** ppReader);
+int32_t tqCheckInfoRead(STqCheckInfoReader* pReader, uint8_t** ppData);
+// STqCheckInfoshotWriter ======================================
+int32_t tqCheckInfoWriterOpen(STQ* pTq, int64_t sver, int64_t ever, STqCheckInfoWriter** ppWriter);
+int32_t tqCheckInfoWriterClose(STqCheckInfoWriter** ppWriter, int8_t rollback);
+int32_t tqCheckInfoWrite(STqCheckInfoWriter* pWriter, uint8_t* pData, uint32_t nData);
 // STqOffsetReader ========================================
 int32_t tqOffsetReaderOpen(STQ* pTq, int64_t sver, int64_t ever, STqOffsetReader** ppReader);
 int32_t tqOffsetReaderClose(STqOffsetReader** ppReader);
@@ -400,6 +411,7 @@ struct STsdbKeepCfg {
   int32_t keep0;
   int32_t keep1;
   int32_t keep2;
+  int32_t keepTimeOffset;
 };
 
 typedef struct SVCommitSched {
@@ -503,6 +515,7 @@ enum {
   SNAP_DATA_STREAM_TASK_CHECKPOINT = 10,
   SNAP_DATA_STREAM_STATE = 11,
   SNAP_DATA_STREAM_STATE_BACKEND = 12,
+  SNAP_DATA_TQ_CHECKINFO = 13,
 };
 
 struct SSnapDataHdr {

source/dnode/vnode/src/meta/metaCache.c

@@ -14,6 +14,13 @@
  */
 #include "meta.h"
 
+#ifdef TD_ENTERPRISE
+extern const char* tkLogStb[];
+extern const char* tkAuditStb[];
+extern const int   tkLogStbNum;
+extern const int   tkAuditStbNum;
+#endif
+
 #define TAG_FILTER_RES_KEY_LEN  32
 #define META_CACHE_BASE_BUCKET  1024
 #define META_CACHE_STATS_BUCKET 16
@@ -69,6 +76,7 @@ struct SMetaCache {
 
   struct STbFilterCache {
     SHashObj* pStb;
+    SHashObj* pStbName;
   } STbFilterCache;
 };
 
@@ -178,6 +186,13 @@ int32_t metaCacheOpen(SMeta* pMeta) {
     goto _err2;
   }
 
+  pCache->STbFilterCache.pStbName =
+      taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
+  if (pCache->STbFilterCache.pStbName == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err2;
+  }
+
   pMeta->pCache = pCache;
   return code;
 
@@ -204,6 +219,7 @@ void metaCacheClose(SMeta* pMeta) {
     taosHashCleanup(pMeta->pCache->STbGroupResCache.pTableEntry);
 
     taosHashCleanup(pMeta->pCache->STbFilterCache.pStb);
+    taosHashCleanup(pMeta->pCache->STbFilterCache.pStbName);
 
     taosMemoryFree(pMeta->pCache);
     pMeta->pCache = NULL;
@@ -893,30 +909,59 @@ int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid) {
   return TSDB_CODE_SUCCESS;
 }
 
-bool metaTbInFilterCache(void* pVnode, tb_uid_t suid, int8_t type) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+bool metaTbInFilterCache(SMeta *pMeta, const void* key, int8_t type) {
+  if (type == 0 && taosHashGet(pMeta->pCache->STbFilterCache.pStb, key, sizeof(tb_uid_t))) {
+    return true;
+  }
 
-  if (type == 0 && taosHashGet(pMeta->pCache->STbFilterCache.pStb, &suid, sizeof(suid))) {
+  if (type == 1 && taosHashGet(pMeta->pCache->STbFilterCache.pStbName, key, strlen(key))) {
     return true;
   }
 
   return false;
 }
 
-int32_t metaPutTbToFilterCache(void* pVnode, tb_uid_t suid, int8_t type) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
-
+int32_t metaPutTbToFilterCache(SMeta *pMeta, const void* key, int8_t type) {
   if (type == 0) {
-    return taosHashPut(pMeta->pCache->STbFilterCache.pStb, &suid, sizeof(suid), NULL, 0);
+    return taosHashPut(pMeta->pCache->STbFilterCache.pStb, key, sizeof(tb_uid_t), NULL, 0);
+  }
+
+  if (type == 1) {
+    return taosHashPut(pMeta->pCache->STbFilterCache.pStbName, key, strlen(key), NULL, 0);
   }
 
   return 0;
 }
 
-int32_t metaSizeOfTbFilterCache(void* pVnode, int8_t type) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+int32_t metaSizeOfTbFilterCache(SMeta *pMeta, int8_t type) {
   if (type == 0) {
     return taosHashGetSize(pMeta->pCache->STbFilterCache.pStb);
   }
   return 0;
-}
+}
+
+int32_t metaInitTbFilterCache(SMeta* pMeta) {
+#ifdef TD_ENTERPRISE
+  int32_t      tbNum = 0;
+  const char** pTbArr = NULL;
+  const char*  dbName = NULL;
+
+  if (!(dbName = strchr(pMeta->pVnode->config.dbname, '.'))) return 0;
+  if (0 == strncmp(++dbName, "log", TSDB_DB_NAME_LEN)) {
+    tbNum = tkLogStbNum;
+    pTbArr = (const char**)&tkLogStb;
+  } else if (0 == strncmp(dbName, "audit", TSDB_DB_NAME_LEN)) {
+    tbNum = tkAuditStbNum;
+    pTbArr = (const char**)&tkAuditStb;
+  }
+  if (tbNum && pTbArr) {
+    for (int32_t i = 0; i < tbNum; ++i) {
+      if (metaPutTbToFilterCache(pMeta, pTbArr[i], 1) != 0) {
+        return terrno ? terrno : -1;
+      }
+    }
+  }
+#else
+#endif
+  return 0;
+}

source/dnode/vnode/src/meta/metaOpen.c

@@ -176,6 +176,10 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
     goto _err;
   }
 
+  if (metaInitTbFilterCache(pMeta) != 0) {
+    goto _err;
+  }
+
   metaDebug("vgId:%d, meta is opened", TD_VID(pVnode));
 
   *ppMeta = pMeta;

source/dnode/vnode/src/meta/metaQuery.c

@@ -696,22 +696,30 @@ int64_t metaGetTbNum(SMeta *pMeta) {
   return pMeta->pVnode->config.vndStats.numOfCTables + pMeta->pVnode->config.vndStats.numOfNTables;
 }
 
-// N.B. Called by statusReq per second
-int64_t metaGetTimeSeriesNum(SMeta *pMeta) {
-  // sum of (number of columns of stable -  1) * number of ctables (excluding timestamp column)
-  int64_t nTables = metaGetTbNum(pMeta);
-  if (nTables - pMeta->pVnode->config.vndStats.numOfCmprTables > 100 ||
-      pMeta->pVnode->config.vndStats.numOfTimeSeries <= 0 ||
-      ++pMeta->pVnode->config.vndStats.itvTimeSeries % (60 * 5) == 0) {
-    int64_t num = 0;
-    vnodeGetTimeSeriesNum(pMeta->pVnode, &num);
-    pMeta->pVnode->config.vndStats.numOfTimeSeries = num;
+void metaUpdTimeSeriesNum(SMeta *pMeta) {
+  int64_t nCtbTimeSeries = 0;
+  if (vnodeGetTimeSeriesNum(pMeta->pVnode, &nCtbTimeSeries) == 0) {
+    atomic_store_64(&pMeta->pVnode->config.vndStats.numOfTimeSeries, nCtbTimeSeries);
+  }
+}
 
-    pMeta->pVnode->config.vndStats.itvTimeSeries = (TD_VID(pMeta->pVnode) % 100) * 2;
-    pMeta->pVnode->config.vndStats.numOfCmprTables = nTables;
+static FORCE_INLINE int64_t metaGetTimeSeriesNumImpl(SMeta *pMeta, bool forceUpd) {
+  // sum of (number of columns of stable -  1) * number of ctables (excluding timestamp column)
+  SVnodeStats *pStats = &pMeta->pVnode->config.vndStats;
+  if (forceUpd || pStats->numOfTimeSeries <= 0) {
+    metaUpdTimeSeriesNum(pMeta);
   }
 
-  return pMeta->pVnode->config.vndStats.numOfTimeSeries + pMeta->pVnode->config.vndStats.numOfNTimeSeries;
+  return pStats->numOfTimeSeries + pStats->numOfNTimeSeries;
+}
+
+// type: 1 reported timeseries
+int64_t metaGetTimeSeriesNum(SMeta *pMeta, int type) {
+  int64_t nTimeSeries = metaGetTimeSeriesNumImpl(pMeta, false);
+  if (type == 1) {
+    atomic_store_64(&pMeta->pVnode->config.vndStats.numOfReportedTimeSeries, nTimeSeries);
+  }
+  return nTimeSeries;
 }
 
 typedef struct {
@@ -1509,9 +1517,10 @@ _exit:
   return code;
 }
 
-int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables) {
+int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t *numOfCols) {
   int32_t code = 0;
-  *numOfTables = 0;
+
+  if (!numOfTables && !numOfCols) goto _exit;
 
   SVnode *pVnodeObj = pVnode;
   metaRLock(pVnodeObj->pMeta);
@@ -1520,19 +1529,26 @@ int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables) {
   SMetaStbStats state = {0};
   if (metaStatsCacheGet(pVnodeObj->pMeta, uid, &state) == TSDB_CODE_SUCCESS) {
     metaULock(pVnodeObj->pMeta);
-    *numOfTables = state.ctbNum;
+    if (numOfTables) *numOfTables = state.ctbNum;
+    if (numOfCols) *numOfCols = state.colNum;
+    ASSERTS(state.colNum > 0, "vgId:%d, suid:%" PRIi64 " nCols:%d <= 0 in metaCache", TD_VID(pVnodeObj), uid,
+            state.colNum);
     goto _exit;
   }
 
   // slow path: search TDB
   int64_t ctbNum = 0;
+  int32_t colNum = 0;
   vnodeGetCtbNum(pVnode, uid, &ctbNum);
-
+  vnodeGetStbColumnNum(pVnode, uid, &colNum);
   metaULock(pVnodeObj->pMeta);
-  *numOfTables = ctbNum;
+
+  if (numOfTables) *numOfTables = ctbNum;
+  if (numOfCols) *numOfCols = colNum;
 
   state.uid = uid;
   state.ctbNum = ctbNum;
+  state.colNum = colNum;
 
   // upsert the cache
   metaWLock(pVnodeObj->pMeta);
@@ -1543,12 +1559,12 @@ _exit:
   return code;
 }
 
-void metaUpdateStbStats(SMeta *pMeta, int64_t uid, int64_t delta) {
+void metaUpdateStbStats(SMeta *pMeta, int64_t uid, int64_t deltaCtb, int32_t deltaCol) {
   SMetaStbStats stats = {0};
 
   if (metaStatsCacheGet(pMeta, uid, &stats) == TSDB_CODE_SUCCESS) {
-    stats.ctbNum += delta;
-
+    stats.ctbNum += deltaCtb;
+    stats.colNum += deltaCol;
     metaStatsCacheUpsert(pMeta, &stats);
   }
 }

source/dnode/vnode/src/meta/metaTable.c

@@ -15,6 +15,8 @@
 
 #include "meta.h"
 
+extern SDmNotifyHandle dmNotifyHdl;
+
 static int  metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
 static int  metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
 static int  metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME);
@@ -26,7 +28,7 @@ static int  metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME);
 static int  metaUpdateCtbIdx(SMeta *pMeta, const SMetaEntry *pME);
 static int  metaUpdateSuidIdx(SMeta *pMeta, const SMetaEntry *pME);
 static int  metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry);
-static int  metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type);
+static int  metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *pSuid, int8_t *pSysTbl);
 static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey);
 // opt ins_tables query
 static int metaUpdateBtimeIdx(SMeta *pMeta, const SMetaEntry *pME);
@@ -34,6 +36,7 @@ static int metaDeleteBtimeIdx(SMeta *pMeta, const SMetaEntry *pME);
 static int metaUpdateNcolIdx(SMeta *pMeta, const SMetaEntry *pME);
 static int metaDeleteNcolIdx(SMeta *pMeta, const SMetaEntry *pME);
 
+
 static void metaGetEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) {
   pInfo->uid = pEntry->uid;
   pInfo->version = pEntry->version;
@@ -191,6 +194,18 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
   return 0;
 }
 
+static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) {
+#if defined(TD_ENTERPRISE) && !defined(_TD_DARWIN_64)
+  int64_t nTimeSeries = metaGetTimeSeriesNum(pMeta, 0);
+  int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries;
+  if (deltaTS > tsTimeSeriesThreshold) {
+    if (0 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 2)) {
+      tsem_post(&dmNotifyHdl.sem);
+    }
+  }
+#endif
+}
+
 int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   SMetaEntry  me = {0};
   int         kLen = 0;
@@ -292,7 +307,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb
 
   for (int32_t iChild = 0; iChild < taosArrayGetSize(tbUidList); iChild++) {
     tb_uid_t uid = *(tb_uid_t *)taosArrayGet(tbUidList, iChild);
-    metaDropTableByUid(pMeta, uid, NULL);
+    metaDropTableByUid(pMeta, uid, NULL, NULL, NULL);
   }
 
   // drop super table
@@ -304,8 +319,12 @@ _drop_super_table:
   tdbTbDelete(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn);
   tdbTbDelete(pMeta->pSuidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn);
 
+  metaStatsCacheDrop(pMeta, pReq->suid);
+
   metaULock(pMeta);
 
+  metaUpdTimeSeriesNum(pMeta);
+
 _exit:
   tdbFree(pKey);
   tdbFree(pData);
@@ -376,6 +395,9 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   nStbEntry.stbEntry.schemaRow = pReq->schemaRow;
   nStbEntry.stbEntry.schemaTag = pReq->schemaTag;
 
+  int32_t deltaCol = pReq->schemaRow.nCols - oStbEntry.stbEntry.schemaRow.nCols;
+  bool    updStat = deltaCol != 0 && !metaTbInFilterCache(pMeta, pReq->name, 1);
+
   metaWLock(pMeta);
   // compare two entry
   if (oStbEntry.stbEntry.schemaRow.version != pReq->schemaRow.version) {
@@ -390,8 +412,19 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
 
   // metaStatsCacheDrop(pMeta, nStbEntry.uid);
 
+  if (updStat) {
+    metaUpdateStbStats(pMeta, pReq->suid, 0, deltaCol);
+  }
   metaULock(pMeta);
 
+  if (updStat) {
+    int64_t ctbNum;
+    metaGetStbStats(pMeta->pVnode, pReq->suid, &ctbNum, NULL);
+    pMeta->pVnode->config.vndStats.numOfTimeSeries += (ctbNum * deltaCol);
+    metaTimeSeriesNotifyCheck(pMeta);
+  }
+
+_exit:
   if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
   tDecoderClear(&dc);
   tdbTbcClose(pTbDbc);
@@ -733,7 +766,10 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
   }
   metaReaderClear(&mr);
 
+  bool sysTbl = (pReq->type == TSDB_CHILD_TABLE) && metaTbInFilterCache(pMeta, pReq->ctb.stbName, 1);
+
   // build SMetaEntry
+  SVnodeStats *pStats = &pMeta->pVnode->config.vndStats;
   me.version = ver;
   me.type = pReq->type;
   me.uid = pReq->uid;
@@ -767,10 +803,16 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
     }
 #endif
 
-    ++pMeta->pVnode->config.vndStats.numOfCTables;
+    ++pStats->numOfCTables;
+
+    if (!sysTbl) {
+      int32_t nCols = 0;
+      metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols);
+      pStats->numOfTimeSeries += nCols - 1;
+    }
 
     metaWLock(pMeta);
-    metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1);
+    metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0);
     metaUidCacheClear(pMeta, me.ctbEntry.suid);
     metaTbGroupCacheClear(pMeta, me.ctbEntry.suid);
     metaULock(pMeta);
@@ -782,12 +824,14 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
     me.ntbEntry.schemaRow = pReq->ntb.schemaRow;
     me.ntbEntry.ncid = me.ntbEntry.schemaRow.pSchema[me.ntbEntry.schemaRow.nCols - 1].colId + 1;
 
-    ++pMeta->pVnode->config.vndStats.numOfNTables;
-    pMeta->pVnode->config.vndStats.numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1;
+    ++pStats->numOfNTables;
+    pStats->numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1;
   }
 
   if (metaHandleEntry(pMeta, &me) < 0) goto _err;
 
+  metaTimeSeriesNotifyCheck(pMeta);
+
   if (pMetaRsp) {
     *pMetaRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp));
 
@@ -817,7 +861,9 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
   void    *pData = NULL;
   int      nData = 0;
   int      rc = 0;
-  tb_uid_t uid;
+  tb_uid_t uid = 0;
+  tb_uid_t suid = 0;
+  int8_t   sysTbl = 0;
   int      type;
 
   rc = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &pData, &nData);
@@ -828,9 +874,19 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
   uid = *(tb_uid_t *)pData;
 
   metaWLock(pMeta);
-  metaDropTableByUid(pMeta, uid, &type);
+  rc = metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl);
   metaULock(pMeta);
 
+  if (rc < 0) goto _exit;
+
+  if (!sysTbl && type == TSDB_CHILD_TABLE) {
+    int32_t      nCols = 0;
+    SVnodeStats *pStats = &pMeta->pVnode->config.vndStats;
+    if (metaGetStbStats(pMeta->pVnode, suid, NULL, &nCols) == 0) {
+      pStats->numOfTimeSeries -= nCols - 1;
+    }
+  }
+
   if ((type == TSDB_CHILD_TABLE || type == TSDB_NORMAL_TABLE) && tbUids) {
     taosArrayPush(tbUids, &uid);
   }
@@ -839,20 +895,49 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
     *tbUid = uid;
   }
 
+_exit:
   tdbFree(pData);
-  return 0;
+  return rc;
 }
 
 void metaDropTables(SMeta *pMeta, SArray *tbUids) {
   if (taosArrayGetSize(tbUids) == 0) return;
 
+  int64_t    nCtbDropped = 0;
+  SSHashObj *suidHash = tSimpleHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));
+
   metaWLock(pMeta);
   for (int i = 0; i < taosArrayGetSize(tbUids); ++i) {
     tb_uid_t uid = *(tb_uid_t *)taosArrayGet(tbUids, i);
-    metaDropTableByUid(pMeta, uid, NULL);
+    tb_uid_t suid = 0;
+    int8_t   sysTbl = 0;
+    int      type;
+    metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl);
+    if (!sysTbl && type == TSDB_CHILD_TABLE && suid != 0 && suidHash) {
+      int64_t *pVal = tSimpleHashGet(suidHash, &suid, sizeof(tb_uid_t));
+      if (pVal) {
+        nCtbDropped = *pVal + 1;
+      } else {
+        nCtbDropped = 1;
+      }
+      tSimpleHashPut(suidHash, &suid, sizeof(tb_uid_t), &nCtbDropped, sizeof(int64_t));
+    }
     metaDebug("batch drop table:%" PRId64, uid);
   }
   metaULock(pMeta);
+
+  // update timeseries
+  void   *pCtbDropped = NULL;
+  int32_t iter = 0;
+  while ((pCtbDropped = tSimpleHashIterate(suidHash, pCtbDropped, &iter))) {
+    tb_uid_t    *pSuid = tSimpleHashGetKey(pCtbDropped, NULL);
+    int32_t      nCols = 0;
+    SVnodeStats *pStats = &pMeta->pVnode->config.vndStats;
+    if (metaGetStbStats(pMeta->pVnode, *pSuid, NULL, &nCols) == 0) {
+      pStats->numOfTimeSeries -= *(int64_t *)pCtbDropped * (nCols - 1);
+    }
+  }
+  tSimpleHashCleanup(suidHash);
 }
 
 static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) {
@@ -987,7 +1072,7 @@ static int metaDeleteTtl(SMeta *pMeta, const SMetaEntry *pME) {
   return ttlMgrDeleteTtl(pMeta->pTtlMgr, &ctx);
 }
 
-static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
+static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *pSuid, int8_t* pSysTbl) {
   void      *pData = NULL;
   int        nData = 0;
   int        rc = 0;
@@ -1012,6 +1097,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
   if (type) *type = e.type;
 
   if (e.type == TSDB_CHILD_TABLE) {
+    if (pSuid) *pSuid = e.ctbEntry.suid;
     void *tData = NULL;
     int   tLen = 0;
 
@@ -1024,6 +1110,8 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
         tDecoderInit(&tdc, tData, tLen);
         metaDecodeEntry(&tdc, &stbEntry);
 
+        if (pSysTbl) *pSysTbl = metaTbInFilterCache(pMeta, stbEntry.name, 1) ? 1 : 0;
+
         SSchema        *pTagColumn = NULL;
         SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
         if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) {
@@ -1075,8 +1163,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
     tdbTbDelete(pMeta->pCtbIdx, &(SCtbIdxKey){.suid = e.ctbEntry.suid, .uid = uid}, sizeof(SCtbIdxKey), pMeta->txn);
 
     --pMeta->pVnode->config.vndStats.numOfCTables;
-
-    metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1);
+    metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1, 0);
     metaUidCacheClear(pMeta, e.ctbEntry.suid);
     metaTbGroupCacheClear(pMeta, e.ctbEntry.suid);
   } else if (e.type == TSDB_NORMAL_TABLE) {
@@ -1243,6 +1330,9 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
         terrno = TSDB_CODE_VND_COL_ALREADY_EXISTS;
         goto _err;
       }
+      if ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) < 0) {
+        goto _err;
+      }
       pSchema->version++;
       pSchema->nCols++;
       pNewSchema = taosMemoryMalloc(sizeof(SSchema) * pSchema->nCols);
@@ -1255,6 +1345,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
       strcpy(pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].name, pAlterTbReq->colName);
 
       ++pMeta->pVnode->config.vndStats.numOfNTimeSeries;
+      metaTimeSeriesNotifyCheck(pMeta);
       break;
     case TSDB_ALTER_TABLE_DROP_COLUMN:
       if (pColumn == NULL) {

source/dnode/vnode/src/sma/smaOpen.c

@@ -27,6 +27,7 @@ static int32_t rsmaRestore(SSma *pSma);
     pKeepCfg->keep0 = pKeepCfg->keep2;                                                            \
     pKeepCfg->keep1 = pKeepCfg->keep2;                                                            \
     pKeepCfg->days = smaEvalDays(v, pCfg->retentions, l, pCfg->precision, pCfg->days);            \
+    pKeepCfg->keepTimeOffset = 0;                                                                 \
   } while (0)
 
 #define SMA_OPEN_RSMA_IMPL(v, l)                                                             \

source/dnode/vnode/src/tq/tq.c

@@ -697,7 +697,9 @@ int32_t tqProcessSubscribeReq(STQ* pTq, int64_t sversion, char* msg, int32_t msg
       tqDestroyTqHandle(&handle);
       goto end;
     }
+    taosWLockLatch(&pTq->lock);
     ret = tqMetaSaveHandle(pTq, req.subKey, &handle);
+    taosWUnLockLatch(&pTq->lock);
   } else {
     while(1){
       taosWLockLatch(&pTq->lock);
@@ -710,7 +712,7 @@ int32_t tqProcessSubscribeReq(STQ* pTq, int64_t sversion, char* msg, int32_t msg
         continue;
       }
       if (pHandle->consumerId == req.newConsumerId) {  // do nothing
-        tqInfo("vgId:%d no switch consumer:0x%" PRIx64 " remains, because redo wal log", req.vgId, req.newConsumerId);
+        tqInfo("vgId:%d no switch consumer:0x%" PRIx64 " remains", req.vgId, req.newConsumerId);
       } else {
         tqInfo("vgId:%d switch consumer from Id:0x%" PRIx64 " to Id:0x%" PRIx64, req.vgId, pHandle->consumerId,
             req.newConsumerId);

source/dnode/vnode/src/tq/tqCheckInfoSnapshot.c

@@ -0,0 +1,196 @@
+/*
+ * 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/>.
+ */
+
+#include "meta.h"
+#include "tdbInt.h"
+#include "tq.h"
+
+// STqCheckInfoReader ========================================
+struct STqCheckInfoReader {
+  STQ*    pTq;
+  int64_t sver;
+  int64_t ever;
+  TBC*    pCur;
+};
+
+int32_t tqCheckInfoReaderOpen(STQ* pTq, int64_t sver, int64_t ever, STqCheckInfoReader** ppReader) {
+  int32_t        code = 0;
+  STqCheckInfoReader* pReader = NULL;
+
+  // alloc
+  pReader = (STqCheckInfoReader*)taosMemoryCalloc(1, sizeof(STqCheckInfoReader));
+  if (pReader == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pReader->pTq = pTq;
+  pReader->sver = sver;
+  pReader->ever = ever;
+
+  // impl
+  code = tdbTbcOpen(pTq->pCheckStore, &pReader->pCur, NULL);
+  if (code) {
+    taosMemoryFree(pReader);
+    goto _err;
+  }
+
+  code = tdbTbcMoveToFirst(pReader->pCur);
+  if (code) {
+    taosMemoryFree(pReader);
+    goto _err;
+  }
+
+  tqInfo("vgId:%d, vnode checkinfo tq reader opened", TD_VID(pTq->pVnode));
+
+  *ppReader = pReader;
+  return code;
+
+_err:
+  tqError("vgId:%d, vnode checkinfo tq reader open failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
+  *ppReader = NULL;
+  return code;
+}
+
+int32_t tqCheckInfoReaderClose(STqCheckInfoReader** ppReader) {
+  int32_t code = 0;
+
+  tdbTbcClose((*ppReader)->pCur);
+  taosMemoryFree(*ppReader);
+  *ppReader = NULL;
+
+  return code;
+}
+
+int32_t tqCheckInfoRead(STqCheckInfoReader* pReader, uint8_t** ppData) {
+  int32_t     code = 0;
+  void* pKey = NULL;
+  void* pVal = NULL;
+  int32_t     kLen = 0;
+  int32_t     vLen = 0;
+
+  if (tdbTbcNext(pReader->pCur, &pKey, &kLen, &pVal, &vLen)) {
+    goto _exit;
+  }
+
+  *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + vLen);
+  if (*ppData == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+  SSnapDataHdr* pHdr = (SSnapDataHdr*)(*ppData);
+  pHdr->type = SNAP_DATA_TQ_CHECKINFO;
+  pHdr->size = vLen;
+  memcpy(pHdr->data, pVal, vLen);
+
+_exit:
+  tdbFree(pKey);
+  tdbFree(pVal);
+
+  tqInfo("vgId:%d, vnode check info tq read data, vLen:%d", TD_VID(pReader->pTq->pVnode), vLen);
+  return code;
+
+_err:
+  tdbFree(pKey);
+  tdbFree(pVal);
+
+  tqError("vgId:%d, vnode check info tq read data failed since %s", TD_VID(pReader->pTq->pVnode), tstrerror(code));
+  return code;
+}
+
+// STqCheckInfoWriter ========================================
+struct STqCheckInfoWriter {
+  STQ*    pTq;
+  int64_t sver;
+  int64_t ever;
+  TXN*    txn;
+};
+
+int32_t tqCheckInfoWriterOpen(STQ* pTq, int64_t sver, int64_t ever, STqCheckInfoWriter** ppWriter) {
+  int32_t        code = 0;
+  STqCheckInfoWriter* pWriter;
+
+  // alloc
+  pWriter = (STqCheckInfoWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
+  if (pWriter == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pWriter->pTq = pTq;
+  pWriter->sver = sver;
+  pWriter->ever = ever;
+
+  if (tdbBegin(pTq->pMetaDB, &pWriter->txn, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) {
+    code = -1;
+    taosMemoryFree(pWriter);
+    goto _err;
+  }
+
+  *ppWriter = pWriter;
+  return code;
+
+_err:
+  tqError("vgId:%d, tq check info writer open failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
+  *ppWriter = NULL;
+  return code;
+}
+
+int32_t tqCheckInfoWriterClose(STqCheckInfoWriter** ppWriter, int8_t rollback) {
+  int32_t        code = 0;
+  STqCheckInfoWriter* pWriter = *ppWriter;
+  STQ*           pTq = pWriter->pTq;
+
+  if (rollback) {
+    tdbAbort(pWriter->pTq->pMetaDB, pWriter->txn);
+  } else {
+    code = tdbCommit(pWriter->pTq->pMetaDB, pWriter->txn);
+    if (code) goto _err;
+    code = tdbPostCommit(pWriter->pTq->pMetaDB, pWriter->txn);
+    if (code) goto _err;
+  }
+
+  taosMemoryFree(pWriter);
+  *ppWriter = NULL;
+
+  return code;
+
+_err:
+  tqError("vgId:%d, tq check info writer close failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
+  return code;
+}
+
+int32_t tqCheckInfoWrite(STqCheckInfoWriter* pWriter, uint8_t* pData, uint32_t nData) {
+  int32_t   code = 0;
+  STQ*      pTq = pWriter->pTq;
+  STqCheckInfo info = {0};
+  SDecoder     decoder;
+  SDecoder* pDecoder = &decoder;
+
+  tDecoderInit(pDecoder, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
+  code = tDecodeSTqCheckInfo(pDecoder, &info);
+  if (code) goto _err;
+  code = taosHashPut(pTq->pCheckInfo, info.topic, strlen(info.topic), &info, sizeof(STqCheckInfo));
+  if (code) goto _err;
+  code = tqMetaSaveCheckInfo(pTq, info.topic, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
+  if (code) goto _err;
+  tDecoderClear(pDecoder);
+
+  return code;
+
+_err:
+  tDecoderClear(pDecoder);
+  tqError("vgId:%d, vnode check info tq write failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
+  return code;
+}

source/dnode/vnode/src/tq/tqHandleSnapshot.c

@@ -75,29 +75,13 @@ int32_t tqSnapReaderClose(STqSnapReader** ppReader) {
 
 int32_t tqSnapRead(STqSnapReader* pReader, uint8_t** ppData) {
   int32_t     code = 0;
-  const void* pKey = NULL;
-  const void* pVal = NULL;
+  void* pKey = NULL;
+  void* pVal = NULL;
   int32_t     kLen = 0;
   int32_t     vLen = 0;
-  SDecoder    decoder;
-  STqHandle   handle;
 
-  *ppData = NULL;
-  for (;;) {
-    if (tdbTbcGet(pReader->pCur, &pKey, &kLen, &pVal, &vLen)) {
-      goto _exit;
-    }
-
-    tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
-    tDecodeSTqHandle(&decoder, &handle);
-    tDecoderClear(&decoder);
-
-    if (handle.snapshotVer <= pReader->sver && handle.snapshotVer >= pReader->ever) {
-      tdbTbcMoveToNext(pReader->pCur);
-      break;
-    } else {
-      tdbTbcMoveToNext(pReader->pCur);
-    }
+  if (tdbTbcNext(pReader->pCur, &pKey, &kLen, &pVal, &vLen)) {
+    goto _exit;
   }
 
   *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + vLen);
@@ -111,13 +95,15 @@ int32_t tqSnapRead(STqSnapReader* pReader, uint8_t** ppData) {
   pHdr->size = vLen;
   memcpy(pHdr->data, pVal, vLen);
 
-  tqInfo("vgId:%d, vnode snapshot tq read data, version:%" PRId64 " subKey: %s vLen:%d", TD_VID(pReader->pTq->pVnode),
-         handle.snapshotVer, handle.subKey, vLen);
-
 _exit:
+  tdbFree(pKey);
+  tdbFree(pVal);
+  tqInfo("vgId:%d, vnode snapshot tq read data, vLen:%d", TD_VID(pReader->pTq->pVnode), vLen);
   return code;
 
 _err:
+  tdbFree(pKey);
+  tdbFree(pVal);
   tqError("vgId:%d, vnode snapshot tq read data failed since %s", TD_VID(pReader->pTq->pVnode), tstrerror(code));
   return code;
 }
@@ -173,20 +159,13 @@ int32_t tqSnapWriterClose(STqSnapWriter** ppWriter, int8_t rollback) {
     if (code) goto _err;
   }
 
-  int vgId = TD_VID(pWriter->pTq->pVnode);
-
   taosMemoryFree(pWriter);
   *ppWriter = NULL;
 
-  // restore from metastore
-  if (tqMetaRestoreHandle(pTq) < 0) {
-    goto _err;
-  }
-
   return code;
 
 _err:
-  tqError("vgId:%d, tq snapshot writer close failed since %s", vgId, tstrerror(code));
+  tqError("vgId:%d, tq snapshot writer close failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
   return code;
 }
 
@@ -195,19 +174,18 @@ int32_t tqSnapWrite(STqSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
   STQ*      pTq = pWriter->pTq;
   SDecoder  decoder = {0};
   SDecoder* pDecoder = &decoder;
-  STqHandle handle;
+  STqHandle handle = {0};
 
   tDecoderInit(pDecoder, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
   code = tDecodeSTqHandle(pDecoder, &handle);
-  if (code) goto _err;
+  if (code) goto end;
+  taosWLockLatch(&pTq->lock);
   code = tqMetaSaveHandle(pTq, handle.subKey, &handle);
-  if (code < 0) goto _err;
-  tDecoderClear(pDecoder);
+  taosWUnLockLatch(&pTq->lock);
 
-  return code;
-
-_err:
+end:
   tDecoderClear(pDecoder);
-  tqError("vgId:%d, vnode snapshot tq write failed since %s", TD_VID(pTq->pVnode), tstrerror(code));
+  tqDestroyTqHandle(&handle);
+  tqInfo("vgId:%d, vnode snapshot tq write result:%d", TD_VID(pTq->pVnode), code);
   return code;
 }