other: merge main.

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

@@ -45,6 +45,9 @@ The following are some explanations about data subscription, which require some
 
 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
 
 The related schemas and APIs in various languages are described as follows:

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

@@ -56,7 +56,7 @@ database_option: {
 - WAL_FSYNC_PERIOD: specifies the interval (in milliseconds) at which data is written from the WAL to disk. This parameter takes effect only when the WAL parameter is set to 2. The default value is 3000. Enter a value between 0 and 180000. The value 0 indicates that incoming data is immediately written to disk.
 - MAXROWS: specifies the maximum number of rows recorded in a block. The default value is 4096.
 - MINROWS: specifies the minimum number of rows recorded in a block. The default value is 100.
-- KEEP: specifies the time for which data is retained. Enter a value between 1 and 365000. The default value is 3650. The value of the KEEP parameter must be greater than or equal to the value of the DURATION parameter. TDengine automatically deletes data that is older than the value of the KEEP parameter. You can use m (minutes), h (hours), and d (days) as the unit, for example KEEP 100h or KEEP 10d. If you do not include a unit, d is used by default. TDengine Enterprise supports [Tiered Storage](https://docs.tdengine.com/tdinternal/arch/#tiered-storage) function, thus multiple KEEP values (comma separated and up to 3 values supported, and meet keep 0 <= keep 1 <= keep 2, e.g. KEEP 100h,100d,3650d) are supported; TDengine OSS does not support Tiered Storage function (although multiple keep values are configured, they do not take effect, only the maximum keep value is used as KEEP).
+- KEEP: specifies the time for which data is retained. Enter a value between 1 and 365000. The default value is 3650. The value of the KEEP parameter must be greater than or equal to three times of the value of the DURATION parameter. TDengine automatically deletes data that is older than the value of the KEEP parameter. You can use m (minutes), h (hours), and d (days) as the unit, for example KEEP 100h or KEEP 10d. If you do not include a unit, d is used by default. TDengine Enterprise supports [Tiered Storage](https://docs.tdengine.com/tdinternal/arch/#tiered-storage) function, thus multiple KEEP values (comma separated and up to 3 values supported, and meet keep 0 <= keep 1 <= keep 2, e.g. KEEP 100h,100d,3650d) are supported; TDengine OSS does not support Tiered Storage function (although multiple keep values are configured, they do not take effect, only the maximum keep value is used as KEEP).
 - PAGES: specifies the number of pages in the metadata storage engine cache on each vnode. Enter a value greater than or equal to 64. The default value is 256. The space occupied by metadata storage on each vnode is equal to the product of the values of the PAGESIZE and PAGES parameters. The space occupied by default is 1 MB.
 - PAGESIZE: specifies the size (in KB) of each page in the metadata storage engine cache on each vnode. The default value is 4. Enter a value between 1 and 16384.
 - PRECISION: specifies the precision at which a database records timestamps. Enter ms for milliseconds, us for microseconds, or ns for nanoseconds. The default value is ms.

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

@@ -24,7 +24,7 @@ SELECT [hints] [DISTINCT] select_list
 hints: /*+ [hint([hint_param_list])] [hint([hint_param_list])] */
 
 hint:
-    BATCH_SCAN | NO_BATCH_SCAN   
+    BATCH_SCAN | NO_BATCH_SCAN | SORT_FOR_GROUP
 
 select_list:
     select_expr [, select_expr] ...
@@ -87,15 +87,17 @@ Hints are a means of user control over query optimization for individual stateme
 
 The list of currently supported Hints is as follows:
 
-|    **Hint**   |    **Params**  |         **Comment**        |       **Scopt**            |  
-| :-----------: | -------------- | -------------------------- | -------------------------- |
-| BATCH_SCAN    | None           | Batch table scan           | JOIN statment for stable   |         
-| NO_BATCH_SCAN | None           | Sequential table scan      | JOIN statment for stable   |         
+|    **Hint**   |    **Params**  |         **Comment**        |       **Scopt**            |
+| :-----------: | -------------- | -------------------------- | -----------------------------------|
+| BATCH_SCAN    | None           | Batch table scan           | JOIN statment for stable           |
+| NO_BATCH_SCAN | None           | Sequential table scan      | JOIN statment for stable           |
+| SORT_FOR_GROUP| None           | Use sort for partition     | With normal column in partition by list |
 
 For example:
 
 ```sql
 SELECT /*+ BATCH_SCAN() */ a.ts FROM stable1 a, stable2 b where a.tag0 = b.tag0 and a.ts = b.ts;
+SELECT /*+ SORT_FOR_GROUP() */ count(*), c1 FROM stable1 PARTITION BY c1;
 ```
 
 ## Lists

docs/en/12-taos-sql/16-operators.md

@@ -54,6 +54,7 @@ LIKE is used together with wildcards to match strings. Its usage is described as
 MATCH and NMATCH are used together with regular expressions to match strings. Their usage is described as follows:
 
 - Use POSIX regular expression syntax. For more information, see Regular Expressions.
+- The `MATCH` operator returns true when the regular expression is matched. The `NMATCH` operator returns true when the regular expression is not matched.
 - Regular expression can be used against only table names, i.e. `tbname`, and tags/columns of binary/nchar types.
 - The maximum length of regular expression string is 128 bytes. Configuration parameter `maxRegexStringLen` can be used to set the maximum allowed regular expression. It's a configuration parameter on the client side, and will take effect after restarting the client.
 

docs/en/12-taos-sql/24-show.md

@@ -73,10 +73,10 @@ Shows the SQL statement used to create the specified table. This statement can b
 ## SHOW DATABASES
 
 ```sql
-SHOW DATABASES;
+SHOW [USER | SYSTEM] DATABASES;
 ```
 
-Shows all user-created databases.
+Shows all databases. The `USER` qualifier specifies only user-created databases. The `SYSTEM` qualifier specifies only system databases.
 
 ## SHOW DNODES
 
@@ -183,10 +183,10 @@ Shows all subscriptions in the system.
 ## SHOW TABLES
 
 ```sql
-SHOW [db_name.]TABLES [LIKE 'pattern'];
+SHOW [NORMAL | CHILD] [db_name.]TABLES [LIKE 'pattern'];
 ```
 
-Shows all standard tables and subtables in the current database. You can use LIKE for fuzzy matching.
+Shows all standard tables and subtables in the current database. You can use LIKE for fuzzy matching. The `Normal` qualifier specifies standard tables. The `CHILD` qualifier specifies subtables.
 
 ## SHOW TABLE DISTRIBUTED
 

docs/en/13-operation/07-import.md

@@ -59,4 +59,4 @@ Query OK, 9 row(s) affected (0.004763s)
 
 ## Import using taosdump
 
-A convenient tool for importing and exporting data is provided by TDengine, `taosdump`, which can be used to export data from one TDengine cluster and import into another one. For the details of using `taosdump` please refer to [Tool for exporting and importing data: taosdump](/reference/taosdump).
+A convenient tool for importing and exporting data is provided by TDengine, `taosdump`, which can be used to export data from one TDengine cluster and import into another one. For the details of using `taosdump` please refer to the taosdump documentation.

docs/en/13-operation/08-export.md

@@ -19,4 +19,4 @@ The data of table or STable specified by `tb_name` will be exported into a file
 
 ## Export Using taosdump
 
-With `taosdump`, you can choose to export the data of all databases, a database, a table or a STable, you can also choose to export the data within a time range, or even only export the schema definition of a table. For the details of using `taosdump` please refer to [Tool for exporting and importing data: taosdump](/reference/taosdump).
+With `taosdump`, you can choose to export the data of all databases, a database, a table or a STable, you can also choose to export the data within a time range, or even only export the schema definition of a table. For the details of using `taosdump` please refer to the taosdump documentation.

docs/en/13-operation/10-monitor.md

@@ -11,8 +11,6 @@ The collection of the monitoring information is enabled by default, but can be d
 
 TDinsight is a complete solution which uses the monitoring database `log` mentioned previously, and Grafana, to monitor a TDengine cluster.
 
-Please refer to [TDinsight Grafana Dashboard](../../reference/tdinsight) to learn more details about using TDinsight to monitor TDengine.
-
 A script `TDinsight.sh` is provided to deploy TDinsight automatically.
 
 Download `TDinsight.sh` with the below command:
@@ -41,8 +39,6 @@ An existing Grafana Notification Channel can be specified with parameter `-E`, t
 
 Launch `TDinsight.sh` with the command above and restart Grafana, then open Dashboard `http://localhost:3000/d/tdinsight`.
 
-For more use cases and restrictions please refer to [TDinsight](/reference/tdinsight/).
-
 ## log database
 
 The data of tdinsight dashboard is stored in `log` database (default. You can change it in taoskeeper's config file. For more infrmation, please reference to [taoskeeper document](/reference/taosKeeper)). The taoskeeper will create log database on taoskeeper startup.

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/05-taosbenchmark.md

@@ -13,7 +13,7 @@ taosBenchmark (formerly taosdemo ) is a tool for testing the performance of TDen
 
 There are two ways to install taosBenchmark:
 
-- Installing the official TDengine installer will automatically install taosBenchmark. 
+- Installing the official TDengine installer will automatically install taosBenchmark.
 
 - Compile taos-tools separately and install them. Please refer to the [taos-tools](https://github.com/taosdata/taos-tools) repository for details.
 

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/en/20-third-party/01-grafana.mdx

@@ -218,7 +218,7 @@ The example to query the average system memory usage for the specified interval
 
 ### Importing the Dashboard
 
-You can install TDinsight dashboard in data source configuration page (like `http://localhost:3000/datasources/edit/1/dashboards`) as a monitoring visualization tool for TDengine cluster. Ensure that you use TDinsight for 3.x. Please note TDinsight for 3.x needs to configure and run taoskeeper correctly. Check the [TDinsight User Manual](/reference/tdinsight/) for the details.
+You can install TDinsight dashboard in data source configuration page (like `http://localhost:3000/datasources/edit/1/dashboards`) as a monitoring visualization tool for TDengine cluster. Ensure that you use TDinsight for 3.x. Please note TDinsight for 3.x needs to configure and run taoskeeper correctly. 
 
 ![TDengine Database Grafana plugine import dashboard](./import_dashboard.webp)
 

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

@@ -21,7 +21,7 @@ TDengine Source Connector is used to read data from TDengine in real-time and se
 1. Linux operating system
 2. Java 8 and Maven installed
 3. Git/curl/vi is installed
-4. TDengine is installed and started. 
+4. TDengine is installed and started.
 
 ## Install Kafka
 

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

@@ -51,7 +51,8 @@ sudo seeq restart
     "UseSSL": false,
     "JdbcProperties": null,
     "GenericDatabaseConfig": {
-        "DatabaseJdbcUrl": "jdbc:TAOS://localhost:6030/?user=root&password=taosdata",
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://localhost:6030/?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
         "ResolutionInNanoseconds": 1000,
         "ZonedColumnTypes": []
     }
@@ -144,6 +145,7 @@ Please login with Seeq administrator and create a few data sources as following.
     "JdbcProperties": null,
     "GenericDatabaseConfig": {
         "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
         "ResolutionInNanoseconds": 1000,
         "ZonedColumnTypes": []
     }
@@ -203,6 +205,7 @@ Please login with Seeq administrator and create a few data sources as following.
     "JdbcProperties": null,
     "GenericDatabaseConfig": {
         "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
         "ResolutionInNanoseconds": 1000,
         "ZonedColumnTypes": []
     }
@@ -261,6 +264,7 @@ Please login with Seeq administrator and create a few data sources as following.
     "JdbcProperties": null,
     "GenericDatabaseConfig": {
         "DatabaseJdbcUrl": "jdbc:TAOS-RS://127.0.0.1:6041/power?user=root&password=taosdata",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
         "ResolutionInNanoseconds": 1000,
         "ZonedColumnTypes": []
     }
@@ -350,13 +354,15 @@ Please note that when using TDengine Cloud, you need to specify the database nam
 
 #### The data source of TDengine Cloud example
 
+This data source contains the data from a smart meter in public database smartmeters.
+
 ```
 {
     "QueryDefinitions": [
         {
             "Name": "CloudVoltage",
             "Type": "SIGNAL",
-            "Sql": "SELECT  ts, voltage FROM test.meters",
+            "Sql": "SELECT  ts, voltage FROM smartmeters.d1000",
             "Enabled": true,
             "TestMode": false,
             "TestQueriesDuringSync": true,
@@ -399,7 +405,8 @@ Please note that when using TDengine Cloud, you need to specify the database nam
     "UseSSL": false,
     "JdbcProperties": null,
     "GenericDatabaseConfig": {
-        "DatabaseJdbcUrl": "jdbc:TAOS-RS://gw.cloud.taosdata.com?useSSL=true&token=41ac9d61d641b6b334e8b76f45f5a8XXXXXXXXXX",
+        "DatabaseJdbcUrl": "jdbc:TAOS-RS://gw.us-west-2.aws.cloud.tdengine.com?useSSL=true&token=42b874395452d36f38dd6bf4317757611b213683",
+        "SqlDriverClassName": "com.taosdata.jdbc.rs.RestfulDriver",
         "ResolutionInNanoseconds": 1000,
         "ZonedColumnTypes": []
     }

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.md

@@ -45,6 +45,9 @@ import CDemo from "./_sub_c.mdx";
 
 本文档不对消息队列本身的知识做更多的介绍，如果需要了解，请自行搜索。
 
+从3.2.0.0版本开始，数据订阅支持vnode迁移和分裂。
+由于数据订阅依赖wal文件，而在vnode迁移和分裂的过程中，wal并不会同步过去，所以迁移或分裂后，之前没消费完的wal数据后消费不到。所以请保证之前把数据全部消费完后，再进行vnode迁移或分裂，否则，消费会丢失数据。
+
 ## 主要数据结构和 API
 
 不同语言下， TMQ 订阅相关的 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/12-taos-sql/02-database.md

@@ -56,7 +56,7 @@ database_option: {
 - WAL_FSYNC_PERIOD：当 WAL 参数设置为 2 时，落盘的周期。默认为 3000，单位毫秒。最小为 0，表示每次写入立即落盘；最大为 180000，即三分钟。
 - MAXROWS：文件块中记录的最大条数，默认为 4096 条。
 - MINROWS：文件块中记录的最小条数，默认为 100 条。
-- KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。企业版支持[多级存储](https://docs.taosdata.com/tdinternal/arch/#%E5%A4%9A%E7%BA%A7%E5%AD%98%E5%82%A8)功能, 因此, 可以设置多个保存时间（多个以英文逗号分隔，最多 3 个，满足 keep 0 <= keep 1 <= keep 2，如 KEEP 100h,100d,3650d）; 社区版不支持多级存储功能（即使配置了多个保存时间, 也不会生效, KEEP 会取最大的保存时间）。
+- KEEP：表示数据文件保存的天数，缺省值为 3650，取值范围 [1, 365000]，且必须大于或等于3倍的 DURATION 参数值。数据库会自动删除保存时间超过 KEEP 值的数据。KEEP 可以使用加单位的表示形式，如 KEEP 100h、KEEP 10d 等，支持 m（分钟）、h（小时）和 d（天）三个单位。也可以不写单位，如 KEEP 50，此时默认单位为天。企业版支持[多级存储](https://docs.taosdata.com/tdinternal/arch/#%E5%A4%9A%E7%BA%A7%E5%AD%98%E5%82%A8)功能, 因此, 可以设置多个保存时间（多个以英文逗号分隔，最多 3 个，满足 keep 0 <= keep 1 <= keep 2，如 KEEP 100h,100d,3650d）; 社区版不支持多级存储功能（即使配置了多个保存时间, 也不会生效, KEEP 会取最大的保存时间）。
 - PAGES：一个 VNODE 中元数据存储引擎的缓存页个数，默认为 256，最小 64。一个 VNODE 元数据存储占用 PAGESIZE \* PAGES，默认情况下为 1MB 内存。
 - PAGESIZE：一个 VNODE 中元数据存储引擎的页大小，单位为 KB，默认为 4 KB。范围为 1 到 16384，即 1 KB 到 16 MB。
 - PRECISION：数据库的时间戳精度。ms 表示毫秒，us 表示微秒，ns 表示纳秒，默认 ms 毫秒。

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

@@ -24,7 +24,7 @@ SELECT [hints] [DISTINCT] select_list
 hints: /*+ [hint([hint_param_list])] [hint([hint_param_list])] */
 
 hint:
-    BATCH_SCAN | NO_BATCH_SCAN   
+    BATCH_SCAN | NO_BATCH_SCAN | SORT_FOR_GROUP
 
 select_list:
     select_expr [, select_expr] ...
@@ -87,15 +87,17 @@ Hints 是用户控制单个语句查询优化的一种手段，当 Hint 不适
 
 目前支持的 Hints 列表如下：
 
-|    **Hint**   |    **参数**    |         **说明**           |       **适用范围**         |  
-| :-----------: | -------------- | -------------------------- | -------------------------- |
-| BATCH_SCAN    | 无             | 采用批量读表的方式         | 超级表 JOIN 语句           |         
-| NO_BATCH_SCAN | 无             | 采用顺序读表的方式         | 超级表 JOIN 语句           |         
+|    **Hint**   |    **参数**    |         **说明**           |       **适用范围**         |
+| :-----------: | -------------- | -------------------------- | -----------------------------|
+| BATCH_SCAN    | 无             | 采用批量读表的方式         | 超级表 JOIN 语句             |
+| NO_BATCH_SCAN | 无             | 采用顺序读表的方式         | 超级表 JOIN 语句             |
+| SORT_FOR_GROUP| 无             | 采用sort方式进行分组       | partition by 列表有普通列时  |
 
 举例： 
 
 ```sql
 SELECT /*+ BATCH_SCAN() */ a.ts FROM stable1 a, stable2 b where a.tag0 = b.tag0 and a.ts = b.ts;
+SELECT /*+ SORT_FOR_GROUP() */ count(*), c1 FROM stable1 PARTITION BY c1;
 ```
 
 ## 列表

docs/zh/12-taos-sql/16-operators.md

@@ -54,6 +54,7 @@ LIKE 条件使用通配符字符串进行匹配检查，规则如下：
 MATCH 条件和 NMATCH 条件使用正则表达式进行匹配，规则如下：
 
 - 支持符合 POSIX 规范的正则表达式，具体规范内容可参见 Regular Expressions。
+- MATCH 和正则表达式匹配时, 返回 TURE.  NMATCH 和正则表达式不匹配时, 返回 TRUE. 
 - 只能针对子表名（即 tbname）、字符串类型的标签值进行正则表达式过滤，不支持普通列的过滤。
 - 正则匹配字符串长度不能超过 128 字节。可以通过参数 maxRegexStringLen 设置和调整最大允许的正则匹配字符串，该参数是客户端配置参数，需要重启客户端才能生效
 

docs/zh/12-taos-sql/24-show.md

@@ -73,10 +73,10 @@ SHOW CREATE TABLE [db_name.]tb_name
 ## SHOW DATABASES
 
 ```sql
-SHOW DATABASES;
+SHOW [USER | SYSTEM] DATABASES;
 ```
 
-显示用户定义的所有数据库。
+显示定义的所有数据库。SYSTEM 指定只显示系统数据库。USER 指定只显示用户创建的数据库。
 
 ## SHOW DNODES
 
@@ -183,10 +183,10 @@ SHOW SUBSCRIPTIONS;
 ## SHOW TABLES
 
 ```sql
-SHOW [db_name.]TABLES [LIKE 'pattern'];
+SHOW [NORMAL | CHILD] [db_name.]TABLES [LIKE 'pattern'];
 ```
 
-显示当前数据库下的所有普通表和子表的信息。可以使用 LIKE 对表名进行模糊匹配。
+显示当前数据库下的所有普通表和子表的信息。可以使用 LIKE 对表名进行模糊匹配。NORMAL 指定只显示普通表信息， CHILD 指定只显示子表信息。
 
 ## SHOW TABLE DISTRIBUTED
 

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

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

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 的废弃参数
 

docs/zh/17-operation/04-import.md

@@ -59,4 +59,4 @@ Query OK, 9 row(s) affected (0.004763s)
 
 ## taosdump 工具导入
 
-TDengine 提供了方便的数据库导入导出工具 taosdump。用户可以将 taosdump 从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见：[TDengine 数据备份工具: taosdump](/reference/taosdump)。
+TDengine 提供了方便的数据库导入导出工具 taosdump。用户可以将 taosdump 从一个系统导出的数据，导入到其他系统中。具体使用方法，请参考 taosdump 的相关文档。

docs/zh/17-operation/05-export.md

@@ -17,5 +17,4 @@ select * from <tb_name> >> data.csv;
 
 ## 用 taosdump 导出数据
 
-利用 taosdump，用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表，所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参见：
-[TDengine 数据备份工具: taosdump](/reference/taosdump)。
+利用 taosdump，用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表，所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参考 taosdump 的相关文档。

docs/zh/17-operation/06-monitor.md

@@ -9,8 +9,6 @@ TDengine 通过 [taosKeeper](/reference/taosKeeper/) 将服务器的 CPU、内
 
 ## TDinsight - 使用监控数据库 + Grafana 对 TDengine 进行监控的解决方案
 
-监控数据库将提供更多的监控项，您可以从 [TDinsight Grafana Dashboard](/reference/tdinsight/) 了解如何使用 TDinsight 方案对 TDengine 进行监控。
-
 我们提供了一个自动化脚本 `TDinsight.sh` 对 TDinsight 进行部署。
 
 下载 `TDinsight.sh`：
@@ -37,8 +35,6 @@ chmod +x TDinsight.sh
 
 运行程序并重启 Grafana 服务，打开面板：`http://localhost:3000/d/tdinsight`。
 
-更多使用场景和限制请参考[TDinsight](/reference/tdinsight/) 文档。
-
 ## log 库
 
 TDinsight dashboard 数据来源于 log 库（存放监控数据的默认db，可以在 taoskeeper 配置文件中修改，具体参考 [taoskeeper 文档](/reference/taosKeeper)）。taoskeeper 启动后会自动创建 log 库，并将监控数据写入到该数据库中。

docs/zh/20-third-party/01-grafana.mdx

@@ -218,7 +218,7 @@ docker run -d \
 
 ### 导入 Dashboard
 
-在数据源配置页面，您可以为该数据源导入 TDinsight 面板，作为 TDengine 集群的监控可视化工具。如果 TDengine 服务端为 3.0 版本请选择 `TDinsight for 3.x` 导入。注意 TDinsight for 3.x 需要运行和配置 taoskeeper，相关使用说明请见 [TDinsight 用户手册](/reference/tdinsight/)。
+在数据源配置页面，您可以为该数据源导入 TDinsight 面板，作为 TDengine 集群的监控可视化工具。如果 TDengine 服务端为 3.0 版本请选择 `TDinsight for 3.x` 导入。注意 TDinsight for 3.x 需要运行和配置 taoskeeper。
 
 ![TDengine Database Grafana plugine import dashboard](./import_dashboard.webp)
 

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,6 +125,8 @@ typedef enum {
 
 typedef enum {
   TAOS_NOTIFY_PASSVER = 0,
+  TAOS_NOTIFY_WHITELIST_VER = 1,
+  TAOS_NOTIFY_USER_DROPPED = 2,
 } TAOS_NOTIFY_TYPE;
 
 #define RET_MSG_LENGTH 1024
@@ -236,6 +238,14 @@ DLL_EXPORT void taos_set_hb_quit(int8_t quitByKill);
 
 DLL_EXPORT int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type);
 
+typedef void (*__taos_async_whitelist_fn_t)(void *param, int code, TAOS *taos, int numOfWhiteLists, uint64_t* pWhiteLists);
+DLL_EXPORT void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param);
+
+typedef enum {
+  TAOS_CONN_MODE_BI = 0,
+} TAOS_CONN_MODE;
+
+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);
@@ -268,6 +278,13 @@ typedef enum tmq_conf_res_t {
   TMQ_CONF_OK = 0,
 } tmq_conf_res_t;
 
+typedef enum tmq_res_t {
+  TMQ_RES_INVALID = -1,
+  TMQ_RES_DATA = 1,
+  TMQ_RES_TABLE_META = 2,
+  TMQ_RES_METADATA = 3,
+} tmq_res_t;
+
 typedef struct tmq_topic_assignment {
   int32_t vgId;
   int64_t currentOffset;
@@ -302,6 +319,9 @@ 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);
 DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
 DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
@@ -309,34 +329,22 @@ DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES* res);
 DLL_EXPORT const char *tmq_err2str(int32_t code);
 
 /* ------------------------------ TAOSX -----------------------------------*/
-// note: following apis are unstable
-enum tmq_res_t {
-  TMQ_RES_INVALID = -1,
-  TMQ_RES_DATA = 1,
-  TMQ_RES_TABLE_META = 2,
-  TMQ_RES_METADATA = 3,
-};
-
 typedef struct tmq_raw_data {
   void    *raw;
   uint32_t raw_len;
   uint16_t raw_type;
 } tmq_raw_data;
 
-typedef enum tmq_res_t tmq_res_t;
-
-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 int32_t     tmq_get_raw(TAOS_RES *res, tmq_raw_data *raw);
 DLL_EXPORT int32_t     tmq_write_raw(TAOS *taos, tmq_raw_data raw);
 DLL_EXPORT int         taos_write_raw_block(TAOS *taos, int numOfRows, char *pData, const char *tbname);
 DLL_EXPORT int         taos_write_raw_block_with_fields(TAOS *taos, int rows, char *pData, const char *tbname,
                                                         TAOS_FIELD *fields, int numFields);
 DLL_EXPORT void        tmq_free_raw(tmq_raw_data raw);
+
 // Returning null means error. Returned result need to be freed by tmq_free_json_meta
 DLL_EXPORT char *tmq_get_json_meta(TAOS_RES *res);
 DLL_EXPORT void  tmq_free_json_meta(char *jsonMeta);
-
 /* ---------------------------- TAOSX END -------------------------------- */
 
 typedef enum {

include/common/tcommon.h

@@ -135,13 +135,11 @@ static inline int STupleKeyCmpr(const void* pKey1, int kLen1, const void* pKey2,
 }
 
 enum {
-  TMQ_MSG_TYPE__DUMMY = 0,
-  TMQ_MSG_TYPE__POLL_DATA_RSP,
+  TMQ_MSG_TYPE__POLL_DATA_RSP = 0,
   TMQ_MSG_TYPE__POLL_META_RSP,
   TMQ_MSG_TYPE__EP_RSP,
   TMQ_MSG_TYPE__POLL_DATA_META_RSP,
   TMQ_MSG_TYPE__WALINFO_RSP,
-  TMQ_MSG_TYPE__END_RSP,
 };
 
 enum {

include/common/tdatablock.h

@@ -28,6 +28,7 @@ typedef struct SBlockOrderInfo {
   bool             nullFirst;
   int32_t          order;
   int32_t          slotId;
+  void*            compFn;
   SColumnInfoData* pColData;
 } SBlockOrderInfo;
 
@@ -82,6 +83,15 @@ static FORCE_INLINE bool colDataIsNull_s(const SColumnInfoData* pColumnInfoData,
   }
 }
 
+static FORCE_INLINE bool colDataIsNull_t(const SColumnInfoData* pColumnInfoData, uint32_t row, bool isVarType) {
+  if (!pColumnInfoData->hasNull) return false;
+  if (isVarType) {
+    return colDataIsNull_var(pColumnInfoData, row);
+  } else {
+    return pColumnInfoData->nullbitmap ? colDataIsNull_f(pColumnInfoData->nullbitmap, row) : false;
+  }
+}
+
 static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, uint32_t totalRows, uint32_t row,
                                        SColumnDataAgg* pColAgg) {
   if (!pColumnInfoData->hasNull) {
@@ -210,6 +220,10 @@ double blockDataGetSerialRowSize(const SSDataBlock* pBlock);
 size_t blockDataGetSerialMetaSize(uint32_t numOfCols);
 
 int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo);
+/**
+ * @brief find how many rows already in order start from first row
+ */
+int32_t blockDataGetSortedRows(SSDataBlock* pDataBlock, SArray* pOrderInfo);
 
 int32_t colInfoDataEnsureCapacity(SColumnInfoData* pColumn, uint32_t numOfRows, bool clearPayload);
 int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);

include/common/tglobal.h

@@ -88,6 +88,7 @@ extern int64_t tsMndLogRetention;
 extern int8_t  tsGrant;
 extern int32_t tsMndGrantMode;
 extern bool    tsMndSkipGrant;
+extern bool    tsEnableWhiteList;
 
 // dnode
 extern int64_t tsDndStart;
@@ -144,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;
@@ -158,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
@@ -205,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,11 @@ typedef enum {
 } EGrantType;
 
 int32_t grantCheck(EGrantType grant);
+#ifndef TD_GRANT_OPTIMIZE
+int32_t grantAlterActiveCode(const char* old, const char* new, char* out, int8_t type);
+#else
+int32_t grantAlterActiveCode(int32_t did, const char* old, const char* new, char* out, int8_t type);
+#endif
 
 #ifndef GRANTS_CFG
 #ifdef TD_ENTERPRISE

include/common/tmsg.h

@@ -184,6 +184,8 @@ typedef enum _mgmt_table {
 #define TSDB_ALTER_USER_REMOVE_WRITE_TABLE     0x10
 #define TSDB_ALTER_USER_ADD_ALL_TABLE          0x11
 #define TSDB_ALTER_USER_REMOVE_ALL_TABLE       0x12
+#define TSDB_ALTER_USER_ADD_WHITE_LIST         0x13
+#define TSDB_ALTER_USER_DROP_WHITE_LIST        0x14
 
 #define TSDB_ALTER_USER_PRIVILEGES 0x2
 
@@ -418,10 +420,9 @@ typedef enum ENodeType {
   QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT,
   QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN,
   QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE,
-  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL  
+  QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL
 } ENodeType;
 
-
 typedef struct {
   int32_t vgId;
   char*   dbFName;
@@ -855,6 +856,7 @@ typedef struct {
   int32_t  authVer;
   char     sVer[TSDB_VERSION_LEN];
   char     sDetailVer[128];
+  int64_t  whiteListVer;
 } SConnectRsp;
 
 int32_t tSerializeSConnectRsp(void* buf, int32_t bufLen, SConnectRsp* pRsp);
@@ -884,6 +886,17 @@ int32_t tSerializeSDropUserReq(void* buf, int32_t bufLen, SDropUserReq* pReq);
 int32_t tDeserializeSDropUserReq(void* buf, int32_t bufLen, SDropUserReq* pReq);
 void    tFreeSDropUserReq(SDropUserReq *pReq);
 
+typedef struct SIpV4Range{
+    uint32_t ip;
+    uint32_t mask;
+} SIpV4Range;
+
+typedef struct {
+  int32_t    num;
+  SIpV4Range pIpRange[];
+} SIpWhiteList;
+
+SIpWhiteList* cloneIpWhiteList(SIpWhiteList* pIpWhiteList);
 typedef struct {
   int8_t createType;
   int8_t superUser;  // denote if it is a super user or not
@@ -891,6 +904,8 @@ typedef struct {
   int8_t enable;
   char   user[TSDB_USER_LEN];
   char   pass[TSDB_USET_PASSWORD_LEN];
+  int32_t     numIpRanges;
+  SIpV4Range* pIpRanges;
   int32_t sqlLen;
   char*   sql;
 } SCreateUserReq;
@@ -899,6 +914,30 @@ int32_t tSerializeSCreateUserReq(void* buf, int32_t bufLen, SCreateUserReq* pReq
 int32_t tDeserializeSCreateUserReq(void* buf, int32_t bufLen, SCreateUserReq* pReq);
 void    tFreeSCreateUserReq(SCreateUserReq *pReq);
 
+typedef struct {
+  int64_t     ver;
+  char        user[TSDB_USER_LEN];
+  int32_t     numOfRange;
+  SIpV4Range* pIpRanges;
+} SUpdateUserIpWhite;
+typedef struct {
+  int64_t             ver;
+  int                 numOfUser;
+  SUpdateUserIpWhite* pUserIpWhite;
+} SUpdateIpWhite;
+
+int32_t         tSerializeSUpdateIpWhite(void* buf, int32_t bufLen, SUpdateIpWhite* pReq);
+int32_t         tDeserializeSUpdateIpWhite(void* buf, int32_t bufLen, SUpdateIpWhite* pReq);
+void            tFreeSUpdateIpWhiteReq(SUpdateIpWhite* pReq);
+SUpdateIpWhite* cloneSUpdateIpWhiteReq(SUpdateIpWhite* pReq);
+
+typedef struct {
+  int64_t ipWhiteVer;
+} SRetrieveIpWhiteReq;
+
+int32_t tSerializeRetrieveIpWhite(void* buf, int32_t bufLen, SRetrieveIpWhiteReq* pReq);
+int32_t tDeserializeRetrieveIpWhite(void* buf, int32_t bufLen, SRetrieveIpWhiteReq* pReq);
+
 typedef struct {
   int8_t  alterType;
   int8_t  superUser;
@@ -910,6 +949,8 @@ typedef struct {
   char    tabName[TSDB_TABLE_NAME_LEN];
   char*   tagCond;
   int32_t tagCondLen;
+  int32_t     numIpRanges;
+  SIpV4Range* pIpRanges;
   int32_t sqlLen;
   char*   sql;
 } SAlterUserReq;
@@ -932,19 +973,37 @@ typedef struct {
   int8_t    superAuth;
   int8_t    sysInfo;
   int8_t    enable;
-  int8_t    reserve;
+  int8_t    dropped;
   SHashObj* createdDbs;
   SHashObj* readDbs;
   SHashObj* writeDbs;
   SHashObj* readTbs;
   SHashObj* writeTbs;
   SHashObj* useDbs;
+  int64_t whiteListVer;
 } SGetUserAuthRsp;
 
 int32_t tSerializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pRsp);
 int32_t tDeserializeSGetUserAuthRsp(void* buf, int32_t bufLen, SGetUserAuthRsp* pRsp);
 void    tFreeSGetUserAuthRsp(SGetUserAuthRsp* pRsp);
 
+typedef struct {
+  char user[TSDB_USER_LEN];
+} SGetUserWhiteListReq;
+
+int32_t tSerializeSGetUserWhiteListReq(void* buf, int32_t bufLen, SGetUserWhiteListReq* pReq);
+int32_t tDeserializeSGetUserWhiteListReq(void* buf, int32_t bufLen, SGetUserWhiteListReq* pReq);
+
+typedef struct {
+  char user[TSDB_USER_LEN];
+  int32_t numWhiteLists;
+  SIpV4Range* pWhiteLists;
+} SGetUserWhiteListRsp;
+
+int32_t tSerializeSGetUserWhiteListRsp(void* buf, int32_t bufLen, SGetUserWhiteListRsp* pRsp);
+int32_t tDeserializeSGetUserWhiteListRsp(void* buf, int32_t bufLen, SGetUserWhiteListRsp* pRsp);
+void    tFreeSGetUserWhiteListRsp(SGetUserWhiteListRsp* pRsp);
+
 /*
  * for client side struct, only column id, type, bytes are necessary
  * But for data in vnode side, we need all the following information.
@@ -988,14 +1047,12 @@ typedef struct {
   int64_t offset;
 } SInterval;
 
-
 typedef struct STbVerInfo {
   char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
   int32_t tversion;
 } STbVerInfo;
 
-
 typedef struct {
   int32_t code;
   int64_t affectedRows;
@@ -1053,6 +1110,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;
@@ -1092,6 +1150,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t walFsyncPeriod;
   int8_t  walLevel;
   int8_t  strict;
@@ -1204,6 +1263,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;
@@ -1226,13 +1286,13 @@ typedef struct {
   int16_t sstTrigger;
 } SDbCfgRsp;
 
-typedef SDbCfgRsp     SDbCfgInfo;
+typedef SDbCfgRsp SDbCfgInfo;
 
-int32_t tSerializeSDbCfgRspImpl(SEncoder *encoder, const SDbCfgRsp *pRsp);
+int32_t tSerializeSDbCfgRspImpl(SEncoder* encoder, const SDbCfgRsp* pRsp);
 int32_t tSerializeSDbCfgRsp(void* buf, int32_t bufLen, const SDbCfgRsp* pRsp);
 int32_t tDeserializeSDbCfgRsp(void* buf, int32_t bufLen, SDbCfgRsp* pRsp);
-int32_t tDeserializeSDbCfgRspImpl(SDecoder* decoder, SDbCfgRsp *pRsp);
-void tFreeSDbCfgRsp(SDbCfgRsp *pRsp);
+int32_t tDeserializeSDbCfgRspImpl(SDecoder* decoder, SDbCfgRsp* pRsp);
+void    tFreeSDbCfgRsp(SDbCfgRsp* pRsp);
 
 typedef struct {
   int32_t rowNum;
@@ -1289,8 +1349,8 @@ int32_t tDeserializeSDnodeListRsp(void* buf, int32_t bufLen, SDnodeListRsp* pRsp
 void    tFreeSDnodeListRsp(SDnodeListRsp* pRsp);
 
 typedef struct {
-  SUseDbRsp *useDbRsp;
-  SDbCfgRsp *cfgRsp;
+  SUseDbRsp* useDbRsp;
+  SDbCfgRsp* cfgRsp;
 } SDbHbRsp;
 
 typedef struct {
@@ -1394,6 +1454,7 @@ typedef struct {
   char    locale[TD_LOCALE_LEN];      // tsLocale
   char    charset[TD_LOCALE_LEN];     // tsCharset
   int8_t  ttlChangeOnWrite;
+  int8_t  enableWhiteList;
 } SClusterCfg;
 
 typedef struct {
@@ -1428,9 +1489,14 @@ typedef struct {
   int64_t numOfBatchInsertReqs;
   int64_t numOfBatchInsertSuccessReqs;
   int32_t numOfCachedTables;
-  int32_t learnerProgress; // use one reservered
+  int32_t learnerProgress;  // use one reservered
 } SVnodeLoad;
 
+typedef struct {
+  int32_t vgId;
+  int64_t nTimeSeries;
+} SVnodeLoadLite;
+
 typedef struct {
   int8_t  syncState;
   int64_t syncTerm;
@@ -1471,12 +1537,23 @@ typedef struct {
   SClusterCfg clusterCfg;
   SArray*     pVloads;  // array of SVnodeLoad
   int32_t     statusSeq;
+  int64_t     ipWhiteVer;
 } SStatusReq;
 
 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;
@@ -1501,6 +1578,7 @@ typedef struct {
   SDnodeCfg dnodeCfg;
   SArray*   pDnodeEps;  // Array of SDnodeEp
   int32_t   statusSeq;
+  int64_t   ipWhiteVer;
 } SStatusRsp;
 
 int32_t tSerializeSStatusRsp(void* buf, int32_t bufLen, SStatusRsp* pRsp);
@@ -1541,6 +1619,7 @@ typedef struct {
   int32_t  daysToKeep0;
   int32_t  daysToKeep1;
   int32_t  daysToKeep2;
+  int32_t  keepTimeOffset;
   int32_t  minRows;
   int32_t  maxRows;
   int32_t  walFsyncPeriod;
@@ -1620,6 +1699,7 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
+  int32_t keepTimeOffset;
   int32_t walFsyncPeriod;
   int8_t  walLevel;
   int8_t  strict;
@@ -2014,6 +2094,7 @@ void    tFreeSRedistributeVgroupReq(SRedistributeVgroupReq *pReq);
 
 typedef struct {
   int32_t useless;
+  int32_t vgId;
   int32_t sqlLen;
   char*   sql;
 } SBalanceVgroupLeaderReq;
@@ -2112,17 +2193,16 @@ typedef struct {
   int32_t tversion;
 } SResReadyRsp;
 
-
 typedef struct SOperatorParam {
-  int32_t             opType;
-  int32_t             downstreamIdx;
-  void*               value;
-  SArray*             pChildren; //SArray<SOperatorParam*>
+  int32_t opType;
+  int32_t downstreamIdx;
+  void*   value;
+  SArray* pChildren;  // SArray<SOperatorParam*>
 } SOperatorParam;
 
 typedef struct STableScanOperatorParam {
-  bool                tableSeq;
-  SArray*             pUidList;
+  bool    tableSeq;
+  SArray* pUidList;
 } STableScanOperatorParam;
 
 typedef struct {
@@ -2211,7 +2291,6 @@ typedef struct {
 int32_t tSerializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
 int32_t tDeserializeSTaskDropReq(void* buf, int32_t bufLen, STaskDropReq* pReq);
 
-
 typedef enum {
   TASK_NOTIFY_FINISHED = 1,
 } ETaskNotifyType;
@@ -2335,10 +2414,10 @@ typedef struct {
   char    clientId[256];
   SArray* topicNames;  // SArray<char**>
 
-  int8_t         withTbName;
-  int8_t         autoCommit;
-  int32_t        autoCommitInterval;
-  int8_t         resetOffsetCfg;
+  int8_t  withTbName;
+  int8_t  autoCommit;
+  int32_t autoCommitInterval;
+  int8_t  resetOffsetCfg;
 } SCMSubscribeReq;
 
 static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubscribeReq* pReq) {
@@ -2610,7 +2689,7 @@ static FORCE_INLINE void tdDestroySVCreateTbReq(SVCreateTbReq* req) {
   if (NULL == req) {
     return;
   }
-  
+
   taosMemoryFreeClear(req->sql);
   taosMemoryFreeClear(req->name);
   taosMemoryFreeClear(req->comment);
@@ -2721,7 +2800,7 @@ typedef struct {
   int32_t newTTL;
   int32_t newCommentLen;
   char*   newComment;
-  int64_t ctimeMs; // fill by vnode
+  int64_t ctimeMs;  // fill by vnode
 } SVAlterTbReq;
 
 int32_t tEncodeSVAlterTbReq(SEncoder* pEncoder, const SVAlterTbReq* pReq);
@@ -3135,7 +3214,7 @@ typedef struct {
   int64_t suid;
 } SMqRebVgReq;
 
-static FORCE_INLINE int tEncodeSMqRebVgReq(SEncoder *pCoder, const SMqRebVgReq* pReq) {
+static FORCE_INLINE int tEncodeSMqRebVgReq(SEncoder* pCoder, const SMqRebVgReq* pReq) {
   if (tStartEncode(pCoder) < 0) return -1;
   if (tEncodeI64(pCoder, pReq->leftForVer) < 0) return -1;
   if (tEncodeI32(pCoder, pReq->vgId) < 0) return -1;
@@ -3155,7 +3234,7 @@ static FORCE_INLINE int tEncodeSMqRebVgReq(SEncoder *pCoder, const SMqRebVgReq*
   return 0;
 }
 
-static FORCE_INLINE int tDecodeSMqRebVgReq(SDecoder *pCoder, SMqRebVgReq* pReq) {
+static FORCE_INLINE int tDecodeSMqRebVgReq(SDecoder* pCoder, SMqRebVgReq* pReq) {
   if (tStartDecode(pCoder) < 0) return -1;
 
   if (tDecodeI64(pCoder, &pReq->leftForVer) < 0) return -1;
@@ -3171,7 +3250,7 @@ static FORCE_INLINE int tDecodeSMqRebVgReq(SDecoder *pCoder, SMqRebVgReq* pReq)
     if (tDecodeCStr(pCoder, &pReq->qmsg) < 0) return -1;
   } else if (pReq->subType == TOPIC_SUB_TYPE__TABLE) {
     if (tDecodeI64(pCoder, &pReq->suid) < 0) return -1;
-    if (!tDecodeIsEnd(pCoder)){
+    if (!tDecodeIsEnd(pCoder)) {
       if (tDecodeCStr(pCoder, &pReq->qmsg) < 0) return -1;
     }
   }
@@ -3190,32 +3269,6 @@ int32_t tEncodeSTqCheckInfo(SEncoder* pEncoder, const STqCheckInfo* pInfo);
 int32_t tDecodeSTqCheckInfo(SDecoder* pDecoder, STqCheckInfo* pInfo);
 void    tDeleteSTqCheckInfo(STqCheckInfo* pInfo);
 
-typedef struct {
-  char topic[TSDB_TOPIC_FNAME_LEN];
-} STqDelCheckInfoReq;
-
-typedef struct {
-  int32_t vgId;
-  int64_t offset;
-  char    topicName[TSDB_TOPIC_FNAME_LEN];
-  char    cgroup[TSDB_CGROUP_LEN];
-} SMqOffset;
-
-typedef struct {
-  int64_t    consumerId;
-  int32_t    num;
-  SMqOffset* offsets;
-} SMqCMCommitOffsetReq;
-
-typedef struct {
-  int32_t reserved;
-} SMqCMCommitOffsetRsp;
-
-int32_t tEncodeSMqOffset(SEncoder* encoder, const SMqOffset* pOffset);
-int32_t tDecodeSMqOffset(SDecoder* decoder, SMqOffset* pOffset);
-int32_t tEncodeSMqCMCommitOffsetReq(SEncoder* encoder, const SMqCMCommitOffsetReq* pReq);
-int32_t tDecodeSMqCMCommitOffsetReq(SDecoder* decoder, SMqCMCommitOffsetReq* pReq);
-
 // tqOffset
 enum {
   TMQ_OFFSET__RESET_NONE = -3,
@@ -3695,12 +3748,12 @@ typedef struct {
   int32_t      vgId;
   STqOffsetVal offset;
   int64_t      rows;
-}OffsetRows;
+} OffsetRows;
 
-typedef struct{
-  char       topicName[TSDB_TOPIC_FNAME_LEN];
-  SArray*    offsetRows;
-}TopicOffsetRows;
+typedef struct {
+  char    topicName[TSDB_TOPIC_FNAME_LEN];
+  SArray* offsetRows;
+} TopicOffsetRows;
 
 typedef struct {
   int64_t consumerId;
@@ -3713,9 +3766,9 @@ typedef struct {
 } SMqHbRsp;
 
 typedef struct {
-  SMsgHead     head;
-  int64_t consumerId;
-  char subKey[TSDB_SUBSCRIBE_KEY_LEN];
+  SMsgHead head;
+  int64_t  consumerId;
+  char     subKey[TSDB_SUBSCRIBE_KEY_LEN];
 } SMqSeekReq;
 
 #define TD_AUTO_CREATE_TABLE 0x1
@@ -3769,7 +3822,7 @@ typedef struct SDeleteRes {
   int64_t  affectedRows;
   char     tableFName[TSDB_TABLE_NAME_LEN];
   char     tsColName[TSDB_COL_NAME_LEN];
-  int64_t  ctimeMs; // fill by vnode
+  int64_t  ctimeMs;  // fill by vnode
 } SDeleteRes;
 
 int32_t tEncodeDeleteRes(SEncoder* pCoder, const SDeleteRes* pRes);
@@ -3847,8 +3900,8 @@ int32_t tSerializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
 int32_t tDeserializeSMqHbReq(void* buf, int32_t bufLen, SMqHbReq* pReq);
 int32_t tDeatroySMqHbReq(SMqHbReq* pReq);
 
-int32_t tSerializeSMqSeekReq(void *buf, int32_t bufLen, SMqSeekReq *pReq);
-int32_t tDeserializeSMqSeekReq(void *buf, int32_t bufLen, SMqSeekReq *pReq);
+int32_t tSerializeSMqSeekReq(void* buf, int32_t bufLen, SMqSeekReq* pReq);
+int32_t tDeserializeSMqSeekReq(void* buf, int32_t bufLen, SMqSeekReq* pReq);
 
 #define SUBMIT_REQ_AUTO_CREATE_TABLE  0x1
 #define SUBMIT_REQ_COLUMN_DATA_FORMAT 0x2
@@ -3863,7 +3916,7 @@ typedef struct {
     SArray* aRowP;
     SArray* aCol;
   };
-  int64_t        ctimeMs;
+  int64_t ctimeMs;
 } SSubmitTbData;
 
 typedef struct {

include/common/tmsgcb.h

@@ -52,6 +52,7 @@ typedef struct {
   void*                   data;
   void*                   mgmt;
   void*                   clientRpc;
+  void*                   serverRpc;
   PutToQueueFp            putToQueueFp;
   GetQueueSizeFp          qsizeFp;
   SendReqFp               sendReqFp;

include/common/tmsgdef.h

@@ -177,8 +177,9 @@ enum { // WARN: new msg should be appended to segment tail
   TD_DEF_MSG_TYPE(TDMT_MND_UPTIME_TIMER, "uptime-timer", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, "lost-consumer-clear", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_STREAM_HEARTBEAT, "stream-heartbeat", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", 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_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)
@@ -187,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

@@ -16,6 +16,7 @@
 #ifndef _TD_COMMON_TOKEN_H_
 #define _TD_COMMON_TOKEN_H_
 
+
 #define TK_OR                               1
 #define TK_AND                              2
 #define TK_UNION                            3
@@ -48,312 +49,318 @@
 #define TK_USERS                           30
 #define TK_CONNS                           31
 #define TK_STATE                           32
-#define TK_USER                            33
-#define TK_ENABLE                          34
-#define TK_NK_INTEGER                      35
-#define TK_SYSINFO                         36
-#define TK_DROP                            37
-#define TK_GRANT                           38
-#define TK_ON                              39
-#define TK_TO                              40
-#define TK_REVOKE                          41
-#define TK_FROM                            42
-#define TK_SUBSCRIBE                       43
-#define TK_NK_COMMA                        44
-#define TK_READ                            45
-#define TK_WRITE                           46
-#define TK_NK_DOT                          47
-#define TK_WITH                            48
-#define TK_DNODE                           49
-#define TK_PORT                            50
-#define TK_DNODES                          51
-#define TK_RESTORE                         52
-#define TK_NK_IPTOKEN                      53
-#define TK_FORCE                           54
-#define TK_UNSAFE                          55
-#define TK_LOCAL                           56
-#define TK_QNODE                           57
-#define TK_BNODE                           58
-#define TK_SNODE                           59
-#define TK_MNODE                           60
-#define TK_VNODE                           61
-#define TK_DATABASE                        62
-#define TK_USE                             63
-#define TK_FLUSH                           64
-#define TK_TRIM                            65
-#define TK_COMPACT                         66
-#define TK_IF                              67
-#define TK_NOT                             68
-#define TK_EXISTS                          69
-#define TK_BUFFER                          70
-#define TK_CACHEMODEL                      71
-#define TK_CACHESIZE                       72
-#define TK_COMP                            73
-#define TK_DURATION                        74
-#define TK_NK_VARIABLE                     75
-#define TK_MAXROWS                         76
-#define TK_MINROWS                         77
-#define TK_KEEP                            78
-#define TK_PAGES                           79
-#define TK_PAGESIZE                        80
-#define TK_TSDB_PAGESIZE                   81
-#define TK_PRECISION                       82
-#define TK_REPLICA                         83
-#define TK_VGROUPS                         84
-#define TK_SINGLE_STABLE                   85
-#define TK_RETENTIONS                      86
-#define TK_SCHEMALESS                      87
-#define TK_WAL_LEVEL                       88
-#define TK_WAL_FSYNC_PERIOD                89
-#define TK_WAL_RETENTION_PERIOD            90
-#define TK_WAL_RETENTION_SIZE              91
-#define TK_WAL_ROLL_PERIOD                 92
-#define TK_WAL_SEGMENT_SIZE                93
-#define TK_STT_TRIGGER                     94
-#define TK_TABLE_PREFIX                    95
-#define TK_TABLE_SUFFIX                    96
-#define TK_NK_COLON                        97
-#define TK_BWLIMIT                         98
-#define TK_START                           99
-#define TK_TIMESTAMP                      100
-#define TK_END                            101
-#define TK_TABLE                          102
-#define TK_NK_LP                          103
-#define TK_NK_RP                          104
-#define TK_STABLE                         105
-#define TK_ADD                            106
-#define TK_COLUMN                         107
-#define TK_MODIFY                         108
-#define TK_RENAME                         109
-#define TK_TAG                            110
-#define TK_SET                            111
-#define TK_NK_EQ                          112
-#define TK_USING                          113
-#define TK_TAGS                           114
-#define TK_BOOL                           115
-#define TK_TINYINT                        116
-#define TK_SMALLINT                       117
-#define TK_INT                            118
-#define TK_INTEGER                        119
-#define TK_BIGINT                         120
-#define TK_FLOAT                          121
-#define TK_DOUBLE                         122
-#define TK_BINARY                         123
-#define TK_NCHAR                          124
-#define TK_UNSIGNED                       125
-#define TK_JSON                           126
-#define TK_VARCHAR                        127
-#define TK_MEDIUMBLOB                     128
-#define TK_BLOB                           129
-#define TK_VARBINARY                      130
-#define TK_GEOMETRY                       131
-#define TK_DECIMAL                        132
-#define TK_COMMENT                        133
-#define TK_MAX_DELAY                      134
-#define TK_WATERMARK                      135
-#define TK_ROLLUP                         136
-#define TK_TTL                            137
-#define TK_SMA                            138
-#define TK_DELETE_MARK                    139
-#define TK_FIRST                          140
-#define TK_LAST                           141
-#define TK_SHOW                           142
-#define TK_PRIVILEGES                     143
-#define TK_DATABASES                      144
-#define TK_TABLES                         145
-#define TK_STABLES                        146
-#define TK_MNODES                         147
-#define TK_QNODES                         148
-#define TK_FUNCTIONS                      149
-#define TK_INDEXES                        150
-#define TK_ACCOUNTS                       151
-#define TK_APPS                           152
-#define TK_CONNECTIONS                    153
-#define TK_LICENCES                       154
-#define TK_GRANTS                         155
-#define TK_QUERIES                        156
-#define TK_SCORES                         157
-#define TK_TOPICS                         158
-#define TK_VARIABLES                      159
-#define TK_CLUSTER                        160
-#define TK_BNODES                         161
-#define TK_SNODES                         162
-#define TK_TRANSACTIONS                   163
-#define TK_DISTRIBUTED                    164
-#define TK_CONSUMERS                      165
-#define TK_SUBSCRIPTIONS                  166
-#define TK_VNODES                         167
-#define TK_ALIVE                          168
-#define TK_LIKE                           169
-#define TK_TBNAME                         170
-#define TK_QTAGS                          171
-#define TK_AS                             172
-#define TK_INDEX                          173
-#define TK_FUNCTION                       174
-#define TK_INTERVAL                       175
-#define TK_COUNT                          176
-#define TK_LAST_ROW                       177
-#define TK_META                           178
-#define TK_ONLY                           179
-#define TK_TOPIC                          180
-#define TK_CONSUMER                       181
-#define TK_GROUP                          182
-#define TK_DESC                           183
-#define TK_DESCRIBE                       184
-#define TK_RESET                          185
-#define TK_QUERY                          186
-#define TK_CACHE                          187
-#define TK_EXPLAIN                        188
-#define TK_ANALYZE                        189
-#define TK_VERBOSE                        190
-#define TK_NK_BOOL                        191
-#define TK_RATIO                          192
-#define TK_NK_FLOAT                       193
-#define TK_OUTPUTTYPE                     194
-#define TK_AGGREGATE                      195
-#define TK_BUFSIZE                        196
-#define TK_LANGUAGE                       197
-#define TK_REPLACE                        198
-#define TK_STREAM                         199
-#define TK_INTO                           200
-#define TK_PAUSE                          201
-#define TK_RESUME                         202
-#define TK_TRIGGER                        203
-#define TK_AT_ONCE                        204
-#define TK_WINDOW_CLOSE                   205
-#define TK_IGNORE                         206
-#define TK_EXPIRED                        207
-#define TK_FILL_HISTORY                   208
-#define TK_UPDATE                         209
-#define TK_SUBTABLE                       210
-#define TK_UNTREATED                      211
-#define TK_KILL                           212
-#define TK_CONNECTION                     213
-#define TK_TRANSACTION                    214
-#define TK_BALANCE                        215
-#define TK_VGROUP                         216
-#define TK_LEADER                         217
-#define TK_MERGE                          218
-#define TK_REDISTRIBUTE                   219
-#define TK_SPLIT                          220
-#define TK_DELETE                         221
-#define TK_INSERT                         222
-#define TK_NULL                           223
-#define TK_NK_QUESTION                    224
-#define TK_NK_ARROW                       225
-#define TK_ROWTS                          226
-#define TK_QSTART                         227
-#define TK_QEND                           228
-#define TK_QDURATION                      229
-#define TK_WSTART                         230
-#define TK_WEND                           231
-#define TK_WDURATION                      232
-#define TK_IROWTS                         233
-#define TK_ISFILLED                       234
-#define TK_CAST                           235
-#define TK_NOW                            236
-#define TK_TODAY                          237
-#define TK_TIMEZONE                       238
-#define TK_CLIENT_VERSION                 239
-#define TK_SERVER_VERSION                 240
-#define TK_SERVER_STATUS                  241
-#define TK_CURRENT_USER                   242
-#define TK_CASE                           243
-#define TK_WHEN                           244
-#define TK_THEN                           245
-#define TK_ELSE                           246
-#define TK_BETWEEN                        247
-#define TK_IS                             248
-#define TK_NK_LT                          249
-#define TK_NK_GT                          250
-#define TK_NK_LE                          251
-#define TK_NK_GE                          252
-#define TK_NK_NE                          253
-#define TK_MATCH                          254
-#define TK_NMATCH                         255
-#define TK_CONTAINS                       256
-#define TK_IN                             257
-#define TK_JOIN                           258
-#define TK_INNER                          259
-#define TK_SELECT                         260
-#define TK_NK_HINT                        261
-#define TK_DISTINCT                       262
-#define TK_WHERE                          263
-#define TK_PARTITION                      264
-#define TK_BY                             265
-#define TK_SESSION                        266
-#define TK_STATE_WINDOW                   267
-#define TK_EVENT_WINDOW                   268
-#define TK_SLIDING                        269
-#define TK_FILL                           270
-#define TK_VALUE                          271
-#define TK_VALUE_F                        272
-#define TK_NONE                           273
-#define TK_PREV                           274
-#define TK_NULL_F                         275
-#define TK_LINEAR                         276
-#define TK_NEXT                           277
-#define TK_HAVING                         278
-#define TK_RANGE                          279
-#define TK_EVERY                          280
-#define TK_ORDER                          281
-#define TK_SLIMIT                         282
-#define TK_SOFFSET                        283
-#define TK_LIMIT                          284
-#define TK_OFFSET                         285
-#define TK_ASC                            286
-#define TK_NULLS                          287
-#define TK_ABORT                          288
-#define TK_AFTER                          289
-#define TK_ATTACH                         290
-#define TK_BEFORE                         291
-#define TK_BEGIN                          292
-#define TK_BITAND                         293
-#define TK_BITNOT                         294
-#define TK_BITOR                          295
-#define TK_BLOCKS                         296
-#define TK_CHANGE                         297
-#define TK_COMMA                          298
-#define TK_CONCAT                         299
-#define TK_CONFLICT                       300
-#define TK_COPY                           301
-#define TK_DEFERRED                       302
-#define TK_DELIMITERS                     303
-#define TK_DETACH                         304
-#define TK_DIVIDE                         305
-#define TK_DOT                            306
-#define TK_EACH                           307
-#define TK_FAIL                           308
-#define TK_FILE                           309
-#define TK_FOR                            310
-#define TK_GLOB                           311
-#define TK_ID                             312
-#define TK_IMMEDIATE                      313
-#define TK_IMPORT                         314
-#define TK_INITIALLY                      315
-#define TK_INSTEAD                        316
-#define TK_ISNULL                         317
-#define TK_KEY                            318
-#define TK_MODULES                        319
-#define TK_NK_BITNOT                      320
-#define TK_NK_SEMI                        321
-#define TK_NOTNULL                        322
-#define TK_OF                             323
-#define TK_PLUS                           324
-#define TK_PRIVILEGE                      325
-#define TK_RAISE                          326
-#define TK_RESTRICT                       327
-#define TK_ROW                            328
-#define TK_SEMI                           329
-#define TK_STAR                           330
-#define TK_STATEMENT                      331
-#define TK_STRICT                         332
-#define TK_STRING                         333
-#define TK_TIMES                          334
-#define TK_VALUES                         335
-#define TK_VARIABLE                       336
-#define TK_VIEW                           337
-#define TK_WAL                            338
+#define TK_NK_COMMA                        33
+#define TK_HOST                            34
+#define TK_USER                            35
+#define TK_ENABLE                          36
+#define TK_NK_INTEGER                      37
+#define TK_SYSINFO                         38
+#define TK_ADD                             39
+#define TK_DROP                            40
+#define TK_GRANT                           41
+#define TK_ON                              42
+#define TK_TO                              43
+#define TK_REVOKE                          44
+#define TK_FROM                            45
+#define TK_SUBSCRIBE                       46
+#define TK_READ                            47
+#define TK_WRITE                           48
+#define TK_NK_DOT                          49
+#define TK_WITH                            50
+#define TK_DNODE                           51
+#define TK_PORT                            52
+#define TK_DNODES                          53
+#define TK_RESTORE                         54
+#define TK_NK_IPTOKEN                      55
+#define TK_FORCE                           56
+#define TK_UNSAFE                          57
+#define TK_LOCAL                           58
+#define TK_QNODE                           59
+#define TK_BNODE                           60
+#define TK_SNODE                           61
+#define TK_MNODE                           62
+#define TK_VNODE                           63
+#define TK_DATABASE                        64
+#define TK_USE                             65
+#define TK_FLUSH                           66
+#define TK_TRIM                            67
+#define TK_COMPACT                         68
+#define TK_IF                              69
+#define TK_NOT                             70
+#define TK_EXISTS                          71
+#define TK_BUFFER                          72
+#define TK_CACHEMODEL                      73
+#define TK_CACHESIZE                       74
+#define TK_COMP                            75
+#define TK_DURATION                        76
+#define TK_NK_VARIABLE                     77
+#define TK_MAXROWS                         78
+#define TK_MINROWS                         79
+#define TK_KEEP                            80
+#define TK_PAGES                           81
+#define TK_PAGESIZE                        82
+#define TK_TSDB_PAGESIZE                   83
+#define TK_PRECISION                       84
+#define TK_REPLICA                         85
+#define TK_VGROUPS                         86
+#define TK_SINGLE_STABLE                   87
+#define TK_RETENTIONS                      88
+#define TK_SCHEMALESS                      89
+#define TK_WAL_LEVEL                       90
+#define TK_WAL_FSYNC_PERIOD                91
+#define TK_WAL_RETENTION_PERIOD            92
+#define TK_WAL_RETENTION_SIZE              93
+#define TK_WAL_ROLL_PERIOD                 94
+#define TK_WAL_SEGMENT_SIZE                95
+#define TK_STT_TRIGGER                     96
+#define TK_TABLE_PREFIX                    97
+#define TK_TABLE_SUFFIX                    98
+#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
+
 
 
 
@@ -365,6 +372,7 @@
 #define TK_NK_BIN           605  // bin format data 0b111
 #define TK_BATCH_SCAN       606
 #define TK_NO_BATCH_SCAN    607
+#define TK_SORT_FOR_GROUP   608
 
 
 #define TK_NK_NIL 65535

include/libs/command/command.h

@@ -22,7 +22,7 @@
 
 typedef struct SExplainCtx SExplainCtx;
 
-int32_t qExecCommand(int64_t* pConnId, bool sysInfoUser, SNode *pStmt, SRetrieveTableRsp **pRsp);
+int32_t qExecCommand(int64_t* pConnId, bool sysInfoUser, SNode *pStmt, SRetrieveTableRsp **pRsp, int8_t biMode);
 
 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp);
 int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs);

include/libs/executor/storageapi.h

@@ -38,6 +38,9 @@ extern "C" {
 
 #define META_READER_NOLOCK 0x1
 
+#define  STREAM_STATE_BUFF_HASH 1
+#define  STREAM_STATE_BUFF_SORT 2
+
 typedef struct SMeta SMeta;
 typedef TSKEY (*GetTsFun)(void*);
 
@@ -115,6 +118,7 @@ typedef struct SRowBuffPos {
   void* pKey;
   bool  beFlushed;
   bool  beUsed;
+  bool  needFree;
 } SRowBuffPos;
 
 // tq
@@ -142,6 +146,7 @@ typedef struct SSnapContext {
 typedef struct {
   int64_t uid;
   int64_t ctbNum;
+  int32_t colNum;
 } SMetaStbStats;
 
 // void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
@@ -285,8 +290,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);
@@ -332,6 +337,8 @@ typedef struct {
   void*   db;        //  rocksdb_t*             db;
   void*   pCur;
   int64_t number;
+  void*   pStreamFileState;
+  int32_t buffIndex;
 } SStreamStateCur;
 
 typedef struct SStateStore {
@@ -339,7 +346,8 @@ typedef struct SStateStore {
   int32_t (*streamStateGetParName)(SStreamState* pState, int64_t groupId, void** pVal);
 
   int32_t (*streamStateAddIfNotExist)(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
-  int32_t (*streamStateReleaseBuf)(SStreamState* pState, const SWinKey* key, void* pVal);
+  int32_t (*streamStateReleaseBuf)(SStreamState* pState, void* pVal, bool used);
+  int32_t (*streamStateClearBuff)(SStreamState* pState, void* pVal);
   void (*streamStateFreeVal)(void* val);
 
   int32_t (*streamStatePut)(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
@@ -370,7 +378,7 @@ typedef struct SStateStore {
 
   int32_t (*streamStateSessionAddIfNotExist)(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal,
                                              int32_t* pVLen);
-  int32_t (*streamStateSessionPut)(SStreamState* pState, const SSessionKey* key, const void* value, int32_t vLen);
+  int32_t (*streamStateSessionPut)(SStreamState* pState, const SSessionKey* key, void* value, int32_t vLen);
   int32_t (*streamStateSessionGet)(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen);
   int32_t (*streamStateSessionDel)(SStreamState* pState, const SSessionKey* key);
   int32_t (*streamStateSessionClear)(SStreamState* pState);
@@ -399,7 +407,7 @@ typedef struct SStateStore {
 
   struct SStreamFileState* (*streamFileStateInit)(int64_t memSize, uint32_t keySize, uint32_t rowSize,
                                                   uint32_t selectRowSize, GetTsFun fp, void* pFile, TSKEY delMark,
-                                                  const char* id, int64_t ckId);
+                                                  const char* id, int64_t ckId, int8_t type);
 
   void (*streamFileStateDestroy)(struct SStreamFileState* pFileState);
   void (*streamFileStateClear)(struct SStreamFileState* pFileState);

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;
@@ -222,6 +223,10 @@ typedef struct SCreateUserStmt {
   char      userName[TSDB_USER_LEN];
   char      password[TSDB_USET_PASSWORD_LEN];
   int8_t    sysinfo;
+  int32_t numIpRanges;
+  SIpV4Range* pIpRanges;
+
+  SNodeList* pNodeListIpRanges;
 } SCreateUserStmt;
 
 typedef struct SAlterUserStmt {
@@ -231,6 +236,10 @@ typedef struct SAlterUserStmt {
   char      password[TSDB_USET_PASSWORD_LEN];
   int8_t    enable;
   int8_t    sysinfo;
+  int32_t numIpRanges;
+  SIpV4Range* pIpRanges;
+
+  SNodeList* pNodeListIpRanges;
 } SAlterUserStmt;
 
 typedef struct SDropUserStmt {
@@ -265,6 +274,7 @@ typedef struct SShowStmt {
   SNode*        pDbName;  // SValueNode
   SNode*        pTbName;  // SValueNode
   EOperatorType tableCondType;
+  EShowKind     showKind; // show databases: user/system, show tables: normal/child, others NULL
 } SShowStmt;
 
 typedef struct SShowCreateDatabaseStmt {
@@ -497,6 +507,7 @@ typedef struct SBalanceVgroupStmt {
 
 typedef struct SBalanceVgroupLeaderStmt {
   ENodeType type;
+  int32_t   vgId;
 } SBalanceVgroupLeaderStmt;
 
 typedef struct SMergeVgroupStmt {

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

@@ -136,6 +136,8 @@ typedef struct SAggLogicNode {
   bool       hasTimeLineFunc;
   bool       onlyHasKeepOrderFunc;
   bool       hasGroupKeyOptimized;
+  bool       isGroupTb;
+  bool       isPartTb;  // true if partition keys has tbname
 } SAggLogicNode;
 
 typedef struct SProjectLogicNode {
@@ -221,6 +223,7 @@ typedef struct SMergeLogicNode {
   int32_t    srcGroupId;
   bool       groupSort;
   bool       ignoreGroupId;
+  bool       inputWithGroupId;
 } SMergeLogicNode;
 
 typedef enum EWindowType {
@@ -263,6 +266,7 @@ typedef struct SWindowLogicNode {
   int8_t           igExpired;
   int8_t           igCheckUpdate;
   EWindowAlgorithm windowAlgo;
+  bool             isPartTb;
 } SWindowLogicNode;
 
 typedef struct SFillLogicNode {
@@ -279,8 +283,9 @@ typedef struct SSortLogicNode {
   SLogicNode node;
   SNodeList* pSortKeys;
   bool       groupSort;
-  int64_t    maxRows;
   bool       skipPKSortOpt;
+  bool       calcGroupId;
+  bool       excludePkCol; // exclude PK ts col when calc group id
 } SSortLogicNode;
 
 typedef struct SPartitionLogicNode {
@@ -288,6 +293,11 @@ 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;
+  uint64_t pkTsColTbId;
 } SPartitionLogicNode;
 
 typedef enum ESubplanType {
@@ -527,6 +537,7 @@ typedef struct SMergePhysiNode {
   int32_t    srcGroupId;
   bool       groupSort;
   bool       ignoreGroupId;
+  bool       inputWithGroupId;
 } SMergePhysiNode;
 
 typedef struct SWindowPhysiNode {
@@ -603,6 +614,8 @@ typedef struct SSortPhysiNode {
   SNodeList* pExprs;     // these are expression list of order_by_clause and parameter expression of aggregate function
   SNodeList* pSortKeys;  // element is SOrderByExprNode, and SOrderByExprNode::pExpr is SColumnNode
   SNodeList* pTargets;
+  bool       calcGroupId;
+  bool       excludePkCol;
 } SSortPhysiNode;
 
 typedef SSortPhysiNode SGroupSortPhysiNode;
@@ -612,6 +625,9 @@ typedef struct SPartitionPhysiNode {
   SNodeList* pExprs;  // these are expression list of partition_by_clause
   SNodeList* pPartitionKeys;
   SNodeList* pTargets;
+
+  bool    needBlockOutputTsOrder;
+  int32_t tsSlotId;
 } SPartitionPhysiNode;
 
 typedef struct SStreamPartitionPhysiNode {

include/libs/nodes/querynodes.h

@@ -119,6 +119,7 @@ typedef struct SLeftValueNode {
 typedef enum EHintOption {
   HINT_NO_BATCH_SCAN = 1,
   HINT_BATCH_SCAN,
+  HINT_SORT_FOR_GROUP,
 } EHintOption;
 
 typedef struct SHintNode {
@@ -276,6 +277,14 @@ typedef enum ETimeLineMode {
   TIME_LINE_GLOBAL,
 } ETimeLineMode;
 
+typedef enum EShowKind {
+  SHOW_KIND_ALL = 1,
+  SHOW_KIND_TABLES_NORMAL,
+  SHOW_KIND_TABLES_CHILD,
+  SHOW_KIND_DATABASES_USER,
+  SHOW_KIND_DATABASES_SYSTEM
+} EShowKind;
+
 typedef struct SFillNode {
   ENodeType   type;  // QUERY_NODE_FILL
   EFillMode   mode;
@@ -518,6 +527,8 @@ void*   nodesGetValueFromNode(SValueNode* pNode);
 int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value);
 char*   nodesGetStrValueFromNode(SValueNode* pNode);
 void    nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
+SValueNode* nodesMakeValueNodeFromString(char* literal);
+SValueNode* nodesMakeValueNodeFromBool(bool b);
 
 char*   nodesGetFillModeString(EFillMode mode);
 int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);
@@ -525,6 +536,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,6 +64,7 @@ typedef struct SParseContext {
   SArray*          pTableMetaPos;    // sql table pos => catalog data pos
   SArray*          pTableVgroupPos;  // sql table pos => catalog data pos
   int64_t          allocatorId;
+  int8_t           biMode;
 } SParseContext;
 
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery);

include/libs/stream/streamState.h

@@ -29,54 +29,6 @@ extern "C" {
 
 #include "storageapi.h"
 
-// void*      streamBackendInit(const char* path);
-// void       streamBackendCleanup(void* arg);
-// SListNode* streamBackendAddCompare(void* backend, void* arg);
-// void       streamBackendDelCompare(void* backend, void* arg);
-
-// <<<<<<< HEAD
-// typedef struct STdbState {
-//   rocksdb_t*                       rocksdb;
-//   rocksdb_column_family_handle_t** pHandle;
-//   rocksdb_writeoptions_t*          writeOpts;
-//   rocksdb_readoptions_t*           readOpts;
-//   rocksdb_options_t**              cfOpts;
-//   rocksdb_options_t*               dbOpt;
-//   struct SStreamTask*              pOwner;
-//   void*                            param;
-//   void*                            env;
-//   SListNode*                       pComparNode;
-//   void*                            pBackend;
-//   char                             idstr[64];
-//   void*                            compactFactory;
-//   TdThreadRwlock                   rwLock;
-// =======
-// typedef struct STdbState {
-//  rocksdb_t*                       rocksdb;
-//  rocksdb_column_family_handle_t** pHandle;
-//  rocksdb_writeoptions_t*          writeOpts;
-//  rocksdb_readoptions_t*           readOpts;
-//  rocksdb_options_t**              cfOpts;
-//  rocksdb_options_t*               dbOpt;
-//  struct SStreamTask*              pOwner;
-//  void*                            param;
-//  void*                            env;
-//  SListNode*                       pComparNode;
-//  void*                            pBackendHandle;
-//  char                             idstr[64];
-//  void*                            compactFactory;
-//
-//  TDB* db;
-//  TTB* pStateDb;
-//  TTB* pFuncStateDb;
-//  TTB* pFillStateDb;  // todo refactor
-//  TTB* pSessionStateDb;
-//  TTB* pParNameDb;
-//  TTB* pParTagDb;
-//  TXN* txn;
-//} STdbState;
-//>>>>>>> enh/dev3.0
-
 SStreamState* streamStateOpen(char* path, void* pTask, bool specPath, int32_t szPage, int32_t pages);
 void          streamStateClose(SStreamState* pState, bool remove);
 int32_t       streamStateBegin(SStreamState* pState);
@@ -97,26 +49,30 @@ void    streamStateSetNumber(SStreamState* pState, int32_t number);
 int32_t streamStateSaveInfo(SStreamState* pState, void* pKey, int32_t keyLen, void* pVal, int32_t vLen);
 int32_t streamStateGetInfo(SStreamState* pState, void* pKey, int32_t keyLen, void** pVal, int32_t* pLen);
 
+//session window
 int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal, int32_t* pVLen);
-int32_t streamStateSessionPut(SStreamState* pState, const SSessionKey* key, const void* value, int32_t vLen);
+int32_t streamStateSessionPut(SStreamState* pState, const SSessionKey* key, void* value, int32_t vLen);
 int32_t streamStateSessionGet(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen);
 int32_t streamStateSessionDel(SStreamState* pState, const SSessionKey* key);
 int32_t streamStateSessionClear(SStreamState* pState);
 int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, void** pVal, int32_t* pVLen);
-int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
-                                      state_key_cmpr_fn fn, void** pVal, int32_t* pVLen);
 int32_t streamStateSessionGetKeyByRange(SStreamState* pState, const SSessionKey* range, SSessionKey* curKey);
 
 SStreamStateCur* streamStateSessionSeekKeyNext(SStreamState* pState, const SSessionKey* key);
 SStreamStateCur* streamStateSessionSeekKeyCurrentPrev(SStreamState* pState, const SSessionKey* key);
 SStreamStateCur* streamStateSessionSeekKeyCurrentNext(SStreamState* pState, const SSessionKey* key);
 
+//state window
+int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
+                                      state_key_cmpr_fn fn, void** pVal, int32_t* pVLen);
+
 int32_t streamStateFillPut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
 int32_t streamStateFillGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
 int32_t streamStateFillDel(SStreamState* pState, const SWinKey* key);
 
 int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
-int32_t streamStateReleaseBuf(SStreamState* pState, const SWinKey* key, void* pVal);
+int32_t streamStateReleaseBuf(SStreamState* pState, void* pVal, bool used);
+int32_t streamStateClearBuff(SStreamState* pState, void* pVal);
 void    streamStateFreeVal(void* val);
 
 SStreamStateCur* streamStateGetAndCheckCur(SStreamState* pState, SWinKey* key);
@@ -124,14 +80,11 @@ SStreamStateCur* streamStateSeekKeyNext(SStreamState* pState, const SWinKey* key
 SStreamStateCur* streamStateFillSeekKeyNext(SStreamState* pState, const SWinKey* key);
 SStreamStateCur* streamStateFillSeekKeyPrev(SStreamState* pState, const SWinKey* key);
 void             streamStateFreeCur(SStreamStateCur* pCur);
+void             streamStateResetCur(SStreamStateCur* pCur);
 
 int32_t streamStateGetGroupKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
 int32_t streamStateGetKVByCur(SStreamStateCur* pCur, SWinKey* pKey, const void** pVal, int32_t* pVLen);
 
-int32_t streamStateGetFirst(SStreamState* pState, SWinKey* key);
-int32_t streamStateSeekFirst(SStreamState* pState, SStreamStateCur* pCur);
-int32_t streamStateSeekLast(SStreamState* pState, SStreamStateCur* pCur);
-
 int32_t streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur);
 
@@ -139,6 +92,7 @@ int32_t streamStatePutParName(SStreamState* pState, int64_t groupId, const char*
 int32_t streamStateGetParName(SStreamState* pState, int64_t groupId, void** pVal);
 
 void streamStateReloadInfo(SStreamState* pState, TSKEY ts);
+SStreamStateCur* createStreamStateCursor();
 
 /***compare func **/
 

include/libs/stream/tstreamFileState.h

@@ -28,20 +28,33 @@ extern "C" {
 #endif
 
 typedef struct SStreamFileState SStreamFileState;
-typedef SList SStreamSnapshot;
+typedef SList                   SStreamSnapshot;
+
+typedef void*   (*_state_buff_get_fn)(void* pRowBuff, const void* pKey, size_t keyLen);
+typedef int32_t (*_state_buff_put_fn)(void* pRowBuff, const void* pKey, size_t keyLen, const void* data, size_t dataLen);
+typedef int32_t (*_state_buff_remove_fn)(void* pRowBuff, const void* pKey, size_t keyLen);
+typedef int32_t (*_state_buff_remove_by_pos_fn)(SStreamFileState* pState, SRowBuffPos* pPos);
+typedef void    (*_state_buff_cleanup_fn)(void* pRowBuff);
+typedef void*   (*_state_buff_create_statekey_fn)(SRowBuffPos* pPos, int64_t num);
+
+typedef int32_t (*_state_file_remove_fn)(SStreamFileState* pFileState, const void* pKey);
+typedef int32_t (*_state_file_get_fn)(SStreamFileState* pFileState, void* pKey, void* data, int32_t* pDataLen);
+typedef int32_t (*_state_file_clear_fn)(SStreamState* pState);
 
 SStreamFileState* streamFileStateInit(int64_t memSize, uint32_t keySize, uint32_t rowSize, uint32_t selectRowSize,
                                       GetTsFun fp, void* pFile, TSKEY delMark, const char* taskId,
-                                      int64_t checkpointId);
+                                      int64_t checkpointId, int8_t type);
 void              streamFileStateDestroy(SStreamFileState* pFileState);
 void              streamFileStateClear(SStreamFileState* pFileState);
 bool              needClearDiskBuff(SStreamFileState* pFileState);
+void              streamFileStateReleaseBuff(SStreamFileState* pFileState, SRowBuffPos* pPos, bool used);
+int32_t           streamFileStateClearBuff(SStreamFileState* pFileState, SRowBuffPos* pPos);
 
 int32_t getRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen, void** pVal, int32_t* pVLen);
 int32_t deleteRowBuff(SStreamFileState* pFileState, const void* pKey, int32_t keyLen);
 int32_t getRowBuffByPos(SStreamFileState* pFileState, SRowBuffPos* pPos, void** pVal);
-void    releaseRowBuffPos(SRowBuffPos* pBuff);
 bool    hasRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen);
+void    putFreeBuff(SStreamFileState* pFileState, SRowBuffPos* pPos);
 
 SStreamSnapshot* getSnapshot(SStreamFileState* pFileState);
 int32_t          flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, bool flushState);
@@ -52,6 +65,34 @@ int32_t deleteExpiredCheckPoint(SStreamFileState* pFileState, TSKEY mark);
 int32_t streamFileStateGeSelectRowSize(SStreamFileState* pFileState);
 void    streamFileStateReloadInfo(SStreamFileState* pFileState, TSKEY ts);
 
+void* getRowStateBuff(SStreamFileState* pFileState);
+void* getStateFileStore(SStreamFileState* pFileState);
+bool isDeteled(SStreamFileState* pFileState, TSKEY ts);
+bool isFlushedState(SStreamFileState* pFileState, TSKEY ts, TSKEY gap);
+SRowBuffPos* getNewRowPosForWrite(SStreamFileState* pFileState);
+int32_t getRowStateRowSize(SStreamFileState* pFileState);
+
+// session window
+int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, TSKEY gap, void** pVal, int32_t* pVLen);
+int32_t putSessionWinResultBuff(SStreamFileState* pFileState, SRowBuffPos* pPos);
+int32_t getSessionFlushedBuff(SStreamFileState* pFileState, SSessionKey* pKey, void** pVal, int32_t* pVLen);
+int32_t deleteSessionWinStateBuffFn(void* pBuff, const void *key, size_t keyLen);
+int32_t deleteSessionWinStateBuffByPosFn(SStreamFileState* pFileState, SRowBuffPos* pPos);
+
+void sessionWinStateClear(SStreamFileState* pFileState);
+void sessionWinStateCleanup(void* pBuff);
+
+SStreamStateCur* sessionWinStateSeekKeyCurrentPrev(SStreamFileState* pFileState, const SSessionKey* pWinKey);
+SStreamStateCur* sessionWinStateSeekKeyCurrentNext(SStreamFileState* pFileState, const SSessionKey* pWinKey);
+SStreamStateCur* sessionWinStateSeekKeyNext(SStreamFileState* pFileState, const SSessionKey* pWinKey);
+int32_t sessionWinStateGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, void** pVal, int32_t* pVLen);
+int32_t sessionWinStateMoveToNext(SStreamStateCur* pCur);
+int32_t sessionWinStateGetKeyByRange(SStreamFileState* pFileState, const SSessionKey* key, SSessionKey* curKey);
+
+// state window
+int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
+                             state_key_cmpr_fn fn, void** pVal, int32_t* pVLen);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/transport/trpc.h

@@ -37,6 +37,7 @@ typedef struct {
   int64_t  applyIndex;
   uint64_t applyTerm;
   char     user[TSDB_USER_LEN];
+
 } SRpcConnInfo;
 
 typedef struct SRpcHandleInfo {
@@ -60,6 +61,8 @@ typedef struct SRpcHandleInfo {
   STraceId traceId;
 
   SRpcConnInfo conn;
+  int8_t       forbiddenIp;
+
 } SRpcHandleInfo;
 
 typedef struct SRpcMsg {
@@ -162,6 +165,11 @@ int   rpcSendRequestWithCtx(void *thandle, const SEpSet *pEpSet, SRpcMsg *pMsg,
 int   rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp);
 int   rpcSetDefaultAddr(void *thandle, const char *ip, const char *fqdn);
 void *rpcAllocHandle();
+void  rpcSetIpWhite(void *thandl, void *arg);
+
+int32_t rpcUtilSIpRangeToStr(SIpV4Range *pRange, char *buf);
+
+int32_t rpcUtilSWhiteListToStr(SIpWhiteList *pWhiteList, char **ppBuf);
 
 #ifdef __cplusplus
 }

include/os/osDef.h

@@ -225,7 +225,10 @@ void syslog(int unused, const char *format, ...);
 #endif
 #else
 // Windows
-#define setThreadName(name)
+#define setThreadName(name)                       \
+  do {                                            \
+    pthread_setname_np(taosThreadSelf(), (name)); \
+  } while (0)
 #endif
 
 #if defined(_WIN32)

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/osSysinfo.h

@@ -39,7 +39,7 @@ int64_t taosGetOsUptime();
 int32_t taosGetEmail(char *email, int32_t maxLen);
 int32_t taosGetOsReleaseName(char *releaseName, char* sName, char* ver, int32_t maxLen);
 int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores);
-int32_t taosGetCpuCores(float *numOfCores);
+int32_t taosGetCpuCores(float *numOfCores, bool physical);
 void    taosGetCpuUsage(double *cpu_system, double *cpu_engine);
 int32_t taosGetCpuInstructions(char* sse42, char* avx, char* avx2, char* fma);
 int32_t taosGetTotalMemory(int64_t *totalKB);

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

@@ -123,6 +123,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_INVALID_DATA_FMT              TAOS_DEF_ERROR_CODE(0, 0x0132)
 #define TSDB_CODE_INVALID_CFG_VALUE             TAOS_DEF_ERROR_CODE(0, 0x0133)
 
+#define TSDB_CODE_IP_NOT_IN_WHITE_LIST          TAOS_DEF_ERROR_CODE(0, 0x0134)
+
 //client
 #define TSDB_CODE_TSC_INVALID_OPERATION         TAOS_DEF_ERROR_CODE(0, 0x0200)
 #define TSDB_CODE_TSC_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0201)
@@ -245,6 +247,10 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_AUTH_FAILURE              TAOS_DEF_ERROR_CODE(0, 0x0357)
 #define TSDB_CODE_MND_USER_NOT_AVAILABLE        TAOS_DEF_ERROR_CODE(0, 0x0358)
 #define TSDB_CODE_MND_PRIVILEDGE_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0359)
+#define TSDB_CODE_MND_USER_HOST_EXIST           TAOS_DEF_ERROR_CODE(0, 0x035A)
+#define TSDB_CODE_MND_USER_HOST_NOT_EXIST       TAOS_DEF_ERROR_CODE(0, 0x035B)
+#define TSDB_CODE_MND_TOO_MANY_USER_HOST       TAOS_DEF_ERROR_CODE(0, 0x035C)
+#define TSDB_CODE_MND_USER_LOCAL_HOST_NOT_DROP       TAOS_DEF_ERROR_CODE(0, 0x035D)
 
 // mnode-stable-part1
 #define TSDB_CODE_MND_STB_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x0360)
@@ -535,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
@@ -710,6 +723,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC TAOS_DEF_ERROR_CODE(0, 0x2668)
 #define TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED      TAOS_DEF_ERROR_CODE(0, 0x2669)
 #define TSDB_CODE_PAR_INVALID_VARBINARY         TAOS_DEF_ERROR_CODE(0, 0x266A)
+#define TSDB_CODE_PAR_INVALID_IP_RANGE          TAOS_DEF_ERROR_CODE(0, 0x266B)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x26FF)
 
 //planner

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

@@ -184,7 +184,7 @@ typedef enum ELogicConditionType {
 #define TSDB_UNI_LEN  24
 #define TSDB_USER_LEN TSDB_UNI_LEN
 
-#define TSDB_POINTER_PRINT_BYTES 18 // 0x1122334455667788
+#define TSDB_POINTER_PRINT_BYTES 18  // 0x1122334455667788
 // ACCOUNT is a 32 bit positive integer
 // this is the length of its string representation, including the terminator zero
 #define TSDB_ACCT_ID_LEN 11
@@ -202,6 +202,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_NAME_LEN              65
 #define TSDB_DB_FNAME_LEN             (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN)
 #define TSDB_PRIVILEDGE_CONDITION_LEN 48 * 1024
+#define TSDB_PRIVILEDGE_HOST_LEN      48 * 1024
 
 #define TSDB_FUNC_NAME_LEN       65
 #define TSDB_FUNC_COMMENT_LEN    1024 * 1024
@@ -321,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
@@ -378,6 +382,7 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_STT_TRIGGER     1
 #define TSDB_DEFAULT_SST_TRIGGER 1
 #endif
+#define TSDB_STT_TRIGGER_ARRAY_SIZE     16 // maximum of TSDB_MAX_STT_TRIGGER of TD_ENTERPRISE and TD_COMMUNITY
 #define TSDB_MIN_HASH_PREFIX     (2 - TSDB_TABLE_NAME_LEN)
 #define TSDB_MAX_HASH_PREFIX     (TSDB_TABLE_NAME_LEN - 2)
 #define TSDB_DEFAULT_HASH_PREFIX 0
@@ -417,7 +422,7 @@ typedef enum ELogicConditionType {
 #define TSDB_EXPLAIN_RESULT_ROW_SIZE    (16 * 1024)
 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY_PLAN"
 
-#define TSDB_MAX_FIELD_LEN    65519               // 16384:65519
+#define TSDB_MAX_FIELD_LEN     65519               // 16384:65519
 #define TSDB_MAX_BINARY_LEN    TSDB_MAX_FIELD_LEN  // 16384-8:65519
 #define TSDB_MAX_NCHAR_LEN     TSDB_MAX_FIELD_LEN  // 16384-8:65519
 #define TSDB_MAX_GEOMETRY_LEN  TSDB_MAX_FIELD_LEN  // 16384-8:65519

packaging/cfg/taos.cfg

@@ -98,6 +98,9 @@
 # enable/disable system monitor
 # monitor                   1
 
+# enable/disable audit log
+# audit                     1
+
 # The following parameter is used to limit the maximum number of lines in log files.
 # max number of lines per log filters
 # numOfLogLines             10000000
@@ -108,9 +111,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

@@ -607,6 +607,9 @@ function install_data() {
 function install_connector() {
   if [ -d "${script_dir}/connector/" ]; then
     ${csudo}cp -rf ${script_dir}/connector/ ${install_main_dir}/ || echo "failed to copy connector"
+    ${csudo}cp ${script_dir}/start-all.sh ${install_main_dir}/ || echo "failed to copy start-all.sh"
+    ${csudo}cp ${script_dir}/stop-all.sh ${install_main_dir}/ || echo "failed to copy stop-all.sh"
+    ${csudo}cp ${script_dir}/README.md ${install_main_dir}/ || echo "failed to copy README.md"
   fi
 }
 
@@ -622,6 +625,14 @@ function install_web() {
   fi
 }
 
+function install_taosx() {
+  if [ -f "${script_dir}/taosx/install_taosx.sh" ]; then    
+    cd ${script_dir}/taosx
+    chmod a+x install_taosx.sh
+    bash install_taosx.sh
+  fi
+}
+
 function clean_service_on_sysvinit() {
   if ps aux | grep -v grep | grep ${serverName2} &>/dev/null; then
     ${csudo}service ${serverName2} stop || :
@@ -893,6 +904,7 @@ function updateProduct() {
 
   if [ "$verMode" == "cluster" ]; then
       install_connector
+      install_taosx
   fi
 
   install_examples
@@ -907,38 +919,54 @@ function updateProduct() {
     openresty_work=false
 
     echo
-    echo -e "${GREEN_DARK}To configure ${productName2} ${NC}\t: edit ${cfg_install_dir}/${configFile2}"
+    echo -e "${GREEN_DARK}To configure ${productName2} ${NC}\t\t: edit ${cfg_install_dir}/${configFile2}"
     [ -f ${configDir}/${clientName2}adapter.toml ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
       echo -e "${GREEN_DARK}To configure ${clientName2}Adapter ${NC}\t: edit ${configDir}/${clientName2}adapter.toml"
+    if [ "$verMode" == "cluster" ]; then
+      echo -e "${GREEN_DARK}To configure ${clientName2}-explorer ${NC}\t: edit ${configDir}/explorer.toml"
+    fi
     if ((${service_mod} == 0)); then
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ${csudo}systemctl start ${serverName2}${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ${csudo}systemctl start ${serverName2}${NC}"
       [ -f ${service_config_dir}/${clientName2}adapter.service ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${csudo}systemctl start ${clientName2}adapter ${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${csudo}systemctl start ${clientName2}adapter ${NC}"
     elif ((${service_mod} == 1)); then
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ${csudo}service ${serverName2} start${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ${csudo}service ${serverName2} start${NC}"
       [ -f ${service_config_dir}/${clientName2}adapter.service ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${csudo}service ${clientName2}adapter start${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${csudo}service ${clientName2}adapter start${NC}"
     else
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ./${serverName2}${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ./${serverName2}${NC}"
       [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${clientName2}adapter ${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${clientName2}adapter ${NC}"
     fi
     
-    echo -e "${GREEN_DARK}To enable ${clientName2}keeper ${NC}\t: sudo systemctl enable ${clientName2}keeper ${NC}"
-
-    if [ ${openresty_work} = 'true' ]; then
-      echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t: use ${GREEN_UNDERLINE}${clientName2} -h $serverFqdn${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${web_port}${NC}"
-    else
-      echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t: use ${GREEN_UNDERLINE}${clientName2} -h $serverFqdn${NC} in shell${NC}"
+    echo -e "${GREEN_DARK}To enable ${clientName2}keeper ${NC}\t\t: sudo systemctl enable ${clientName2}keeper ${NC}"
+    if [ "$verMode" == "cluster" ];then
+      echo -e "${GREEN_DARK}To start ${clientName2}x ${NC}\t\t\t: sudo systemctl start ${clientName2}x ${NC}"
+      echo -e "${GREEN_DARK}To start ${clientName2}-explorer ${NC}\t\t: sudo systemctl start ${clientName2}-explorer ${NC}"
     fi
 
-    if ((${prompt_force} == 1)); then
-      echo ""
-      echo -e "${RED}Please run '${serverName2} --force-keep-file' at first time for the exist ${productName2} $exist_version!${NC}"
-    fi
+    # if [ ${openresty_work} = 'true' ]; then
+    #   echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t\t: use ${GREEN_UNDERLINE}${clientName2} -h $serverFqdn${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${web_port}${NC}"
+    # else
+    #   echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t\t: use ${GREEN_UNDERLINE}${clientName2} -h $serverFqdn${NC} in shell${NC}"
+    # fi
+
+    # if ((${prompt_force} == 1)); then
+    #   echo ""
+    #   echo -e "${RED}Please run '${serverName2} --force-keep-file' at first time for the exist ${productName2} $exist_version!${NC}"
+    # fi
+
     echo
     echo -e "\033[44;32;1m${productName2} is updated successfully!${NC}"
-    echo -e "\033[44;32;1mTo manage ${productName2} instance, view documentation or explorer features, please install ${clientName2}Explorer ${NC}"
+    echo
+    if [ "$verMode" == "cluster" ];then
+      echo -e "\033[44;32;1mTo start all the components  \t: sudo ./start-all.sh${NC}"
+    fi
+    echo -e "\033[44;32;1mTo access ${productName2}  \t\t: ${clientName2} -h $serverFqdn${NC}"
+    if [ "$verMode" == "cluster" ];then
+      echo -e "\033[44;32;1mTo access the management system \t: http://$serverFqdn:6060${NC}"
+      echo -e "\033[44;32;1mTo read the user manual          \t: http://$serverFqdn:6060/docs${NC}"
+    fi
   else
     install_bin
     install_config
@@ -947,7 +975,8 @@ function updateProduct() {
     echo -e "\033[44;32;1m${productName2} client is updated successfully!${NC}"
   fi
 
-  rm -rf $(tar -tf ${tarName} | grep -Ev "^\./$|^\/")
+  cd $script_dir
+  rm -rf $(tar -tf ${tarName} | grep -Ev "^\./$|^\/") 
 }
 
 function installProduct() {
@@ -975,6 +1004,7 @@ function installProduct() {
 
   if [ "$verMode" == "cluster" ]; then
       install_connector
+      install_taosx    
   fi
   install_examples  
   install_web
@@ -991,47 +1021,63 @@ function installProduct() {
 
     # Ask if to start the service
     echo
-    echo -e "${GREEN_DARK}To configure ${productName2} ${NC}\t: edit ${cfg_install_dir}/${configFile2}"
+    echo -e "${GREEN_DARK}To configure ${productName2} ${NC}\t\t: edit ${cfg_install_dir}/${configFile2}"
     [ -f ${configDir}/${clientName2}adapter.toml ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
       echo -e "${GREEN_DARK}To configure ${clientName2}Adapter ${NC}\t: edit ${configDir}/${clientName2}adapter.toml"
+    if [ "$verMode" == "cluster" ]; then
+      echo -e "${GREEN_DARK}To configure ${clientName2}-explorer ${NC}\t: edit ${configDir}/explorer.toml"
+    fi
     if ((${service_mod} == 0)); then
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ${csudo}systemctl start ${serverName2}${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ${csudo}systemctl start ${serverName2}${NC}"
       [ -f ${service_config_dir}/${clientName2}adapter.service ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${csudo}systemctl start ${clientName2}adapter ${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${csudo}systemctl start ${clientName2}adapter ${NC}"
     elif ((${service_mod} == 1)); then
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ${csudo}service ${serverName2} start${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ${csudo}service ${serverName2} start${NC}"
       [ -f ${service_config_dir}/${clientName2}adapter.service ] && [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${csudo}service ${clientName2}adapter start${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${csudo}service ${clientName2}adapter start${NC}"
     else
-      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t: ${serverName2}${NC}"
+      echo -e "${GREEN_DARK}To start ${productName2}     ${NC}\t\t: ${serverName2}${NC}"
       [ -f ${installDir}/bin/${clientName2}adapter ] && \
-        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t: ${clientName2}adapter ${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName2}Adapter ${NC}\t\t: ${clientName2}adapter ${NC}"
     fi
 
-    echo -e "${GREEN_DARK}To enable ${clientName2}keeper ${NC}\t: sudo systemctl enable ${clientName2}keeper ${NC}"
-
-    if [ ! -z "$firstEp" ]; then
-      tmpFqdn=${firstEp%%:*}
-      substr=":"
-      if [[ $firstEp =~ $substr ]]; then
-        tmpPort=${firstEp#*:}
-      else
-        tmpPort=""
-      fi
-      if [[ "$tmpPort" != "" ]]; then
-        echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t: ${clientName2} -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
-      else
-        echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t: ${clientName2} -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
-      fi
-      echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
-      echo
-    elif [ ! -z "$serverFqdn" ]; then
-      echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t: ${clientName2} -h $serverFqdn${GREEN_DARK} to login into ${productName2} server${NC}"
-      echo
+    echo -e "${GREEN_DARK}To enable ${clientName2}keeper ${NC}\t\t: sudo systemctl enable ${clientName2}keeper ${NC}"
+    
+    if [ "$verMode" == "cluster" ];then
+      echo -e "${GREEN_DARK}To start ${clientName2}x ${NC}\t\t\t: sudo systemctl start ${clientName2}x ${NC}"
+      echo -e "${GREEN_DARK}To start ${clientName2}-explorer ${NC}\t\t: sudo systemctl start ${clientName2}-explorer ${NC}"
     fi
 
+    # if [ ! -z "$firstEp" ]; then
+    #   tmpFqdn=${firstEp%%:*}
+    #   substr=":"
+    #   if [[ $firstEp =~ $substr ]]; then
+    #     tmpPort=${firstEp#*:}
+    #   else
+    #     tmpPort=""
+    #   fi
+    #   if [[ "$tmpPort" != "" ]]; then
+    #     echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t\t: ${clientName2} -h $tmpFqdn -P $tmpPort${GREEN_DARK} to login into cluster, then${NC}"
+    #   else
+    #     echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t\t: ${clientName2} -h $tmpFqdn${GREEN_DARK} to login into cluster, then${NC}"
+    #   fi
+    #   echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+    #   echo
+    # elif [ ! -z "$serverFqdn" ]; then
+    #   echo -e "${GREEN_DARK}To access ${productName2}    ${NC}\t\t: ${clientName2} -h $serverFqdn${GREEN_DARK} to login into ${productName2} server${NC}"
+    #   echo
+    # fi
+    echo
     echo -e "\033[44;32;1m${productName2} is installed successfully!${NC}"
-    echo -e "\033[44;32;1mTo manage ${productName2} instance, view documentation or explorer features, please install ${clientName2}Explorer ${NC}"
+    echo
+    if [ "$verMode" == "cluster" ];then
+      echo -e "\033[44;32;1mTo start all the components  \t: sudo ./start-all.sh${NC}"
+    fi
+    echo -e "\033[44;32;1mTo access ${productName2}  \t\t: ${clientName2} -h $serverFqdn${NC}"
+    if [ "$verMode" == "cluster" ];then
+      echo -e "\033[44;32;1mTo access the management system \t: http://$serverFqdn:6060${NC}"
+      echo -e "\033[44;32;1mTo read the user manual          \t: http://$serverFqdn:6060/docs${NC}"
+    fi
     echo
   else # Only install client
     install_bin
@@ -1039,7 +1085,8 @@ function installProduct() {
     echo
     echo -e "\033[44;32;1m${productName2} client is installed successfully!${NC}"
   fi
-
+  
+  cd $script_dir
   touch ~/.${historyFile}
   rm -rf $(tar -tf ${tarName} | grep -Ev "^\./$|^\/")
 }
@@ -1070,4 +1117,4 @@ elif [ "$verType" == "client" ]; then
   fi
 else
   echo "please input correct verType"
-fi
+fi

packaging/tools/makepkg.sh

@@ -284,8 +284,13 @@ if [ "$pagMode" == "lite" ]; then
 fi
 chmod a+x ${install_dir}/install.sh
 
-if [[ $dbName == "taos" ]]; then
-  # Copy example code
+if [[ $dbName == "taos" ]]; then  
+  cp ${top_dir}/../enterprise/packaging/start-all.sh ${install_dir}
+  cp ${top_dir}/../enterprise/packaging/stop-all.sh ${install_dir}
+  cp ${top_dir}/../enterprise/packaging/README.md ${install_dir}
+  chmod a+x ${install_dir}/start-all.sh
+  chmod a+x ${install_dir}/stop-all.sh
+  # Copy example code  
   mkdir -p ${install_dir}/examples
   examples_dir="${top_dir}/examples"
   cp -r ${examples_dir}/c ${install_dir}/examples
@@ -330,8 +335,8 @@ fi
 mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo "${versionComp}" >${install_dir}/driver/vercomp.txt
 [ -f ${wslib_files} ] && cp ${wslib_files} ${install_dir}/driver || :
 
-# Copy connector
-if [ "$verMode" == "cluster" ]; then
+# Copy connector && taosx
+if [ "$verMode" == "cluster" ]; then    
     connector_dir="${code_dir}/connector"
     mkdir -p ${install_dir}/connector
     if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
@@ -364,8 +369,15 @@ if [ "$verMode" == "cluster" ]; then
         git clone --depth 1 https://github.com/taosdata/taos-connector-rust ${install_dir}/connector/rust
         rm -rf ${install_dir}/connector/rust/.git ||:
 
-        # cp -r ${connector_dir}/python ${install_dir}/connector
-        # cp -r ${connector_dir}/nodejs ${install_dir}/connector
+        # copy taosx
+        if [ -d ${top_dir}/../enterprise/src/plugins/taosx/release/taosx ]; then
+          cp -r ${top_dir}/../enterprise/src/plugins/taosx/release/taosx ${install_dir}
+          cp ${top_dir}/../enterprise/packaging/install_taosx.sh ${install_dir}/taosx
+          cp ${top_dir}/../enterprise/src/plugins/taosx/packaging/uninstall.sh ${install_dir}/taosx
+        else
+          echo "taox package not found"
+          exit 1
+        fi
     fi
 fi
 
@@ -436,4 +448,4 @@ if [ -n "${taostools_bin_files}" ] && [ "$verMode" != "cloud" ]; then
     fi
 fi
 
-cd ${curr_dir}
+cd ${curr_dir}

packaging/tools/remove.sh

@@ -284,6 +284,16 @@ function clean_service() {
   fi
 }
 
+function uninstall_taosx() {
+  if [ -f /usr/local/taosx/uninstall.sh ]; then
+    cd /usr/local/taosx
+    bash uninstall.sh > /dev/null
+
+    echo -e "${GREEN}${xName2} is removed successfully!${NC}"
+    echo -e "${GREEN}${explorerName2} is removed successfully!${NC}"
+  fi
+}
+
 # Stop service and disable booting start.
 clean_service
 # Remove binary file and links
@@ -323,4 +333,7 @@ if [ "$osType" = "Darwin" ]; then
 fi
 
 echo -e "${GREEN}${productName2} is removed successfully!${NC}"
-echo
+if [ "$verMode" == "cluster" ]; then
+  uninstall_taosx
+fi
+echo

source/client/inc/clientInt.h

@@ -133,25 +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;
+  __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;
+  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) {
@@ -116,6 +129,19 @@ static int32_t hbUpdateUserAuthInfo(SAppHbMgr *pAppHbMgr, SUserAuthBatchRsp *bat
                    atomic_load_32(&passInfo->ver), pTscObj->id);
         }
       }
+
+      if (pTscObj->whiteListInfo.fp) {
+        SWhiteListInfo *whiteListInfo = &pTscObj->whiteListInfo;
+        int64_t    oldVer = atomic_load_64(&whiteListInfo->ver);
+        if (oldVer < pRsp->whiteListVer) {
+          atomic_store_64(&whiteListInfo->ver, pRsp->whiteListVer);
+          if (whiteListInfo->fp) {
+            (*whiteListInfo->fp)(whiteListInfo->param, &pRsp->whiteListVer, TAOS_NOTIFY_WHITELIST_VER);
+          }
+          tscDebug("update whitelist version of user %s from %"PRId64" to %"PRId64", tscRid:%" PRIi64, pRsp->user, oldVer,
+                   atomic_load_64(&whiteListInfo->ver), pTscObj->id);
+        }
+      }
       releaseTscObj(pReq->connKey.tscRid);
     }
   }
@@ -829,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

@@ -157,6 +157,10 @@ STscObj* taos_connect_internal(const char* ip, const char* user, const char* pas
     tscDebug("new app inst mgr %p, user:%s, ip:%s, port:%d", p, user, epSet.epSet.eps[0].fqdn, epSet.epSet.eps[0].port);
 
     pInst = &p;
+  } else {
+    ASSERTS((*pInst) && (*pInst)->pAppHbMgr, "*pInst:%p, pAppHgMgr:%p", *pInst, (*pInst) ? (*pInst)->pAppHbMgr : NULL);
+    // reset to 0 in case of conn with duplicated user key but its user has ever been dropped.
+    atomic_store_8(&(*pInst)->pAppHbMgr->connHbFlag, 0);
   }
 
   taosThreadMutexUnlock(&appInfo.mutex);
@@ -297,7 +301,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);
+  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);
   }
@@ -335,7 +340,7 @@ void asyncExecLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
     return;
   }
 
-  int32_t code = qExecCommand(&pRequest->pTscObj->id, pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp);
+  int32_t code = qExecCommand(&pRequest->pTscObj->id, pRequest->pTscObj->sysInfo, pQuery->pRoot, &pRsp, atomic_load_8(&pRequest->pTscObj->biMode));
   if (TSDB_CODE_SUCCESS == code && NULL != pRsp) {
     code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp, false, true);
   }
@@ -2553,6 +2558,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

@@ -140,6 +140,20 @@ int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type)
       taosThreadMutexUnlock(&pObj->mutex);
       break;
     }
+    case TAOS_NOTIFY_WHITELIST_VER: {
+      taosThreadMutexLock(&pObj->mutex);
+      pObj->whiteListInfo.fp = fp;
+      pObj->whiteListInfo.param = param;
+      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);
@@ -151,6 +165,113 @@ int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type)
   return 0;
 }
 
+typedef struct SFetchWhiteListInfo{
+  int64_t connId;
+  __taos_async_whitelist_fn_t userCbFn;
+  void* userParam;
+} SFetchWhiteListInfo;
+
+int32_t fetchWhiteListCallbackFn(void* param, SDataBuf* pMsg, int32_t code) {
+  SFetchWhiteListInfo* pInfo = (SFetchWhiteListInfo*)param;
+  TAOS* taos = &pInfo->connId;
+  if (code != TSDB_CODE_SUCCESS) {
+    pInfo->userCbFn(pInfo->userParam, code, taos, 0, NULL);
+    taosMemoryFree(pMsg->pData);
+    taosMemoryFree(pMsg->pEpSet);
+    taosMemoryFree(pInfo);
+    return code;
+  }
+
+  SGetUserWhiteListRsp wlRsp;
+  tDeserializeSGetUserWhiteListRsp(pMsg->pData, pMsg->len, &wlRsp);
+
+  uint64_t* pWhiteLists = taosMemoryMalloc(wlRsp.numWhiteLists * sizeof(uint64_t));
+  if (pWhiteLists == NULL) {
+    taosMemoryFree(pMsg->pData);
+    taosMemoryFree(pMsg->pEpSet);
+    taosMemoryFree(pInfo);
+    tFreeSGetUserWhiteListRsp(&wlRsp);
+  }
+
+  for (int i = 0; i < wlRsp.numWhiteLists; ++i) {
+    pWhiteLists[i] = ((uint64_t)wlRsp.pWhiteLists[i].mask << 32) | wlRsp.pWhiteLists[i].ip;
+  }
+
+  pInfo->userCbFn(pInfo->userParam, code, taos, wlRsp.numWhiteLists, pWhiteLists);
+
+  taosMemoryFree(pWhiteLists);
+  taosMemoryFree(pMsg->pData);
+  taosMemoryFree(pMsg->pEpSet);
+  taosMemoryFree(pInfo);
+  tFreeSGetUserWhiteListRsp(&wlRsp);
+  return code;
+}
+
+void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param) {
+  if (NULL == taos) {
+    fp(param, TSDB_CODE_INVALID_PARA, taos, 0, NULL);
+    return;
+  }
+
+  int64_t connId = *(int64_t*)taos;
+
+  STscObj *pTsc = acquireTscObj(connId);
+  if (NULL == pTsc) {
+    fp(param, TSDB_CODE_TSC_DISCONNECTED, taos, 0, NULL);
+    return;
+  }
+
+  SGetUserWhiteListReq req;
+  memcpy(req.user, pTsc->user, TSDB_USER_LEN);
+  int32_t msgLen = tSerializeSGetUserWhiteListReq(NULL, 0, &req);
+  void* pReq = taosMemoryMalloc(msgLen);
+  if (pReq == NULL) {
+    fp(param, TSDB_CODE_OUT_OF_MEMORY, taos, 0, NULL);
+    releaseTscObj(connId);
+    return;
+  }
+
+  if (tSerializeSGetUserWhiteListReq(pReq, msgLen, &req) < 0) {
+    fp(param, TSDB_CODE_INVALID_PARA, taos, 0, NULL);
+    taosMemoryFree(pReq);
+    releaseTscObj(connId);
+    return;
+  }
+
+  SFetchWhiteListInfo* pParam = taosMemoryMalloc(sizeof(SFetchWhiteListInfo));
+  if (pParam == NULL) {
+    fp(param, TSDB_CODE_OUT_OF_MEMORY, taos, 0, NULL);
+    taosMemoryFree(pReq);
+    releaseTscObj(connId);
+    return;
+  }
+
+  pParam->connId = connId;
+  pParam->userCbFn = fp;
+  pParam->userParam = param;
+  SMsgSendInfo* pSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
+  if (pSendInfo == NULL) {
+    fp(param,  TSDB_CODE_OUT_OF_MEMORY, taos, 0, NULL);
+    taosMemoryFree(pParam);
+    taosMemoryFree(pReq);
+    releaseTscObj(connId);
+    return;
+  }
+
+  pSendInfo->msgInfo = (SDataBuf){.pData = pReq, .len = msgLen, .handle = NULL};
+  pSendInfo->requestId = generateRequestId();
+  pSendInfo->requestObjRefId = 0;
+  pSendInfo->param = pParam;
+  pSendInfo->fp = fetchWhiteListCallbackFn;
+  pSendInfo->msgType = TDMT_MND_GET_USER_WHITELIST;
+
+  int64_t transportId = 0;
+  SEpSet epSet = getEpSet_s(&pTsc->pAppInfo->mgmtEp);
+  asyncSendMsgToServer(pTsc->pAppInfo->pTransporter, &epSet, &transportId, pSendInfo);
+  releaseTscObj(connId);
+  return;
+}
+
 void taos_close_internal(void *taos) {
   if (taos == NULL) {
     return;
@@ -1052,6 +1173,8 @@ int32_t createParseContext(const SRequestObj *pRequest, SParseContext **pCxt) {
                            .svrVer = pTscObj->sVer,
                            .nodeOffline = (pTscObj->pAppInfo->onlineDnodes < pTscObj->pAppInfo->totalDnodes),
                            .allocatorId = pRequest->allocatorRefId};
+  int8_t biMode = atomic_load_8(&((STscObj *)pTscObj)->biMode);
+  (*pCxt)->biMode = biMode;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1715,3 +1838,26 @@ int taos_stmt_close(TAOS_STMT *stmt) {
 
   return stmtClose(stmt);
 }
+
+int taos_set_conn_mode(TAOS* taos, int mode, int value) {
+  if (taos == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+
+  STscObj *pObj = acquireTscObj(*(int64_t *)taos);
+  if (NULL == pObj) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    tscError("invalid parameter for %s", __func__);
+    return terrno;
+  }
+  switch (mode) {
+    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/clientMsgHandler.c

@@ -139,6 +139,7 @@ int32_t processConnectRsp(void* param, SDataBuf* pMsg, int32_t code) {
   pTscObj->connType = connectRsp.connType;
   pTscObj->passInfo.ver = connectRsp.passVer;
   pTscObj->authVer = connectRsp.authVer;
+  pTscObj->whiteListInfo.ver = connectRsp.whiteListVer;
 
   hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, pTscObj->id, connectRsp.clusterId, connectRsp.connType);
 

source/client/src/clientRawBlockWrite.c

@@ -1412,7 +1412,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);
@@ -1497,7 +1497,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/test/clientTests.cpp

@@ -47,7 +47,8 @@ void printSubResults(void* pRes, int32_t* totalRows) {
     int32_t precision = taos_result_precision(pRes);
     taos_print_row(buf, row, fields, numOfFields);
     *totalRows += 1;
-    printf("vgId: %d, offset: %lld, precision: %d, row content: %s\n", vgId, offset, precision, buf);
+    std::cout << "vgId:" << vgId << ", offset:" << offset << ", precision:" << precision << ", row content:" << buf
+              << std::endl;
   }
 
 //  taos_free_result(pRes);
@@ -832,7 +833,7 @@ TEST(clientCase, projection_query_tables) {
   for(int32_t i = 0; i < 1000000; ++i) {
     char t[512] = {0};
 
-    sprintf(t, "insert into t1 values(now, %ld)", i);
+    sprintf(t, "insert into t1 values(now, %d)", i);
     while(1) {
       void* p = taos_query(pConn, t);
       code = taos_errno(p);
@@ -1167,16 +1168,19 @@ TEST(clientCase, tmq_commit) {
   }
 
   for(int i = 0; i < numOfAssign; i++){
-    printf("assign i:%d, vgId:%d, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+    tmq_topic_assignment* pa = &pAssign[i];
+    std::cout << "assign i:" << i << ", vgId:" << pa->vgId << ", offset:" << pa->currentOffset << ", start:%"
+              << pa->begin << ", end:%" << pa->end << std::endl;
 
-    int64_t committed = tmq_committed(tmq, topicName, pAssign[i].vgId);
-    printf("committed vgId:%d, committed:%lld\n", pAssign[i].vgId, committed);
+    int64_t committed = tmq_committed(tmq, topicName, pa->vgId);
+    std::cout << "committed vgId:" << pa->vgId << " committed:" << committed << std::endl;
 
-    int64_t position = tmq_position(tmq, topicName, pAssign[i].vgId);
-    printf("position vgId:%d, position:%lld\n", pAssign[i].vgId, position);
-    tmq_offset_seek(tmq, topicName, pAssign[i].vgId, 1);
-    position = tmq_position(tmq, topicName, pAssign[i].vgId);
-    printf("after seek 1, position vgId:%d, position:%lld\n", pAssign[i].vgId, position);
+    int64_t position = tmq_position(tmq, topicName, pa->vgId);
+    std::cout << "position vgId:" << pa->vgId << ", position:" << position << std::endl;
+
+    tmq_offset_seek(tmq, topicName, pa->vgId, 1);
+    position = tmq_position(tmq, topicName, pa->vgId);
+    std::cout << "after seek 1, position vgId:" << pa->vgId << " position:" << position << std::endl;
   }
 
   while (1) {
@@ -1191,12 +1195,14 @@ TEST(clientCase, tmq_commit) {
     tmq_commit_sync(tmq, pRes);
     for(int i = 0; i < numOfAssign; i++) {
       int64_t committed = tmq_committed(tmq, topicName, pAssign[i].vgId);
-      printf("committed vgId:%d, committed:%lld\n", pAssign[i].vgId, committed);
+      std::cout << "committed vgId:" << pAssign[i].vgId << " , committed:" << committed << std::endl;
       if(committed > 0){
         int32_t code = tmq_commit_offset_sync(tmq, topicName, pAssign[i].vgId, 4);
         printf("tmq_commit_offset_sync vgId:%d, offset:4, code:%d\n", pAssign[i].vgId, code);
         int64_t committed = tmq_committed(tmq, topicName, pAssign[i].vgId);
-        printf("after tmq_commit_offset_sync, committed vgId:%d, committed:%lld\n", pAssign[i].vgId, committed);
+
+        std::cout << "after tmq_commit_offset_sync, committed vgId:" << pAssign[i].vgId << ", committed:" << committed
+                  << std::endl;
       }
     }
     if (pRes != NULL) {
@@ -1212,7 +1218,12 @@ TEST(clientCase, tmq_commit) {
   taos_close(pConn);
   fprintf(stderr, "%d msg consumed, include %d rows\n", msgCnt, totalRows);
 }
-
+namespace {
+void doPrintInfo(tmq_topic_assignment* pa, int32_t index) {
+  std::cout << "assign i:" << index << ", vgId:" << pa->vgId << ", offset:%" << pa->currentOffset << ", start:%"
+            << pa->begin << ", end:%" << pa->end << std::endl;
+}
+}
 TEST(clientCase, td_25129) {
 //  taos_options(TSDB_OPTION_CONFIGDIR, "~/first/cfg");
 
@@ -1264,7 +1275,7 @@ TEST(clientCase, td_25129) {
   }
 
   for(int i = 0; i < numOfAssign; i++){
-    printf("assign i:%d, vgId:%d, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+    doPrintInfo(&pAssign[i], i);
   }
 
 //  tmq_offset_seek(tmq, "tp", pAssign[0].vgId, 4);
@@ -1281,7 +1292,7 @@ TEST(clientCase, td_25129) {
   }
 
   for(int i = 0; i < numOfAssign; i++){
-    printf("assign i:%d, vgId:%d, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+    doPrintInfo(&pAssign[i], i);
   }
 
   tmq_free_assignment(pAssign);
@@ -1298,7 +1309,7 @@ TEST(clientCase, td_25129) {
 
   for(int i = 0; i < numOfAssign; i++){
     int64_t committed = tmq_committed(tmq, topicName, pAssign[i].vgId);
-    printf("assign i:%d, vgId:%d, committed:%lld, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, committed, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+    doPrintInfo(&pAssign[i], i);
   }
 
   while (1) {
@@ -1328,7 +1339,7 @@ TEST(clientCase, td_25129) {
       }
 
       for(int i = 0; i < numOfAssign; i++){
-        printf("assign i:%d, vgId:%d, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+        doPrintInfo(&pAssign[i], i);
       }
     } else {
       for(int i = 0; i < numOfAssign; i++) {
@@ -1364,7 +1375,7 @@ TEST(clientCase, td_25129) {
   }
 
   for(int i = 0; i < numOfAssign; i++){
-    printf("assign i:%d, vgId:%d, offset:%lld, start:%lld, end:%lld\n", i, pAssign[i].vgId, pAssign[i].currentOffset, pAssign[i].begin, pAssign[i].end);
+    doPrintInfo(&pAssign[i], i);
   }
 
   tmq_free_assignment(pAssign);

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[] = {
@@ -225,6 +226,7 @@ static const SSysDbTableSchema userUsersSchema[] = {
     {.name = "enable", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = false},
     {.name = "sysinfo", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = false},
     {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
+    {.name = "allowed_host", .bytes = TSDB_PRIVILEDGE_HOST_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
 GRANTS_SCHEMA;
@@ -330,7 +332,7 @@ static const SSysTableMeta infosMeta[] = {
     {TSDB_INS_TABLE_TAGS, userTagsSchema, tListLen(userTagsSchema), false},
     {TSDB_INS_TABLE_COLS, userColsSchema, tListLen(userColsSchema), false},
     // {TSDB_INS_TABLE_TABLE_DISTRIBUTED, userTblDistSchema, tListLen(userTblDistSchema)},
-    {TSDB_INS_TABLE_USERS, userUsersSchema, tListLen(userUsersSchema), false},
+    {TSDB_INS_TABLE_USERS, userUsersSchema, tListLen(userUsersSchema), true},
     {TSDB_INS_TABLE_LICENCES, grantsSchema, tListLen(grantsSchema), true},
     {TSDB_INS_TABLE_VGROUPS, vgroupsSchema, tListLen(vgroupsSchema), true},
     {TSDB_INS_TABLE_CONFIGS, configSchema, tListLen(configSchema), false},
@@ -340,7 +342,7 @@ static const SSysTableMeta infosMeta[] = {
     {TSDB_INS_TABLE_STREAMS, streamSchema, tListLen(streamSchema), false},
     {TSDB_INS_TABLE_STREAM_TASKS, streamTaskSchema, tListLen(streamTaskSchema), false},
     {TSDB_INS_TABLE_VNODES, vnodesSchema, tListLen(vnodesSchema), true},
-    {TSDB_INS_TABLE_USER_PRIVILEGES, userUserPrivilegesSchema, tListLen(userUserPrivilegesSchema), false},
+    {TSDB_INS_TABLE_USER_PRIVILEGES, userUserPrivilegesSchema, tListLen(userUserPrivilegesSchema), true},
 };
 
 static const SSysDbTableSchema connectionsSchema[] = {

source/common/src/tdatablock.c

@@ -933,7 +933,13 @@ int32_t dataBlockCompar(const void* p1, const void* p2, const void* param) {
         return 0;
       }
     }
-    __compar_fn_t fn = getKeyComparFunc(pColInfoData->info.type, pOrder->order);
+
+    __compar_fn_t fn;
+    if (pOrder->compFn) {
+      fn = pOrder->compFn;
+    } else {
+      fn = getKeyComparFunc(pColInfoData->info.type, pOrder->order);
+    }
 
     int ret = fn(left1, right1);
     if (ret == 0) {
@@ -1099,6 +1105,7 @@ int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo) {
   for (int32_t i = 0; i < taosArrayGetSize(helper.orderInfo); ++i) {
     struct SBlockOrderInfo* pInfo = taosArrayGet(helper.orderInfo, i);
     pInfo->pColData = taosArrayGet(pDataBlock->pDataBlock, pInfo->slotId);
+    pInfo->compFn = getKeyComparFunc(pInfo->pColData->info.type, pInfo->order);
   }
 
   terrno = 0;
@@ -2508,3 +2515,20 @@ void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList
 int32_t blockGetEncodeSize(const SSDataBlock* pBlock) {
   return blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock)) + blockDataGetSize(pBlock);
 }
+
+int32_t blockDataGetSortedRows(SSDataBlock* pDataBlock, SArray* pOrderInfo) {
+  if (!pDataBlock || !pOrderInfo) return 0;
+  for (int32_t i = 0; i < taosArrayGetSize(pOrderInfo); ++i) {
+    SBlockOrderInfo* pOrder = taosArrayGet(pOrderInfo, i);
+    pOrder->pColData = taosArrayGet(pDataBlock->pDataBlock, pOrder->slotId);
+    pOrder->compFn = getKeyComparFunc(pOrder->pColData->info.type, pOrder->order);
+  }
+  SSDataBlockSortHelper sortHelper = {.orderInfo = pOrderInfo, .pDataBlock = pDataBlock};
+  int32_t rowIdx = 0, nextRowIdx = 1;
+  for (; rowIdx < pDataBlock->info.rows && nextRowIdx < pDataBlock->info.rows; ++rowIdx, ++nextRowIdx) {
+    if (dataBlockCompar(&nextRowIdx, &rowIdx, &sortHelper) < 0) {
+      break;
+    }
+  }
+  return nextRowIdx;
+}

source/common/src/tdataformat.c

@@ -1561,11 +1561,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"
@@ -81,6 +82,7 @@ int64_t tsMndLogRetention = 2000;
 int8_t  tsGrant = 1;
 int32_t tsMndGrantMode = 0;
 bool    tsMndSkipGrant = false;
+bool    tsEnableWhiteList = false;  // ip white list cfg
 
 // dnode
 int64_t tsDndStart = 0;
@@ -143,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,
@@ -210,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
@@ -252,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>";
@@ -263,6 +266,11 @@ 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 = 300;
+
 #ifndef _STORAGE
 int32_t taosSetTfsCfg(SConfig *pCfg) {
   SConfigItem *pItem = cfgGetItem(pCfg, "dataDir");
@@ -318,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) {
@@ -628,6 +638,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)
@@ -644,8 +655,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;
@@ -653,11 +671,14 @@ 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,
                   CFG_SCOPE_SERVER) != 0)
     return -1;
+  if (cfgAddBool(pCfg, "enableWhiteList", tsEnableWhiteList, CFG_SCOPE_SERVER) != 0) return -1;
 
   GRANT_CFG_ADD;
   return 0;
@@ -1034,6 +1055,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;
 
@@ -1047,6 +1069,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsMndLogRetention = cfgGetItem(pCfg, "mndLogRetention")->i64;
   tsMndSkipGrant = cfgGetItem(pCfg, "skipGrant")->bval;
   tsMndGrantMode = cfgGetItem(pCfg, "grantMode")->i32;
+  tsEnableWhiteList = cfgGetItem(pCfg, "enableWhiteList")->bval;
 
   tsStartUdfd = cfgGetItem(pCfg, "udf")->bval;
   tstrncpy(tsUdfdResFuncs, cfgGetItem(pCfg, "udfdResFuncs")->str, sizeof(tsUdfdResFuncs));
@@ -1057,16 +1080,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;
 }
@@ -1445,6 +1479,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;
     }
@@ -1640,10 +1676,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

@@ -1077,6 +1077,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);
@@ -1102,6 +1164,7 @@ int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   if (tEncodeCStr(&encoder, pReq->clusterCfg.timezone) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->clusterCfg.locale) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->clusterCfg.charset) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->clusterCfg.enableWhiteList) < 0) return -1;
 
   // vnode loads
   int32_t vlen = (int32_t)taosArrayGetSize(pReq->pVloads);
@@ -1157,6 +1220,8 @@ int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
     if (tEncodeI64(&encoder, reserved) < 0) return -1;
     if (tEncodeI64(&encoder, reserved) < 0) return -1;
   }
+
+  if (tEncodeI64(&encoder, pReq->ipWhiteVer) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1189,6 +1254,7 @@ int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   if (tDecodeCStrTo(&decoder, pReq->clusterCfg.timezone) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->clusterCfg.locale) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->clusterCfg.charset) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->clusterCfg.enableWhiteList) < 0) return -1;
 
   // vnode loads
   int32_t vlen = 0;
@@ -1266,6 +1332,10 @@ int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
       if (tDecodeI64(&decoder, &reserved) < 0) return -1;
     }
   }
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI64(&decoder, &pReq->ipWhiteVer) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
   tDecoderClear(&decoder);
   return 0;
@@ -1298,6 +1368,8 @@ int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
   }
 
   if (tEncodeI32(&encoder, pRsp->statusSeq) < 0) return -1;
+
+  if (tEncodeI64(&encoder, pRsp->ipWhiteVer) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1340,6 +1412,10 @@ int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
   }
 
   if (tDecodeI32(&decoder, &pRsp->statusSeq) < 0) return -1;
+
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI64(&decoder, &pRsp->ipWhiteVer) < 0) return -1;
+  }
   tEndDecode(&decoder);
   tDecoderClear(&decoder);
   return 0;
@@ -1417,6 +1493,15 @@ void tFreeSDropUserReq(SDropUserReq *pReq) {
   FREESQL();
 }
 
+SIpWhiteList *cloneIpWhiteList(SIpWhiteList *pIpWhiteList) {
+  if (pIpWhiteList == NULL) return NULL;
+
+  int32_t       sz = sizeof(SIpWhiteList) + pIpWhiteList->num * sizeof(SIpV4Range);
+  SIpWhiteList *pNew = taosMemoryCalloc(1, sz);
+  memcpy(pNew, pIpWhiteList, sz);
+  return pNew;
+}
+
 int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
@@ -1428,6 +1513,12 @@ int32_t tSerializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pReq
   if (tEncodeI8(&encoder, pReq->enable) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->pass) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1;
+  for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
+    if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1;
+    if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1;
+  }
+
   ENCODESQL();
   tEndEncode(&encoder);
 
@@ -1447,15 +1538,134 @@ int32_t tDeserializeSCreateUserReq(void *buf, int32_t bufLen, SCreateUserReq *pR
   if (tDecodeI8(&decoder, &pReq->enable) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->pass) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1;
+  pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range));
+  if (pReq->pIpRanges == NULL) return -1;
+  for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
+    if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1;
+    if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1;
+  }
+
   DECODESQL();
   tEndDecode(&decoder);
+  tDecoderClear(&decoder);
+  return 0;
+}
 
+int32_t tSerializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
+  // impl later
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->ver) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numOfUser) < 0) return -1;
+  for (int i = 0; i < pReq->numOfUser; i++) {
+    SUpdateUserIpWhite *pUser = &(pReq->pUserIpWhite[i]);
+
+    if (tEncodeI64(&encoder, pUser->ver) < 0) return -1;
+    if (tEncodeCStr(&encoder, pUser->user) < 0) return -1;
+    if (tEncodeI32(&encoder, pUser->numOfRange) < 0) return -1;
+    for (int j = 0; j < pUser->numOfRange; j++) {
+      SIpV4Range *pRange = &pUser->pIpRanges[j];
+      if (tEncodeU32(&encoder, pRange->ip) < 0) return -1;
+      if (tEncodeU32(&encoder, pRange->mask) < 0) return -1;
+    }
+  }
+
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+int32_t tDeserializeSUpdateIpWhite(void *buf, int32_t bufLen, SUpdateIpWhite *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  // impl later
+  if (tDecodeI64(&decoder, &pReq->ver) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->numOfUser) < 0) return -1;
+
+  pReq->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser);
+  for (int i = 0; i < pReq->numOfUser; i++) {
+    SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i];
+    if (tDecodeI64(&decoder, &pUserWhite->ver) < 0) return -1;
+    if (tDecodeCStrTo(&decoder, pUserWhite->user) < 0) return -1;
+    if (tDecodeI32(&decoder, &pUserWhite->numOfRange) < 0) return -1;
+
+    pUserWhite->pIpRanges = taosMemoryCalloc(1, pUserWhite->numOfRange * sizeof(SIpV4Range));
+    for (int j = 0; j < pUserWhite->numOfRange; j++) {
+      SIpV4Range *pRange = &pUserWhite->pIpRanges[j];
+      if (tDecodeU32(&decoder, &pRange->ip) < 0) return -1;
+      if (tDecodeU32(&decoder, &pRange->mask) < 0) return -1;
+    }
+  }
+
+  tEndDecode(&decoder);
+  tDecoderClear(&decoder);
+  return 0;
+}
+void tFreeSUpdateIpWhiteReq(SUpdateIpWhite *pReq) {
+  for (int i = 0; i < pReq->numOfUser; i++) {
+    SUpdateUserIpWhite *pUserWhite = &pReq->pUserIpWhite[i];
+    taosMemoryFree(pUserWhite->pIpRanges);
+  }
+  taosMemoryFree(pReq->pUserIpWhite);
+  // impl later
+  return;
+}
+SUpdateIpWhite *cloneSUpdateIpWhiteReq(SUpdateIpWhite *pReq) {
+  SUpdateIpWhite *pClone = taosMemoryCalloc(1, sizeof(SUpdateIpWhite));
+
+  pClone->numOfUser = pReq->numOfUser;
+  pClone->ver = pReq->ver;
+  pClone->pUserIpWhite = taosMemoryCalloc(1, sizeof(SUpdateUserIpWhite) * pReq->numOfUser);
+
+  for (int i = 0; i < pReq->numOfUser; i++) {
+    SUpdateUserIpWhite *pNew = &pClone->pUserIpWhite[i];
+    SUpdateUserIpWhite *pOld = &pReq->pUserIpWhite[i];
+
+    pNew->ver = pOld->ver;
+    memcpy(pNew->user, pOld->user, strlen(pOld->user));
+    pNew->numOfRange = pOld->numOfRange;
+
+    int32_t sz = pOld->numOfRange * sizeof(SIpV4Range);
+    pNew->pIpRanges = taosMemoryCalloc(1, sz);
+    memcpy(pNew->pIpRanges, pOld->pIpRanges, sz);
+  }
+  return pClone;
+}
+int32_t tSerializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+  if (tStartEncode(&encoder) < 0) return -1;
+
+  if (tEncodeI64(&encoder, pReq->ipWhiteVer) < 0) {
+    return -1;
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeRetrieveIpWhite(void *buf, int32_t bufLen, SRetrieveIpWhiteReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  // impl later
+  if (tDecodeI64(&decoder, &pReq->ipWhiteVer) < 0) return -1;
+  tEndDecode(&decoder);
   tDecoderClear(&decoder);
   return 0;
 }
 
 void tFreeSCreateUserReq(SCreateUserReq *pReq) {
   FREESQL();
+  taosMemoryFreeClear(pReq->pIpRanges);
 }
 
 int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq) {
@@ -1476,6 +1686,11 @@ int32_t tSerializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq)
     if (tEncodeCStr(&encoder, pReq->tabName) < 0) return -1;
   }
   if (tEncodeBinary(&encoder, pReq->tagCond, pReq->tagCondLen) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->numIpRanges) < 0) return -1;
+  for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
+    if (tEncodeU32(&encoder, pReq->pIpRanges[i].ip) < 0) return -1;
+    if (tEncodeU32(&encoder, pReq->pIpRanges[i].mask) < 0) return -1;
+  }
   ENCODESQL();
   tEndEncode(&encoder);
 
@@ -1506,6 +1721,13 @@ int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq
     if (tDecodeBinaryAlloc(&decoder, (void **)&pReq->tagCond, &tagCondLen) < 0) return -1;
     pReq->tagCondLen = tagCondLen;
   }
+  if (tDecodeI32(&decoder, &pReq->numIpRanges) < 0) return -1;
+  pReq->pIpRanges = taosMemoryMalloc(pReq->numIpRanges * sizeof(SIpV4Range));
+  if (pReq->pIpRanges == NULL) return -1;
+  for (int32_t i = 0; i < pReq->numIpRanges; ++i) {
+    if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].ip)) < 0) return -1;
+    if (tDecodeU32(&decoder, &(pReq->pIpRanges[i].mask)) < 0) return -1;
+  }
   DECODESQL();
   tEndDecode(&decoder);
 
@@ -1513,9 +1735,10 @@ int32_t tDeserializeSAlterUserReq(void *buf, int32_t bufLen, SAlterUserReq *pReq
   return 0;
 }
 
-void tFreeSAlterUserReq(SAlterUserReq *pReq) { 
+void tFreeSAlterUserReq(SAlterUserReq *pReq) {
   taosMemoryFreeClear(pReq->tagCond);
-  FREESQL(); 
+  taosMemoryFree(pReq->pIpRanges);
+  FREESQL();
 }
 
 int32_t tSerializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *pReq) {
@@ -1548,7 +1771,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);
@@ -1627,7 +1850,7 @@ int32_t tSerializeSGetUserAuthRspImpl(SEncoder *pEncoder, SGetUserAuthRsp *pRsp)
 
   // since 3.0.7.0
   if (tEncodeI32(pEncoder, pRsp->passVer) < 0) return -1;
-
+  if (tEncodeI64(pEncoder, pRsp->whiteListVer) < 0) return -1;
   return 0;
 }
 
@@ -1663,7 +1886,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;
@@ -1759,6 +1982,11 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
     } else {
       pRsp->passVer = 0;
     }
+    if (!tDecodeIsEnd(pDecoder)) {
+      if (tDecodeI64(pDecoder, &pRsp->whiteListVer) < 0) goto _err;
+    } else {
+      pRsp->whiteListVer = 0;
+    }
   }
   return 0;
 _err:
@@ -1797,6 +2025,73 @@ void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {
   taosHashCleanup(pRsp->useDbs);
 }
 
+int32_t tSerializeSGetUserWhiteListReq(void *buf, int32_t bufLen, SGetUserWhiteListReq *pReq) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSGetUserWhiteListReq(void *buf, int32_t bufLen, SGetUserWhiteListReq *pReq) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSGetUserWhiteListRsp(void* buf, int32_t bufLen, SGetUserWhiteListRsp* pRsp) {
+  SEncoder encoder = {0};
+  tEncoderInit(&encoder, buf, bufLen);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeCStr(&encoder, pRsp->user) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->numWhiteLists) < 0) return -1;
+  for (int i = 0; i < pRsp->numWhiteLists; ++i) {
+    if (tEncodeU32(&encoder, pRsp->pWhiteLists[i].ip) < 0) return -1;
+    if (tEncodeU32(&encoder, pRsp->pWhiteLists[i].mask) < 0) return -1;
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tEncoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSGetUserWhiteListRsp(void* buf, int32_t bufLen, SGetUserWhiteListRsp* pRsp) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pRsp->user) < 0) return -1;
+
+  if (tDecodeI32(&decoder, &pRsp->numWhiteLists) < 0) return -1;
+  pRsp->pWhiteLists = taosMemoryMalloc(pRsp->numWhiteLists * sizeof(SIpV4Range));
+  if (pRsp->pWhiteLists == NULL) return -1;
+  for (int32_t i = 0; i < pRsp->numWhiteLists; ++i) {
+    if (tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].ip)) < 0) return -1;
+    if (tDecodeU32(&decoder, &(pRsp->pWhiteLists[i].mask)) < 0) return -1;
+  }
+
+  tEndDecode(&decoder);
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+void tFreeSGetUserWhiteListRsp(SGetUserWhiteListRsp* pRsp) {
+  taosMemoryFree(pRsp->pWhiteLists);
+}
+
 int32_t tSerializeSCreateDropMQSNodeReq(void *buf, int32_t bufLen, SMCreateQnodeReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
@@ -2490,6 +2785,8 @@ 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;
+
   ENCODESQL();
   tEndEncode(&encoder);
 
@@ -2553,6 +2850,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;
+  }
+
   DECODESQL();
 
   tEndDecode(&decoder);
@@ -2593,6 +2895,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;
   ENCODESQL();
   tEndEncode(&encoder);
 
@@ -2637,6 +2940,11 @@ 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;
+  }
+
   DECODESQL();
   tEndDecode(&decoder);
 
@@ -3280,6 +3588,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);
@@ -3381,6 +3690,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;
 }
@@ -3449,6 +3759,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;
 }
@@ -4325,6 +4639,7 @@ int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
   if (tEncodeCStr(&encoder, pRsp->sDetailVer) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->passVer) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->authVer) < 0) return -1;
+  if (tEncodeI64(&encoder, pRsp->whiteListVer) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -4361,6 +4676,11 @@ int32_t tDeserializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
     pRsp->authVer = 0;
   }
 
+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI64(&decoder, &pRsp->whiteListVer) < 0) return -1;
+  } else {
+    pRsp->whiteListVer = 0;
+  }
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -4498,6 +4818,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);
 
@@ -4587,6 +4908,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);
@@ -4746,6 +5071,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;
@@ -4792,6 +5118,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;
@@ -5036,6 +5367,7 @@ int32_t tSerializeSBalanceVgroupLeaderReq(void *buf, int32_t bufLen, SBalanceVgr
 
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->useless) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
   ENCODESQL();
   tEndEncode(&encoder);
 
@@ -5050,6 +5382,10 @@ int32_t tDeserializeSBalanceVgroupLeaderReq(void *buf, int32_t bufLen, SBalanceV
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->useless) < 0) return -1;
+  if(!tDecodeIsEnd(&decoder)){
+    if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
+  }
+
   DECODESQL();
   tEndDecode(&decoder);
 
@@ -5282,43 +5618,7 @@ int32_t tDeserializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp
   tDecoderClear(&decoder);
   return 0;
 }
-int32_t tEncodeSMqOffset(SEncoder *encoder, const SMqOffset *pOffset) {
-  if (tEncodeI32(encoder, pOffset->vgId) < 0) return -1;
-  if (tEncodeI64(encoder, pOffset->offset) < 0) return -1;
-  if (tEncodeCStr(encoder, pOffset->topicName) < 0) return -1;
-  if (tEncodeCStr(encoder, pOffset->cgroup) < 0) return -1;
-  return encoder->pos;
-}
 
-int32_t tDecodeSMqOffset(SDecoder *decoder, SMqOffset *pOffset) {
-  if (tDecodeI32(decoder, &pOffset->vgId) < 0) return -1;
-  if (tDecodeI64(decoder, &pOffset->offset) < 0) return -1;
-  if (tDecodeCStrTo(decoder, pOffset->topicName) < 0) return -1;
-  if (tDecodeCStrTo(decoder, pOffset->cgroup) < 0) return -1;
-  return 0;
-}
-
-int32_t tEncodeSMqCMCommitOffsetReq(SEncoder *encoder, const SMqCMCommitOffsetReq *pReq) {
-  if (tStartEncode(encoder) < 0) return -1;
-  if (tEncodeI32(encoder, pReq->num) < 0) return -1;
-  for (int32_t i = 0; i < pReq->num; i++) {
-    tEncodeSMqOffset(encoder, &pReq->offsets[i]);
-  }
-  tEndEncode(encoder);
-  return encoder->pos;
-}
-
-int32_t tDecodeSMqCMCommitOffsetReq(SDecoder *decoder, SMqCMCommitOffsetReq *pReq) {
-  if (tStartDecode(decoder) < 0) return -1;
-  if (tDecodeI32(decoder, &pReq->num) < 0) return -1;
-  pReq->offsets = (SMqOffset *)tDecoderMalloc(decoder, sizeof(SMqOffset) * pReq->num);
-  if (pReq->offsets == NULL) return -1;
-  for (int32_t i = 0; i < pReq->num; i++) {
-    tDecodeSMqOffset(decoder, &pReq->offsets[i]);
-  }
-  tEndDecode(decoder);
-  return 0;
-}
 int32_t tSerializeSExplainRsp(void *buf, int32_t bufLen, SExplainRsp *pRsp) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);

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

@@ -23,38 +23,44 @@ extern "C" {
 #endif
 
 typedef struct SDnodeMgmt {
-  SDnodeData         *pData;
-  SMsgCb              msgCb;
-  const char         *path;
-  const char         *name;
-  TdThread            statusThread;
-  TdThread            monitorThread;
-  TdThread            crashReportThread;
-  SSingleWorker       mgmtWorker;
-  ProcessCreateNodeFp processCreateNodeFp;
+  SDnodeData            *pData;
+  SMsgCb                 msgCb;
+  const char            *path;
+  const char            *name;
+  TdThread               statusThread;
+  TdThread               notifyThread;
+  TdThread               monitorThread;
+  TdThread               crashReportThread;
+  SSingleWorker          mgmtWorker;
+  ProcessCreateNodeFp    processCreateNodeFp;
   ProcessAlterNodeTypeFp processAlterNodeTypeFp;
-  ProcessDropNodeFp   processDropNodeFp;
-  SendMonitorReportFp sendMonitorReportFp;
-  GetVnodeLoadsFp     getVnodeLoadsFp;
-  GetMnodeLoadsFp     getMnodeLoadsFp;
-  GetQnodeLoadsFp     getQnodeLoadsFp;
-  int32_t             statusSeq;
+  ProcessDropNodeFp      processDropNodeFp;
+  SendMonitorReportFp    sendMonitorReportFp;
+  GetVnodeLoadsFp        getVnodeLoadsFp;
+  GetVnodeLoadsFp        getVnodeLoadsLiteFp;
+  GetMnodeLoadsFp        getMnodeLoadsFp;
+  GetQnodeLoadsFp        getQnodeLoadsFp;
+  int32_t                statusSeq;
 } 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

@@ -30,7 +30,36 @@ static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
     taosThreadRwlockUnlock(&pMgmt->pData->lock);
   }
 }
+static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) {
+  dDebug("ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver);
+  if (pMgmt->pData->ipWhiteVer == ver) {
+    if (ver == 0) {
+      dDebug("disable ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver);
+      rpcSetIpWhite(pMgmt->msgCb.serverRpc, NULL);
+      // pMgmt->ipWhiteVer = ver;
+    }
+    return;
+  }
+  int64_t oldVer = pMgmt->pData->ipWhiteVer;
+  // pMgmt->ipWhiteVer = ver;
 
+  SRetrieveIpWhiteReq req = {.ipWhiteVer = oldVer};
+  int32_t             contLen = tSerializeRetrieveIpWhite(NULL, 0, &req);
+  void               *pHead = rpcMallocCont(contLen);
+  tSerializeRetrieveIpWhite(pHead, contLen, &req);
+
+  SRpcMsg rpcMsg = {.pCont = pHead,
+                    .contLen = contLen,
+                    .msgType = TDMT_MND_RETRIEVE_IP_WHITE,
+                    .info.ahandle = (void *)0x9527,
+                    .info.refId = 0,
+                    .info.noResp = 0};
+  SEpSet  epset = {0};
+
+  dmGetMnodeEpSet(pMgmt->pData, &epset);
+
+  rpcSendRequest(pMgmt->msgCb.clientRpc, &epset, &rpcMsg, NULL);
+}
 static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
   const STraceId *trace = &pRsp->info.traceId;
   dGTrace("status rsp received from mnode, statusSeq:%d code:0x%x", pMgmt->statusSeq, pRsp->code);
@@ -55,6 +84,7 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
         dmUpdateDnodeCfg(pMgmt, &statusRsp.dnodeCfg);
         dmUpdateEps(pMgmt->pData, statusRsp.pDnodeEps);
       }
+      dmMayShouldUpdateIpWhiteList(pMgmt, statusRsp.ipWhiteVer);
     }
     tFreeSStatusRsp(&statusRsp);
   }
@@ -91,6 +121,7 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   req.clusterCfg.statusInterval = tsStatusInterval;
   req.clusterCfg.checkTime = 0;
   req.clusterCfg.ttlChangeOnWrite = tsTtlChangeOnWrite;
+  req.clusterCfg.enableWhiteList = tsEnableWhiteList ? 1 : 0;
   char timestr[32] = "1970-01-01 00:00:00.00";
   (void)taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
   memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
@@ -110,6 +141,7 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
 
   pMgmt->statusSeq++;
   req.statusSeq = pMgmt->statusSeq;
+  req.ipWhiteVer = pMgmt->pData->ipWhiteVer;
 
   int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
   void   *pHead = rpcMallocCont(contLen);
@@ -138,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;
@@ -363,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)
+  if (dmStartNotifyThread(pMgmt) != 0) {
+    return -1;
+  }
+#endif
   if (dmStartMonitorThread(pMgmt) != 0) {
     return -1;
   }
@@ -33,6 +39,9 @@ static void dmStopMgmt(SDnodeMgmt *pMgmt) {
   pMgmt->pData->stopped = true;
   dmStopMonitorThread(pMgmt);
   dmStopStatusThread(pMgmt);
+#if defined(TD_ENTERPRISE)
+  dmStopNotifyThread(pMgmt);
+#endif
   dmStopCrashReportThread(pMgmt);
 }
 
@@ -52,9 +61,11 @@ 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;
 
+  // pMgmt->pData->ipWhiteVer = 0;
   if (dmStartWorker(pMgmt) != 0) {
     return -1;
   }

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

@@ -164,6 +164,9 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_MND_PAUSE_STREAM, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_RESUME_STREAM, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
 
+
+  if (dmSetMgmtHandle(pArray, TDMT_MND_RETRIEVE_IP_WHITE, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GET_USER_WHITELIST, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_GET_INDEX, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_GET_TABLE_INDEX, mmPutMsgToReadQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_MND_TMQ_CREATE_TOPIC, mmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
@@ -178,6 +181,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);