fix:conflict from 3.0

README.md

@@ -14,6 +14,12 @@
 [![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)
+<br />
+[![Twitter Follow](https://img.shields.io/twitter/follow/tdenginedb?label=TDengine&style=social)](https://twitter.com/tdenginedb)
+[![YouTube Channel](https://img.shields.io/badge/Subscribe_@tdengine--white?logo=youtube&style=social)](https://www.youtube.com/@tdengine)
+[![Discord Community](https://img.shields.io/badge/Join_Discord--white?logo=discord&style=social)](https://discord.com/invite/VZdSuUg4pS)
+[![LinkedIn](https://img.shields.io/badge/Follow_LinkedIn--white?logo=linkedin&style=social)](https://www.linkedin.com/company/tdengine)
+[![StackOverflow](https://img.shields.io/badge/Ask_StackOverflow--white?logo=stackoverflow&style=social&logoColor=orange)](https://stackoverflow.com/questions/tagged/tdengine)
 
 English | [简体中文](README-CN.md) | [TDengine Cloud](https://cloud.tdengine.com) | [Learn more about TSDB](https://tdengine.com/tsdb/)
 

cmake/cmake.platform

@@ -37,6 +37,21 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin
             SET(TD_LINUX_32 TRUE)
         ENDIF ()
 
+        EXECUTE_PROCESS(COMMAND chmod 777  ${CMAKE_CURRENT_LIST_DIR}/../packaging/tools/get_os.sh)
+	EXECUTE_PROCESS(COMMAND readlink /bin/sh OUTPUT_VARIABLE SHELL_LINK)
+	MESSAGE(STATUS "The shell is: " ${SHELL_LINK})
+	
+        IF (${SHELL_LINK} MATCHES "dash")
+	    EXECUTE_PROCESS(COMMAND  ${CMAKE_CURRENT_LIST_DIR}/../packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
+	ELSE ()
+	    EXECUTE_PROCESS(COMMAND sh  ${CMAKE_CURRENT_LIST_DIR}/../packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
+	ENDIF ()    
+	MESSAGE(STATUS "The current OS is " ${TD_OS_INFO})
+	IF (${TD_OS_INFO} MATCHES "Alpine")
+	    SET(TD_ALPINE TRUE)
+            ADD_DEFINITIONS("-D_ALPINE")
+	ENDIF ()
+
     ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 
         SET(TD_DARWIN TRUE)

cmake/cmake.version

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

cmake/taosadapter_CMakeLists.txt.in

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

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 6a2d9fc
+        GIT_TAG 22627d7
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

cmake/taosws_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosws-rs
 ExternalProject_Add(taosws-rs
         GIT_REPOSITORY https://github.com/taosdata/taos-connector-rust.git
-        GIT_TAG f406d51
+        GIT_TAG main
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosws-rs"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/en/07-develop/03-insert-data/_py_kafka.mdx

@@ -53,8 +53,69 @@ for p in ps:
 
 In addition to python's built-in multithreading and multiprocessing library, we can also use the third-party library gunicorn.
 
-### Examples
+### examples
+
+<details>
+<summary>kafka_example_perform</summary>
+
+`kafka_example_perform` is the entry point of the examples.
+
+```py
+{{#include docs/examples/python/kafka_example_perform.py}}
+```
+</details>
+
+<details>
+<summary>kafka_example_common</summary>
+
+`kafka_example_common` is the common code of the examples.
 
 ```py
-{{#include docs/examples/python/kafka_example.py}}
+{{#include docs/examples/python/kafka_example_common.py}}
 ```
+</details>
+
+<details>
+<summary>kafka_example_producer</summary>
+
+`kafka_example_producer` is `producer`, which is responsible for generating test data and sending it to kafka.
+
+```py
+{{#include docs/examples/python/kafka_example_producer.py}}
+```
+</details>
+
+<details>
+<summary>kafka_example_consumer</summary>
+
+`kafka_example_consumer` is `consumer`，which is responsible for consuming data from kafka and writing it to TDengine.
+
+```py
+{{#include docs/examples/python/kafka_example_consumer.py}}
+```
+</details>
+
+### execute Python examples
+
+<details>
+    <summary>execute Python examples</summary>
+
+    1. install and start up `kafka`
+    2. install python3 and pip
+    3. install `taospy` by pip
+    4. install `kafka-python` by pip
+    5. execute this example
+
+    The entry point of this example is `kafka_example_perform.py`. For more information about usage, please use `--help` command.
+
+    ```
+    python3 kafka_example_perform.py --help
+    ```
+
+    For example, the following command is creating 100 sub-table and inserting 20000 data for each table and the kafka max poll is 100 and 1 thread and 1 process per thread.
+
+    ```
+    python3 kafka_example_perform.py -table-count=100 -table-items=20000 -max-poll=100 -threads=1 -processes=1
+    ```
+
+</details>

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

@@ -13,6 +13,7 @@ SELECT [DISTINCT] select_list
     from_clause
     [WHERE condition]
     [partition_by_clause]
+    [interp_clause]
     [window_clause]
     [group_by_clause]
     [order_by_clasue]
@@ -53,8 +54,11 @@ window_clause: {
   | STATE_WINDOW(col)
   | INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [WATERMARK(watermark_val)] [FILL(fill_mod_and_val)]
 
+interp_clause:
+    RANGE(ts_val, ts_val), EVERY(every_val), FILL(fill_mod_and_val)
+
 partition_by_clause:
-    PARTITION BY expr [, expr] ... 
+    PARTITION BY expr [, expr] ...
 
 group_by_clause:
     GROUP BY expr [, expr] ... HAVING condition

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

@@ -873,9 +873,9 @@ INTERP(expr)
 - `INTERP` is used to get the value that matches the specified time slice from a column. If no such value exists an interpolation value will be returned based on `FILL` parameter.
 - The input data of `INTERP` is the value of the specified column and a `where` clause can be used to filter the original data. If no `where` condition is specified then all original data is the input.
 - `INTERP` must be used along with `RANGE`, `EVERY`, `FILL` keywords.
-- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1<=timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified.
-- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY`. Starting from timestamp1, one interpolation is performed for every time interval specified `EVERY` parameter. The parameter `EVERY` must be an integer, with no quotes, with a time unit of: b(nanosecond), u(microsecond), a(millisecond)), s(second), m(minute), h(hour), d(day), or w(week). For example, `EVERY(500a)` will interpolate every 500 milliseconds.
-- Interpolation is performed based on `FILL` parameter.
+- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1 <= timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified.
+- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY(time_unit)`. Starting from timestamp1, one interpolation is performed for every time interval specified `time_unit` parameter. The parameter `time_unit` must be an integer, with no quotes, with a time unit of: a(millisecond)), s(second), m(minute), h(hour), d(day), or w(week). For example, `EVERY(500a)` will interpolate every 500 milliseconds.
+- Interpolation is performed based on `FILL` parameter. For more information about FILL clause, see [FILL Clause](../distinguished/#fill-clause).
 - `INTERP` can only be used to interpolate in single timeline. So it must be used with `partition by tbname` when it's used on a STable.
 - Pseudocolumn `_irowts` can be used along with `INTERP` to return the timestamps associated with interpolation points(support after version 3.0.1.4).
 - Pseudocolumn `_isfilled` can be used along with `INTERP` to indicate whether the results are original records or data points generated by interpolation algorithm(support after version 3.0.2.3).

docs/en/14-reference/07-tdinsight/index.md

@@ -326,11 +326,12 @@ Currently, only the number of logins per minute is reported.
 
 Support monitoring taosAdapter request statistics and status details. Includes.
 
-1. **http_request_inflight**: number of real-time requests.
-2. **http_request_total**: number of total requests.
-3. **http_request_fail**: number of failed requets.
-4. **CPU Used**: CPU usage of taosAdapter.
-5. **Memory Used**: Memory usage of taosAdapter.
+1. **Http Request Total**: number of total requests.
+2. **Http Request Fail**: number of failed requests.
+3. **CPU Used**: CPU usage of taosAdapter.
+4. **Memory Used**: Memory usage of taosAdapter.
+5. **Http Request Inflight**: number of real-time requests.
+6. **Http Status Code**: taosAdapter http status code.
 
 ## Upgrade
 

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

@@ -156,13 +156,13 @@ You can setup a zero-configuration stack for TDengine + Grafana by [docker-compo
 
     services:
       tdengine:
-        image: tdengine/tdengine:2.6.0.2
+        image: tdengine/tdengine:3.0.2.4
         environment:
           TAOS_FQDN: tdengine
         volumes:
           - tdengine-data:/var/lib/taos/
       grafana:
-        image: grafana/grafana:8.5.6
+        image: grafana/grafana:9.3.6
         volumes:
           - ./tdengine.yml/:/etc/grafana/provisioning/tdengine.yml
           - grafana-data:/var/lib/grafana
@@ -197,11 +197,18 @@ As shown above, select the `TDengine` data source in the `Query` and enter the c
 - INPUT SQL: Enter the desired query (the results being two columns and multiple rows), such as `select _wstart, avg(mem_system) from log.dnodes_info where ts >= $from and ts < $to interval($interval)`. In this statement, $from, $to, and $interval are variables that Grafana replaces with the query time range and interval. In addition to the built-in variables, custom template variables are also supported.
 - ALIAS BY: This allows you to set the current query alias.
 - GENERATE SQL: Clicking this button will automatically replace the corresponding variables and generate the final executed statement.
+- Group by column name(s): `group by` or `partition by` columns name split by comma. By setting `Group by column name(s)`, it can show multi-dimension data if Sql is `group by` or `partition by`. Such as, it can show data by `dnode_ep` if sql is  `select _wstart as ts, avg(mem_system), dnode_ep from log.dnodes_info where ts>=$from and ts<=$to partition by dnode_ep interval($interval)` and `Group by column name(s)` is `dnode_ep`.
+- Format to: format legend for `group by` or `partition by`. Such as it can display series data by `dnode_ep` if sql is `select _wstart as ts, avg(mem_system), dnode_ep from log.dnodes_info where ts>=$from and ts<=$to partition by dnode_ep interval($interval)` and `Group by column name(s)` is `dnode_ep` and `Format to` is `mem_system_{{dnode_ep}}`.
 
 Follow the default prompt to query the average system memory usage for the specified interval on the server where the current TDengine deployment is located as follows.
 
 ![TDengine Database TDinsight plugin create dashboard 2](./grafana/create_dashboard2.webp)
 
+查询每台 TDengine 服务器指定间隔系统内存平均使用量如下.
+The example to query the average system memory usage for the specified interval on each server as follows.
+
+![TDengine Database TDinsight plugin create dashboard 2](./grafana/create_dashboard3.webp)
+
 > For more information on how to use Grafana to create the appropriate monitoring interface and for more details on using Grafana, refer to the official Grafana [documentation](https://grafana.com/docs/).
 
 ### Importing the Dashboard

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

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

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

@@ -10,6 +10,10 @@ For other historical version installers, please visit [here](https://www.taosdat
 
 import Release from "/components/ReleaseV3";
 
+## 2.4.3
+
+<Release type="tools" version="2.4.3" />
+
 ## 2.4.2
 
 <Release type="tools" version="2.4.2" />

docs/examples/python/kafka_example_common.py

+#! encoding = utf-8
+import taos
+
+LOCATIONS = ['California.SanFrancisco', 'California.LosAngles', 'California.SanDiego', 'California.SanJose',
+             'California.PaloAlto', 'California.Campbell', 'California.MountainView', 'California.Sunnyvale',
+             'California.SantaClara', 'California.Cupertino']
+
+CREATE_DATABASE_SQL = 'create database if not exists {} keep 365 duration 10 buffer 16 wal_level 1'
+USE_DATABASE_SQL = 'use {}'
+DROP_TABLE_SQL = 'drop table if exists meters'
+DROP_DATABASE_SQL = 'drop database if exists {}'
+CREATE_STABLE_SQL = 'create stable meters (ts timestamp, current float, voltage int, phase float) tags ' \
+                    '(location binary(64), groupId int)'
+CREATE_TABLE_SQL = 'create table if not exists {} using meters tags (\'{}\', {})'
+
+
+def create_database_and_tables(host, port, user, password, db, table_count):
+    tags_tables = _init_tags_table_names(table_count=table_count)
+    conn = taos.connect(host=host, port=port, user=user, password=password)
+
+    conn.execute(DROP_DATABASE_SQL.format(db))
+    conn.execute(CREATE_DATABASE_SQL.format(db))
+    conn.execute(USE_DATABASE_SQL.format(db))
+    conn.execute(DROP_TABLE_SQL)
+    conn.execute(CREATE_STABLE_SQL)
+    for tags in tags_tables:
+        location, group_id = _get_location_and_group(tags)
+        tables = tags_tables[tags]
+        for table_name in tables:
+            conn.execute(CREATE_TABLE_SQL.format(table_name, location, group_id))
+    conn.close()
+
+
+def clean(host, port, user, password, db):
+    conn = taos.connect(host=host, port=port, user=user, password=password)
+    conn.execute(DROP_DATABASE_SQL.format(db))
+    conn.close()
+
+
+def _init_tags_table_names(table_count):
+    tags_table_names = {}
+    group_id = 0
+    for i in range(table_count):
+        table_name = 'd{}'.format(i)
+        location_idx = i % len(LOCATIONS)
+        location = LOCATIONS[location_idx]
+        if location_idx == 0:
+            group_id += 1
+            if group_id > 10:
+                group_id -= 10
+        key = _tag_table_mapping_key(location=location, group_id=group_id)
+        if key not in tags_table_names:
+            tags_table_names[key] = []
+        tags_table_names[key].append(table_name)
+
+    return tags_table_names
+
+
+def _tag_table_mapping_key(location, group_id):
+    return '{}_{}'.format(location, group_id)
+
+
+def _get_location_and_group(key):
+    fields = key.split('_')
+    return fields[0], fields[1]

docs/examples/python/kafka_example.py → docs/examples/python/kafka_example_consumer.py

 #! encoding = utf-8
 import json
+import logging
 import time
+from concurrent.futures import ThreadPoolExecutor, Future
 from json import JSONDecodeError
 from typing import Callable
-import logging
-from concurrent.futures import ThreadPoolExecutor, Future
 
 import taos
 from kafka import KafkaConsumer
 from kafka.consumer.fetcher import ConsumerRecord
 
+import kafka_example_common as common
+
 
 class Consumer(object):
     DEFAULT_CONFIGS = {
-        'kafka_brokers': 'localhost:9092',
-        'kafka_topic': 'python_kafka',
+        'kafka_brokers': 'localhost:9092',  # kafka broker
+        'kafka_topic': 'tdengine_kafka_practices',
         'kafka_group_id': 'taos',
-        'taos_host': 'localhost',
-        'taos_user': 'root',
-        'taos_password': 'taosdata',
-        'taos_database': 'power',
-        'taos_port': 6030,
-        'timezone': None,
-        'clean_after_testing': False,
-        'bath_consume': True,
-        'batch_size': 1000,
-        'async_model': True,
-        'workers': 10,
+        'taos_host': 'localhost',  # TDengine host
+        'taos_port': 6030,  # TDengine port
+        'taos_user': 'root',  # TDengine user name
+        'taos_password': 'taosdata',  # TDengine password
+        'taos_database': 'power',  # TDengine database
+        'message_type': 'json',  # message format, 'json' or 'line'
+        'clean_after_testing': False,  # if drop database after testing
+        'max_poll': 1000,  # poll size for batch mode
+        'workers': 10,  # thread count for multi-threading
         'testing': False
     }
 
-    LOCATIONS = ['California.SanFrancisco', 'California.LosAngles', 'California.SanDiego', 'California.SanJose',
-                 'California.PaloAlto', 'California.Campbell', 'California.MountainView', 'California.Sunnyvale',
-                 'California.SantaClara', 'California.Cupertino']
-
-    CREATE_DATABASE_SQL = 'create database if not exists {} keep 365 duration 10 buffer 16 wal_level 1'
-    USE_DATABASE_SQL = 'use {}'
-    DROP_TABLE_SQL = 'drop table if exists meters'
-    DROP_DATABASE_SQL = 'drop database if exists {}'
-    CREATE_STABLE_SQL = 'create stable meters (ts timestamp, current float, voltage int, phase float) ' \
-                        'tags (location binary(64), groupId int)'
-    CREATE_TABLE_SQL = 'create table if not exists {} using meters tags (\'{}\', {})'
     INSERT_SQL_HEADER = "insert into "
-    INSERT_PART_SQL = 'power.{} values (\'{}\', {}, {}, {})'
+    INSERT_PART_SQL = '{} values (\'{}\', {}, {}, {})'
 
     def __init__(self, **configs):
-        self.config: dict = self.DEFAULT_CONFIGS
+        self.config = self.DEFAULT_CONFIGS
         self.config.update(configs)
+
+        self.consumer = None
         if not self.config.get('testing'):
             self.consumer = KafkaConsumer(
-                self.config.get('kafka_topic'),  # topic
+                self.config.get('kafka_topic'),
                 bootstrap_servers=self.config.get('kafka_brokers'),
                 group_id=self.config.get('kafka_group_id'),
             )
-        self.taos = taos.connect(
+
+        self.conns = taos.connect(
             host=self.config.get('taos_host'),
+            port=self.config.get('taos_port'),
             user=self.config.get('taos_user'),
             password=self.config.get('taos_password'),
-            port=self.config.get('taos_port'),
-            timezone=self.config.get('timezone'),
+            db=self.config.get('taos_database'),
         )
-        if self.config.get('async_model'):
+        if self.config.get('workers') > 1:
             self.pool = ThreadPoolExecutor(max_workers=self.config.get('workers'))
             self.tasks = []
         # tags and table mapping # key: {location}_{groupId} value:
-        self.tag_table_mapping = {}
-        i = 0
-        for location in self.LOCATIONS:
-            for j in range(1, 11):
-                table_name = 'd{}'.format(i)
-                self._cache_table(location=location, group_id=j, table_name=table_name)
-                i += 1
-
-    def init_env(self):
-        # create database and table
-        self.taos.execute(self.DROP_DATABASE_SQL.format(self.config.get('taos_database')))
-        self.taos.execute(self.CREATE_DATABASE_SQL.format(self.config.get('taos_database')))
-        self.taos.execute(self.USE_DATABASE_SQL.format(self.config.get('taos_database')))
-        self.taos.execute(self.DROP_TABLE_SQL)
-        self.taos.execute(self.CREATE_STABLE_SQL)
-        for tags, table_name in self.tag_table_mapping.items():
-            location, group_id = _get_location_and_group(tags)
-            self.taos.execute(self.CREATE_TABLE_SQL.format(table_name, location, group_id))
 
     def consume(self):
-        logging.warning('## start consumer topic-[%s]', self.config.get('kafka_topic'))
+        """
+
+        consume data from kafka and deal. Base on `message_type`, `bath_consume`, `insert_by_table`,
+        there are several deal function.
+        :return:
+        """
+        self.conns.execute(common.USE_DATABASE_SQL.format(self.config.get('taos_database')))
         try:
-            if self.config.get('bath_consume'):
-                self._run_batch(self._to_taos_batch)
-            else:
-                self._run(self._to_taos)
+            if self.config.get('message_type') == 'line':  # line
+                self._run(self._line_to_taos)
+            if self.config.get('message_type') == 'json':  # json
+                self._run(self._json_to_taos)
         except KeyboardInterrupt:
             logging.warning("## caught keyboard interrupt, stopping")
         finally:
             self.stop()
 
     def stop(self):
+        """
+
+        stop consuming
+        :return:
+        """
         # close consumer
         if self.consumer is not None:
             self.consumer.commit()
             self.consumer.close()
 
         # multi thread
-        if self.config.get('async_model'):
+        if self.config.get('workers') > 1:
+            if self.pool is not None:
+                self.pool.shutdown()
             for task in self.tasks:
                 while not task.done():
-                    pass
-                if self.pool is not None:
-                    self.pool.shutdown()
+                    time.sleep(0.01)
 
         # clean data
         if self.config.get('clean_after_testing'):
-            self.taos.execute(self.DROP_TABLE_SQL)
-            self.taos.execute(self.DROP_DATABASE_SQL.format(self.config.get('taos_database')))
+            self.conns.execute(common.DROP_TABLE_SQL)
+            self.conns.execute(common.DROP_DATABASE_SQL.format(self.config.get('taos_database')))
         # close taos
-        if self.taos is not None:
-            self.taos.close()
+        if self.conns is not None:
+            self.conns.close()
 
     def _run(self, f):
-        for message in self.consumer:
-            if self.config.get('async_model'):
-                self.pool.submit(f(message))
-            else:
-                f(message)
+        """
 
-    def _run_batch(self, f):
+        run in batch consuming mode
+        :param f:
+        :return:
+        """
+        i = 0  # just for test.
         while True:
-            messages = self.consumer.poll(timeout_ms=500, max_records=self.config.get('batch_size'))
+            messages = self.consumer.poll(timeout_ms=100, max_records=self.config.get('max_poll'))
             if messages:
-                if self.config.get('async_model'):
+                if self.config.get('workers') > 1:
                     self.pool.submit(f, messages.values())
                 else:
                     f(list(messages.values()))
             if not messages:
+                i += 1  # just for test.
                 time.sleep(0.1)
+            if i > 3:  # just for test.
+                logging.warning('## test over.')  # just for test.
+                return  # just for test.
+
+    def _json_to_taos(self, messages):
+        """
+
+        convert a batch of json data to sql, and insert into TDengine
+        :param messages:
+        :return:
+        """
+        sql = self._build_sql_from_json(messages=messages)
+        self.conns.execute(sql=sql)
+
+    def _line_to_taos(self, messages):
+        """
+
+        convert a batch of lines data to sql, and insert into TDengine
+        :param messages:
+        :return:
+        """
+        lines = []
+        for partition_messages in messages:
+            for message in partition_messages:
+                lines.append(message.value.decode())
+        sql = self.INSERT_SQL_HEADER + ' '.join(lines)
+        self.conns.execute(sql=sql)
 
-    def _to_taos(self, message: ConsumerRecord) -> bool:
-        sql = self.INSERT_SQL_HEADER + self._build_sql(message.value)
-        if len(sql) == 0:  # decode error, skip
-            return True
-        logging.info('## insert sql %s', sql)
-        return self.taos.execute(sql=sql) == 1
-
-    def _to_taos_batch(self, messages):
-        sql = self._build_sql_batch(messages=messages)
-        if len(sql) == 0:  # decode error, skip
-            return
-        self.taos.execute(sql=sql)
-
-    def _build_sql(self, msg_value: str) -> str:
+    def _build_single_sql_from_json(self, msg_value):
         try:
             data = json.loads(msg_value)
         except JSONDecodeError as e:
             logging.error('## decode message [%s] error ', msg_value, e)
             return ''
-        location = data.get('location')
-        group_id = data.get('groupId')
+        # location = data.get('location')
+        # group_id = data.get('groupId')
         ts = data.get('ts')
         current = data.get('current')
         voltage = data.get('voltage')
         phase = data.get('phase')
+        table_name = data.get('table_name')
 
-        table_name = self._get_table_name(location=location, group_id=group_id)
         return self.INSERT_PART_SQL.format(table_name, ts, current, voltage, phase)
 
-    def _build_sql_batch(self, messages) -> str:
+    def _build_sql_from_json(self, messages):
         sql_list = []
         for partition_messages in messages:
             for message in partition_messages:
-                sql_list.append(self._build_sql(message.value))
-
+                sql_list.append(self._build_single_sql_from_json(message.value))
         return self.INSERT_SQL_HEADER + ' '.join(sql_list)
 
-    def _cache_table(self, location: str, group_id: int, table_name: str):
-        self.tag_table_mapping[_tag_table_mapping_key(location=location, group_id=group_id)] = table_name
-
-    def _get_table_name(self, location: str, group_id: int) -> str:
-        return self.tag_table_mapping.get(_tag_table_mapping_key(location=location, group_id=group_id))
-
-
-def _tag_table_mapping_key(location: str, group_id: int):
-    return '{}_{}'.format(location, group_id)
-
 
-def _get_location_and_group(key: str) -> (str, int):
-    fields = key.split('_')
-    return fields[0], fields[1]
-
-
-def test_to_taos(consumer: Consumer):
-    msg = {
-        'location': 'California.SanFrancisco',
-        'groupId': 1,
-        'ts': '2022-12-06 15:13:38.643',
-        'current': 3.41,
-        'voltage': 105,
-        'phase': 0.02027,
-    }
-    record = ConsumerRecord(checksum=None, headers=None, offset=1, key=None, value=json.dumps(msg), partition=1,
-                            topic='test', serialized_key_size=None, serialized_header_size=None,
-                            serialized_value_size=None, timestamp=time.time(), timestamp_type=None)
-    assert consumer._to_taos(message=record)
-
-
-def test_to_taos_batch(consumer: Consumer):
+def test_json_to_taos(consumer: Consumer):
     records = [
         [
             ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
-                           value=json.dumps({'location': 'California.SanFrancisco',
-                                             'groupId': 1,
+                           value=json.dumps({'table_name': 'd0',
                                              'ts': '2022-12-06 15:13:38.643',
                                              'current': 3.41,
                                              'voltage': 105,
@@ -216,8 +184,7 @@ def test_to_taos_batch(consumer: Consumer):
                            partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
                            serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
             ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
-                           value=json.dumps({'location': 'California.LosAngles',
-                                             'groupId': 2,
+                           value=json.dumps({'table_name': 'd1',
                                              'ts': '2022-12-06 15:13:39.643',
                                              'current': 3.41,
                                              'voltage': 102,
@@ -227,15 +194,38 @@ def test_to_taos_batch(consumer: Consumer):
         ]
     ]
 
-    consumer._to_taos_batch(messages=records)
+    consumer._json_to_taos(messages=records)
+
+
+def test_line_to_taos(consumer: Consumer):
+    records = [
+        [
+            ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
+                           value="d0 values('2023-01-01 00:00:00.001', 3.49, 109, 0.02737)".encode('utf-8'),
+                           partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+            ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
+                           value="d1 values('2023-01-01 00:00:00.002', 6.19, 112, 0.09171)".encode('utf-8'),
+                           partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+        ]
+    ]
+    consumer._line_to_taos(messages=records)
+
+
+def consume(kafka_brokers, kafka_topic, kafka_group_id, taos_host, taos_port, taos_user,
+            taos_password, taos_database, message_type, max_poll, workers):
+    c = Consumer(kafka_brokers=kafka_brokers, kafka_topic=kafka_topic, kafka_group_id=kafka_group_id,
+                 taos_host=taos_host, taos_port=taos_port, taos_user=taos_user, taos_password=taos_password,
+                 taos_database=taos_database, message_type=message_type, max_poll=max_poll, workers=workers)
+    c.consume()
 
 
 if __name__ == '__main__':
-    consumer = Consumer(async_model=True, testing=True)
-    # init env
-    consumer.init_env()
-    # consumer.consume()
-    # test build sql
-    # test build sql batch
-    test_to_taos(consumer)
-    test_to_taos_batch(consumer)
+    consumer = Consumer(testing=True)
+    common.create_database_and_tables(host='localhost', port=6030, user='root', password='taosdata', db='py_kafka_test',
+                                      table_count=10)
+    consumer.conns.execute(common.USE_DATABASE_SQL.format('py_kafka_test'))
+    test_json_to_taos(consumer)
+    test_line_to_taos(consumer)
+    common.clean(host='localhost', port=6030, user='root', password='taosdata', db='py_kafka_test')

docs/examples/python/kafka_example_perform.py

+#! encoding=utf-8
+
+import argparse
+import logging
+import multiprocessing
+import time
+from multiprocessing import pool
+
+import kafka_example_common as common
+import kafka_example_consumer as consumer
+import kafka_example_producer as producer
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-kafka-broker', type=str, default='localhost:9092',
+                        help='kafka borker host. default is `localhost:9200`')
+    parser.add_argument('-kafka-topic', type=str, default='tdengine-kafka-practices',
+                        help='kafka topic. default is `tdengine-kafka-practices`')
+    parser.add_argument('-kafka-group', type=str, default='kafka_practices',
+                        help='kafka consumer group. default is `kafka_practices`')
+    parser.add_argument('-taos-host', type=str, default='localhost',
+                        help='TDengine host. default is `localhost`')
+    parser.add_argument('-taos-port', type=int, default=6030, help='TDengine port. default is 6030')
+    parser.add_argument('-taos-user', type=str, default='root', help='TDengine username, default is `root`')
+    parser.add_argument('-taos-password', type=str, default='taosdata', help='TDengine password, default is `taosdata`')
+    parser.add_argument('-taos-db', type=str, default='tdengine_kafka_practices',
+                        help='TDengine db name, default is `tdengine_kafka_practices`')
+    parser.add_argument('-table-count', type=int, default=100, help='TDengine sub-table count, default is 100')
+    parser.add_argument('-table-items', type=int, default=1000, help='items in per sub-tables, default is 1000')
+    parser.add_argument('-message-type', type=str, default='line',
+                        help='kafka message type. `line` or `json`. default is `line`')
+    parser.add_argument('-max-poll', type=int, default=1000, help='max poll for kafka consumer')
+    parser.add_argument('-threads', type=int, default=10, help='thread count for deal message')
+    parser.add_argument('-processes', type=int, default=1, help='process count')
+
+    args = parser.parse_args()
+    total = args.table_count * args.table_items
+
+    logging.warning("## start to prepare testing data...")
+    prepare_data_start = time.time()
+    producer.produce_total(100, args.kafka_broker, args.kafka_topic, args.message_type, total, args.table_count)
+    prepare_data_end = time.time()
+    logging.warning("## prepare testing data finished! spend-[%s]", prepare_data_end - prepare_data_start)
+
+    logging.warning("## start to create database and tables ...")
+    create_db_start = time.time()
+    # create database and table
+    common.create_database_and_tables(host=args.taos_host, port=args.taos_port, user=args.taos_user,
+                                      password=args.taos_password, db=args.taos_db, table_count=args.table_count)
+    create_db_end = time.time()
+    logging.warning("## create database and tables finished! spend [%s]", create_db_end - create_db_start)
+
+    processes = args.processes
+
+    logging.warning("## start to consume data and insert into TDengine...")
+    consume_start = time.time()
+    if processes > 1:  # multiprocess
+        multiprocessing.set_start_method("spawn")
+        pool = pool.Pool(processes)
+
+        consume_start = time.time()
+        for _ in range(processes):
+            pool.apply_async(func=consumer.consume, args=(
+                args.kafka_broker, args.kafka_topic, args.kafka_group, args.taos_host, args.taos_port, args.taos_user,
+                args.taos_password, args.taos_db, args.message_type, args.max_poll, args.threads))
+        pool.close()
+        pool.join()
+    else:
+        consume_start = time.time()
+        consumer.consume(kafka_brokers=args.kafka_broker, kafka_topic=args.kafka_topic, kafka_group_id=args.kafka_group,
+                         taos_host=args.taos_host, taos_port=args.taos_port, taos_user=args.taos_user,
+                         taos_password=args.taos_password, taos_database=args.taos_db, message_type=args.message_type,
+                         max_poll=args.max_poll, workers=args.threads)
+    consume_end = time.time()
+    logging.warning("## consume data and insert into TDengine over! spend-[%s]", consume_end - consume_start)
+
+    # print report
+    logging.warning(
+        "\n#######################\n"
+        "     Prepare data      \n"
+        "#######################\n"
+        "# data_type # %s  \n"
+        "# total     # %s  \n"
+        "# spend     # %s s\n"
+        "#######################\n"
+        "     Create database   \n"
+        "#######################\n"
+        "# stable    # 1  \n"
+        "# sub-table # 100  \n"
+        "# spend     # %s s \n"
+        "#######################\n"
+        "        Consume        \n"
+        "#######################\n"
+        "# data_type   # %s  \n"
+        "# threads     # %s  \n"
+        "# processes   # %s  \n"
+        "# total_count # %s  \n"
+        "# spend       # %s s\n"
+        "# per_second  # %s  \n"
+        "#######################\n",
+        args.message_type, total, prepare_data_end - prepare_data_start, create_db_end - create_db_start,
+        args.message_type, args.threads, processes, total, consume_end - consume_start,
+                                  total / (consume_end - consume_start))

docs/examples/python/kafka_example_producer.py

+#! encoding = utf-8
+import json
+import random
+import threading
+from concurrent.futures import ThreadPoolExecutor, Future
+from datetime import datetime
+
+from kafka import KafkaProducer
+
+locations = ['California.SanFrancisco', 'California.LosAngles', 'California.SanDiego', 'California.SanJose',
+             'California.PaloAlto', 'California.Campbell', 'California.MountainView', 'California.Sunnyvale',
+             'California.SantaClara', 'California.Cupertino']
+
+producers: list[KafkaProducer] = []
+
+lock = threading.Lock()
+start = 1640966400
+
+
+def produce_total(workers, broker, topic, message_type, total, table_count):
+    if len(producers) == 0:
+        lock.acquire()
+        if len(producers) == 0:
+            _init_kafka_producers(broker=broker, count=10)
+        lock.release()
+    pool = ThreadPoolExecutor(max_workers=workers)
+    futures = []
+    for _ in range(0, workers):
+        futures.append(pool.submit(_produce_total, topic, message_type, int(total / workers), table_count))
+    pool.shutdown()
+    for f in futures:
+        f.result()
+    _close_kafka_producers()
+
+
+def _produce_total(topic, message_type, total, table_count):
+    producer = _get_kafka_producer()
+    for _ in range(total):
+        message = _get_fake_date(message_type=message_type, table_count=table_count)
+        producer.send(topic=topic, value=message.encode(encoding='utf-8'))
+
+
+def _init_kafka_producers(broker, count):
+    for _ in range(count):
+        p = KafkaProducer(bootstrap_servers=broker, batch_size=64 * 1024, linger_ms=300, acks=0)
+        producers.append(p)
+
+
+def _close_kafka_producers():
+    for p in producers:
+        p.close()
+
+
+def _get_kafka_producer():
+    return producers[random.randint(0, len(producers) - 1)]
+
+
+def _get_fake_date(table_count, message_type='json'):
+    if message_type == 'json':
+        return _get_json_message(table_count=table_count)
+    if message_type == 'line':
+        return _get_line_message(table_count=table_count)
+    return ''
+
+
+def _get_json_message(table_count):
+    return json.dumps({
+        'ts': _get_timestamp(),
+        'current': random.randint(0, 1000) / 100,
+        'voltage': random.randint(105, 115),
+        'phase': random.randint(0, 32000) / 100000,
+        'location': random.choice(locations),
+        'groupId': random.randint(1, 10),
+        'table_name': _random_table_name(table_count)
+    })
+
+
+def _get_line_message(table_count):
+    return "{} values('{}', {}, {}, {})".format(
+        _random_table_name(table_count),  # table
+        _get_timestamp(),  # ts
+        random.randint(0, 1000) / 100,  # current
+        random.randint(105, 115),  # voltage
+        random.randint(0, 32000) / 100000,  # phase
+    )
+
+
+def _random_table_name(table_count):
+    return 'd{}'.format(random.randint(0, table_count - 1))
+
+
+def _get_timestamp():
+    global start
+    lock.acquire(blocking=True)
+    start += 0.001
+    lock.release()
+    return datetime.fromtimestamp(start).strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]

docs/zh/07-develop/03-insert-data/_py_kafka.mdx

@@ -55,6 +55,70 @@ for p in ps:
 
 ### 完整示例
 
+<details>
+<summary>kafka_example_perform</summary>
+
+`kafka_example_perform` 是示例程序的入口
+
+```py
+{{#include docs/examples/python/kafka_example_perform.py}}
+```
+</details>
+
+<details>
+<summary>kafka_example_common</summary>
+
+`kafka_example_common` 是示例程序的公共代码
+
 ```py
-{{#include docs/examples/python/kafka_example.py}}
+{{#include docs/examples/python/kafka_example_common.py}}
 ```
+</details>
+
+<details>
+<summary>kafka_example_producer</summary>
+
+`kafka_example_producer` 是示例程序的 producer 代码，负责生成并发送测试数据到 kafka
+
+```py
+{{#include docs/examples/python/kafka_example_producer.py}}
+```
+</details>
+
+<details>
+<summary>kafka_example_consumer</summary>
+
+`kafka_example_consumer` 是示例程序的 consumer 代码，负责从 kafka 消费数据，并写入到 TDengine
+
+```py
+{{#include docs/examples/python/kafka_example_consumer.py}}
+```
+</details>
+
+### 执行步骤
+
+<details>
+    <summary>执行 Python 示例程序</summary>
+
+    1. 安装并启动 kafka
+
+    2. python 环境准备
+        - 安装 python3
+        - 安装 taospy
+        - 安装 kafka-python
+
+    3. 执行示例程序
+
+    程序的执行入口是 `kafka_example_perform.py`，获取程序完整的执行参数，请执行 help 命令。
+
+    ```
+    python3 kafka_example_perform.py --help
+    ```
+
+    以下为创建 100 个子表，每个子表 20000 条数据，kafka max poll 为 100，一个进程，每个进程一个处理线程的程序执行命令
+
+    ```
+    python3 kafka_example_perform.py -table-count=100 -table-items=20000 -max-poll=100 -threads=1 -processes=1
+    ```
+
+</details>

docs/zh/12-taos-sql/03-table.md

@@ -57,7 +57,7 @@ table_option: {
 3. MAX_DELAY：用于控制推送计算结果的最大延迟，默认值为 interval 的值(但不能超过最大值)，最小单位毫秒，范围为 1 毫秒到 15 分钟，多个以逗号分隔。注：不建议 MAX_DELAY 设置太小，否则会过于频繁的推送结果，影响存储和查询性能，如无特殊需求，取默认值即可。只可用于超级表，且只有当数据库使用了 RETENTIONS 参数时，才可以使用此表参数。
 4. ROLLUP：Rollup 指定的聚合函数，提供基于多层级的降采样聚合结果。只可用于超级表。只有当数据库使用了 RETENTIONS 参数时，才可以使用此表参数。作用于超级表除 TS 列外的其它所有列，但是只能定义一个聚合函数。 聚合函数支持 avg, sum, min, max, last, first。
 5. SMA：Small Materialized Aggregates，提供基于数据块的自定义预计算功能。预计算类型包括 MAX、MIN 和 SUM。可用于超级表/普通表。
-6. TTL：Time to Live，是用户用来指定表的生命周期的参数。如果创建表时指定了这个参数，当该表的存在时间超过 TTL 指定的时间后，TDengine 自动删除该表。这个 TTL 的时间只是一个大概时间，系统不保证到了时间一定会将其删除，而只保证存在这样一个机制且最终一定会删除。TTL 单位是天，默认为 0，表示不限制，到期时间为表创建时间加上 TTL 时间。
+6. TTL：Time to Live，是用户用来指定表的生命周期的参数。如果创建表时指定了这个参数，当该表的存在时间超过 TTL 指定的时间后，TDengine 自动删除该表。这个 TTL 的时间只是一个大概时间，系统不保证到了时间一定会将其删除，而只保证存在这样一个机制且最终一定会删除。TTL 单位是天，默认为 0，表示不限制，到期时间为表创建时间加上 TTL 时间。TTL 与数据库 KEEP 参数没有关联，如果 KEEP 比 TTL 小，在表被删除之前数据也可能已经被删除。
 
 ## 创建子表
 

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

@@ -13,6 +13,7 @@ SELECT [DISTINCT] select_list
     from_clause
     [WHERE condition]
     [partition_by_clause]
+    [interp_clause]
     [window_clause]
     [group_by_clause]
     [order_by_clasue]
@@ -53,8 +54,11 @@ window_clause: {
   | STATE_WINDOW(col)
   | INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [WATERMARK(watermark_val)] [FILL(fill_mod_and_val)]
 
+interp_clause:
+    RANGE(ts_val, ts_val), EVERY(every_val), FILL(fill_mod_and_val)
+
 partition_by_clause:
-    PARTITION BY expr [, expr] ... 
+    PARTITION BY expr [, expr] ...
 
 group_by_clause:
     GROUP BY expr [, expr] ... HAVING condition

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

@@ -875,9 +875,9 @@ INTERP(expr)
 - INTERP 用于在指定时间断面获取指定列的记录值，如果该时间断面不存在符合条件的行数据，那么会根据 FILL 参数的设定进行插值。
 - INTERP 的输入数据为指定列的数据，可以通过条件语句（where 子句）来对原始列数据进行过滤，如果没有指定过滤条件则输入为全部数据。
 - INTERP 需要同时与 RANGE，EVERY 和 FILL 关键字一起使用。
-- INTERP 的输出时间范围根据 RANGE(timestamp1,timestamp2)字段来指定，需满足 timestamp1<=timestamp2。其中 timestamp1（必选值）为输出时间范围的起始值，即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录，timestamp2（必选值）为输出时间范围的结束值，即输出的最后一条记录的 timestamp 不能大于 timestamp2。
-- INTERP 根据 EVERY 字段来确定输出时间范围内的结果条数，即从 timestamp1 开始每隔固定长度的时间（EVERY 值）进行插值。
-- INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值。
+- INTERP 的输出时间范围根据 RANGE(timestamp1,timestamp2)字段来指定，需满足 timestamp1 <= timestamp2。其中 timestamp1（必选值）为输出时间范围的起始值，即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录，timestamp2（必选值）为输出时间范围的结束值，即输出的最后一条记录的 timestamp 不能大于 timestamp2。
+- INTERP 根据 EVERY(time_unit) 字段来确定输出时间范围内的结果条数，即从 timestamp1 开始每隔固定长度的时间（time_unit 值）进行插值，time_unit 可取值时间单位：1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)，1w(周)。例如 EVERY(500a) 将对于指定数据每500毫秒间隔进行一次插值.
+- INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值。关于 FILL 子句如何使用请参考 [FILL 子句](../distinguished/#fill-子句)
 - INTERP 只能在一个时间序列内进行插值，因此当作用于超级表时必须跟 partition by tbname 一起使用。
 - INTERP 可以与伪列 _irowts 一起使用，返回插值点所对应的时间戳(3.0.1.4版本以后支持)。
 - INTERP 可以与伪列 _isfilled 一起使用，显示返回结果是否为原始记录或插值算法产生的数据(3.0.2.3版本以后支持)。

docs/zh/14-reference/07-tdinsight/index.mdx

@@ -345,11 +345,12 @@ TDinsight 仪表盘旨在提供 TDengine 相关资源的使用情况和状态，
 
 支持监控 taosAdapter 请求统计和状态详情。包括：
 
-1. **http_request_inflight**: 即时处理请求数
-2. **http_request_total**: 请求总数。
-3. **http_request_fail**: 请求总数。
-4. **CPU Used**: taosAdapter CPU 使用情况。
-5. **Memory Used**: taosAdapter 内存使用情况。
+1. **Http Request Total**: 请求总数。
+2. **Http Request Fail**: 请求总数。
+3. **CPU Used**: taosAdapter CPU 使用情况。
+4. **Memory Used**: taosAdapter 内存使用情况。
+5. **Http Request Inflight**: 即时处理请求数。
+6. **Http Status Code**: taosAdapter http 状态码。
 
 ## 升级
 

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

@@ -77,7 +77,7 @@ sudo -u grafana grafana-cli plugins install tdengine-datasource
 或者从 [GitHub](https://github.com/taosdata/grafanaplugin/releases/tag/latest) 或 [Grafana](https://grafana.com/grafana/plugins/tdengine-datasource/?tab=installation) 下载 .zip 文件到本地并解压到 Grafana 插件目录。命令行下载示例如下：
 
 ```bash
-GF_VERSION=3.2.7
+GF_VERSION=3.2.9
 # from GitHub
 wget https://github.com/taosdata/grafanaplugin/releases/download/v$GF_VERSION/tdengine-datasource-$GF_VERSION.zip
 # from Grafana
@@ -156,13 +156,13 @@ docker run -d \
 
     services:
       tdengine:
-        image: tdengine/tdengine:2.6.0.2
+        image: tdengine/tdengine:3.0.2.4
         environment:
           TAOS_FQDN: tdengine
         volumes:
           - tdengine-data:/var/lib/taos/
       grafana:
-        image: grafana/grafana:8.5.6
+        image: grafana/grafana:9.3.6
         volumes:
           - ./tdengine.yml/:/etc/grafana/provisioning/tdengine.yml
           - grafana-data:/var/lib/grafana
@@ -197,11 +197,17 @@ docker run -d \
 - INPUT SQL：输入要查询的语句（该 SQL 语句的结果集应为两列多行），例如：`select _wstart, avg(mem_system) from log.dnodes_info where ts >= $from and ts < $to interval($interval)` ，其中，from、to 和 interval 为 TDengine 插件的内置变量，表示从 Grafana 插件面板获取的查询范围和时间间隔。除了内置变量外，`也支持可以使用自定义模板变量`。
 - ALIAS BY：可设置当前查询别名。
 - GENERATE SQL： 点击该按钮会自动替换相应变量，并生成最终执行的语句。
+- Group by column name(s)： **半角**逗号分隔的 `group by` 或 `partition by` 列名。如果是 `group by` or `partition by` 查询语句，设置 `Group by` 列，可以展示多维数据。例如：INPUT SQL 为 `select _wstart as ts, avg(mem_system), dnode_ep from log.dnodes_info where ts>=$from and ts<=$to partition by dnode_ep interval($interval)`，设置 Group by 列名为 `dnode_ep`，可以按 `dnode_ep` 展示数据。
+- Format to： Group by 或 Partition by 场景下多维数据 legend 格式化格式。例如上述 INPUT SQL，将 Format to 设置为 `mem_system_{{dnode_ep}}`，展示的 legend 名字为格式化的列名。
 
 按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：
 
 ![TDengine Database Grafana plugin create dashboard](./create_dashboard2.webp)
 
+查询每台 TDengine 服务器指定间隔系统内存平均使用量如下：
+
+![TDengine Database Grafana plugin create dashboard](./create_dashboard3.webp)
+
 > 关于如何使用 Grafana 创建相应的监测界面以及更多有关使用 Grafana 的信息，请参考 Grafana 官方的[文档](https://grafana.com/docs/)。
 
 ### 导入 Dashboard

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

@@ -243,8 +243,8 @@ sudo launchctl load -w /Library/LaunchDaemons/limit.maxfiles.plist
 ```
 launchctl limit maxfiles
 ```
-### 19 建库时提示Out of dnode
-该提示是创建db的vnode数量不够了，需要的vnode不能超过了dnode中vnode的上限。因为系统默认是一个dnode中有cpu核数两倍的vnode，也可以通过配置文件中的参数supportVnodes控制。
-正常调大taos.cfg种这个supportVnodes参数即可。
+### 20 建库时提示 Out of dnodes
+该提示是创建 db 的 vnode 数量不够了，需要的 vnode 不能超过了 dnode 中 vnode 的上限。因为系统默认是一个 dnode 中有 CPU 核数两倍的 vnode，也可以通过配置文件中的参数 supportVnodes 控制。
+正常调大 taos.cfg 中 supportVnodes 参数即可。
 
 

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

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

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

@@ -10,6 +10,10 @@ taosTools 各版本安装包下载链接如下：
 
 import Release from "/components/ReleaseV3";
 
+## 2.4.3
+
+<Release type="tools" version="2.4.3" />
+
 ## 2.4.2
 
 <Release type="tools" version="2.4.2" />

examples/JDBC/readme.md

@@ -10,4 +10,4 @@
 |  6   |      taosdemo      | This is an internal tool for testing Our JDBC-JNI, JDBC-RESTful, RESTful interfaces |
 
 
-more detail: https://docs.taosdata.com/reference/connector/java/
+more detail: https://docs.taosdata.com/connector/java/
\ No newline at end of file

include/common/tdataformat.h

@@ -109,7 +109,7 @@ void    tRowGet(SRow *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
 void    tRowDestroy(SRow *pRow);
 void    tRowSort(SArray *aRowP);
 int32_t tRowMerge(SArray *aRowP, STSchema *pTSchema, int8_t flag);
-int32_t tRowAppendToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData);
+int32_t tRowUpsertColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData, int32_t flag);
 
 // SRowIter ================================
 int32_t  tRowIterOpen(SRow *pRow, STSchema *pTSchema, SRowIter **ppIter);
@@ -137,6 +137,7 @@ void    tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn)
 void    tColDataClear(SColData *pColData);
 void    tColDataDeepClear(SColData *pColData);
 int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal);
+int32_t tColDataUpdateValue(SColData *pColData, SColVal *pColVal, bool forward);
 void    tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal);
 uint8_t tColDataGetBitValue(const SColData *pColData, int32_t iVal);
 int32_t tColDataCopy(SColData *pColDataFrom, SColData *pColData, xMallocFn xMalloc, void *arg);
@@ -200,6 +201,9 @@ struct SColData {
   int16_t  cid;
   int8_t   type;
   int8_t   smaOn;
+  int32_t  numOfNone;   // # of none
+  int32_t  numOfNull;   // # of null
+  int32_t  numOfValue;  // # of vale
   int32_t  nVal;
   uint8_t  flag;
   uint8_t *pBitMap;

include/common/tmsg.h

@@ -58,7 +58,7 @@ extern int32_t tMsgDict[];
 #define TMSG_INFO(TYPE)                                                                                                \
   ((TYPE) < TDMT_DND_MAX_MSG || (TYPE) < TDMT_MND_MAX_MSG || (TYPE) < TDMT_VND_MAX_MSG || (TYPE) < TDMT_SCH_MAX_MSG || \
    (TYPE) < TDMT_STREAM_MAX_MSG || (TYPE) < TDMT_MON_MAX_MSG || (TYPE) < TDMT_SYNC_MAX_MSG) ||                         \
-          (TYPE) < TDMT_VND_STREAM_MSG || (TYPE) < TDMT_VND_TMQ_MSG                                                    \
+          (TYPE) < TDMT_VND_STREAM_MSG || (TYPE) < TDMT_VND_TMQ_MSG || (TYPE) < TDMT_VND_TMQ_MAX_MSG                   \
       ? tMsgInfo[tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE)]                                                   \
       : 0
 
@@ -145,12 +145,14 @@ typedef enum _mgmt_table {
 #define TSDB_ALTER_TABLE_UPDATE_OPTIONS      9
 #define TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME  10
 
-#define TSDB_FILL_NONE      0
-#define TSDB_FILL_NULL      1
-#define TSDB_FILL_SET_VALUE 2
-#define TSDB_FILL_LINEAR    3
-#define TSDB_FILL_PREV      4
-#define TSDB_FILL_NEXT      5
+#define TSDB_FILL_NONE        0
+#define TSDB_FILL_NULL        1
+#define TSDB_FILL_NULL_F      2
+#define TSDB_FILL_SET_VALUE   3
+#define TSDB_FILL_SET_VALUE_F 4
+#define TSDB_FILL_LINEAR      5
+#define TSDB_FILL_PREV        6
+#define TSDB_FILL_NEXT        7
 
 #define TSDB_ALTER_USER_PASSWD                 0x1
 #define TSDB_ALTER_USER_SUPERUSER              0x2
@@ -1241,7 +1243,7 @@ int32_t tDeserializeSDropVnodeReq(void* buf, int32_t bufLen, SDropVnodeReq* pReq
 typedef struct {
   int64_t dbUid;
   char    db[TSDB_DB_FNAME_LEN];
-  int64_t reserved[8];
+  int64_t compactStartTime;
 } SCompactVnodeReq;
 
 int32_t tSerializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* pReq);
@@ -1280,8 +1282,8 @@ int32_t tSerializeSAlterVnodeReplicaReq(void* buf, int32_t bufLen, SAlterVnodeRe
 int32_t tDeserializeSAlterVnodeReplicaReq(void* buf, int32_t bufLen, SAlterVnodeReplicaReq* pReq);
 
 typedef struct {
-  int32_t  vgId;
-  int8_t   disable;
+  int32_t vgId;
+  int8_t  disable;
 } SDisableVnodeWriteReq;
 
 int32_t tSerializeSDisableVnodeWriteReq(void* buf, int32_t bufLen, SDisableVnodeWriteReq* pReq);
@@ -1781,6 +1783,7 @@ typedef struct {
 #define STREAM_FILL_HISTORY_ON        1
 #define STREAM_FILL_HISTORY_OFF       0
 #define STREAM_DEFAULT_FILL_HISTORY   STREAM_FILL_HISTORY_OFF
+#define STREAM_DEFAULT_IGNORE_UPDATE  0
 #define STREAM_CREATE_STABLE_TRUE     1
 #define STREAM_CREATE_STABLE_FALSE    0
 
@@ -1809,7 +1812,8 @@ typedef struct {
   // 3.0.2.3
   int8_t   createStb;
   uint64_t targetStbUid;
-  SArray*  fillNullCols; // array of SColLocation
+  SArray*  fillNullCols;  // array of SColLocation
+  int8_t   igUpdate;
 } SCMCreateStreamReq;
 
 typedef struct {

include/libs/cache/cache.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_CACHE_H_
-#define _TD_CACHE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_CACHE_H_*/
\ No newline at end of file

include/libs/function/functionMgt.h

@@ -219,6 +219,7 @@ bool fmIsKeepOrderFunc(int32_t funcId);
 bool fmIsCumulativeFunc(int32_t funcId);
 bool fmIsInterpPseudoColumnFunc(int32_t funcId);
 bool fmIsGroupKeyFunc(int32_t funcId);
+bool fmIsBlockDistFunc(int32_t funcId);
 
 void getLastCacheDataType(SDataType* pType);
 

include/libs/nodes/cmdnodes.h

@@ -124,6 +124,11 @@ typedef struct STrimDatabaseStmt {
   int32_t   maxSpeed;
 } STrimDatabaseStmt;
 
+typedef struct SCompactDatabaseStmt {
+  ENodeType type;
+  char      dbName[TSDB_DB_NAME_LEN];
+} SCompactDatabaseStmt;
+
 typedef struct STableOptions {
   ENodeType  type;
   bool       commentNull;
@@ -395,6 +400,7 @@ typedef struct SStreamOptions {
   SNode*    pDeleteMark;
   int8_t    fillHistory;
   int8_t    ignoreExpired;
+  int8_t    ignoreUpdate;
 } SStreamOptions;
 
 typedef struct SCreateStreamStmt {

include/libs/nodes/nodes.h

@@ -155,7 +155,7 @@ typedef enum ENodeType {
   QUERY_NODE_EXPLAIN_STMT,
   QUERY_NODE_DESCRIBE_STMT,
   QUERY_NODE_RESET_QUERY_CACHE_STMT,
-  QUERY_NODE_COMPACT_STMT,
+  QUERY_NODE_COMPACT_DATABASE_STMT,
   QUERY_NODE_CREATE_FUNCTION_STMT,
   QUERY_NODE_DROP_FUNCTION_STMT,
   QUERY_NODE_CREATE_STREAM_STMT,

include/libs/nodes/plannodes.h

@@ -93,6 +93,7 @@ typedef struct SScanLogicNode {
   int64_t       watermark;
   int64_t       deleteMark;
   int8_t        igExpired;
+  int8_t        igCheckUpdate;
   SArray*       pSmaIndexes;
   SNodeList*    pGroupTags;
   bool          groupSort;
@@ -224,6 +225,7 @@ typedef struct SWindowLogicNode {
   int64_t          watermark;
   int64_t          deleteMark;
   int8_t           igExpired;
+  int8_t           igCheckUpdate;
   EWindowAlgorithm windowAlgo;
   EOrder           inputTsOrder;
   EOrder           outputTsOrder;
@@ -364,6 +366,7 @@ typedef struct STableScanPhysiNode {
   int64_t        watermark;
   int8_t         igExpired;
   bool           assignBlockUid;
+  int8_t         igCheckUpdate;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -562,6 +565,7 @@ typedef struct SQueryInserterNode {
   char          tableName[TSDB_TABLE_NAME_LEN];
   int32_t       vgId;
   SEpSet        epSet;
+  bool          explain;
 } SQueryInserterNode;
 
 typedef struct SDataDeleterNode {

include/libs/nodes/querynodes.h

@@ -233,8 +233,10 @@ typedef struct SEventWindowNode {
 typedef enum EFillMode {
   FILL_MODE_NONE = 1,
   FILL_MODE_VALUE,
+  FILL_MODE_VALUE_F,
   FILL_MODE_PREV,
   FILL_MODE_NULL,
+  FILL_MODE_NULL_F,
   FILL_MODE_LINEAR,
   FILL_MODE_NEXT
 } EFillMode;

include/libs/planner/planner.h

@@ -36,6 +36,7 @@ typedef struct SPlanContext {
   int64_t     watermark;
   int64_t     deleteMark;
   int8_t      igExpired;
+  int8_t      igCheckUpdate;
   char*       pMsg;
   int32_t     msgLen;
   const char* pUser;

include/libs/wal/wal.h

@@ -191,6 +191,7 @@ int32_t walApplyVer(SWal *, int64_t ver);
 // read
 SWalReader *walOpenReader(SWal *, SWalFilterCond *pCond);
 void        walCloseReader(SWalReader *pRead);
+void        walReadReset(SWalReader *pReader);
 int32_t     walReadVer(SWalReader *pRead, int64_t ver);
 int32_t     walReadSeekVer(SWalReader *pRead, int64_t ver);
 int32_t     walNextValidMsg(SWalReader *pRead);

include/os/os.h

@@ -27,7 +27,11 @@ extern "C" {
 
 #if !defined(WINDOWS)
 #include <dirent.h>
+
+#if !defined(_ALPINE)
 #include <execinfo.h>
+#endif
+
 #include <libgen.h>
 #include <sched.h>
 #include <unistd.h>

include/os/osFile.h

@@ -110,6 +110,8 @@ bool taosValidFile(TdFilePtr pFile);
 
 int32_t taosGetErrorFile(TdFilePtr pFile);
 
+int32_t taosCompressFile(char *srcFileName, char *destFileName);
+
 #ifdef __cplusplus
 }
 #endif

include/os/osSysinfo.h

@@ -60,6 +60,13 @@ void    taosSetCoreDump(bool enable);
 
 #endif  // WINDOWS
 
+#if defined(_ALPINE)
+
+#define _UTSNAME_LENGTH         65
+#define _UTSNAME_MACHINE_LENGTH _UTSNAME_LENGTH
+
+#endif
+
 typedef struct {
   char sysname[_UTSNAME_MACHINE_LENGTH];
   char nodename[_UTSNAME_MACHINE_LENGTH];

include/os/osThread.h

@@ -22,7 +22,7 @@
 extern "C" {
 #endif
 
-#ifndef WINDOWS
+#if !defined(WINDOWS) && !defined(_ALPINE)
 #ifndef __USE_XOPEN2K
 #define TD_USE_SPINLOCK_AS_MUTEX
 typedef pthread_mutex_t pthread_spinlock_t;
@@ -100,7 +100,11 @@ typedef pthread_key_t        TdThreadKey;
 #define pthread_condattr_init          PTHREAD_CONDATTR_INIT_FUNC_TAOS_FORBID
 #define pthread_condattr_setpshared    PTHREAD_CONDATTR_SETPSHARED_FUNC_TAOS_FORBID
 #define pthread_detach                 PTHREAD_DETACH_FUNC_TAOS_FORBID
+
+#if !defined(_ALPINE)
 #define pthread_equal                  PTHREAD_EQUAL_FUNC_TAOS_FORBID
+#endif
+
 #define pthread_exit                   PTHREAD_EXIT_FUNC_TAOS_FORBID
 #define pthread_getschedparam          PTHREAD_GETSCHEDPARAM_FUNC_TAOS_FORBID
 #define pthread_getspecific            PTHREAD_GETSPECIFIC_FUNC_TAOS_FORBID

include/util/taoserror.h

@@ -111,6 +111,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_NOT_FOUND                     TAOS_DEF_ERROR_CODE(0, 0x012A)
 #define TSDB_CODE_NO_DISKSPACE                  TAOS_DEF_ERROR_CODE(0, 0x012B)
 #define TSDB_CODE_TIMEOUT_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x012C)
+#define TSDB_CODE_MSG_ENCODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x012D)
 
 #define TSDB_CODE_APP_IS_STARTING               TAOS_DEF_ERROR_CODE(0, 0x0130) //
 #define TSDB_CODE_APP_IS_STOPPING               TAOS_DEF_ERROR_CODE(0, 0x0131) //
@@ -357,6 +358,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_STREAM_MUST_BE_DELETED    TAOS_DEF_ERROR_CODE(0, 0x03F3)
 #define TSDB_CODE_MND_STREAM_TASK_DROPPED       TAOS_DEF_ERROR_CODE(0, 0x03F4)
 #define TSDB_CODE_MND_MULTI_REPLICA_SOURCE_DB   TAOS_DEF_ERROR_CODE(0, 0x03F5)
+#define TSDB_CODE_MND_TOO_MANY_STREAMS          TAOS_DEF_ERROR_CODE(0, 0x03F6)
 
 // mnode-sma
 #define TSDB_CODE_MND_SMA_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x0480)

include/util/trbtree.h

@@ -33,9 +33,12 @@ typedef int32_t (*tRBTreeCmprFn)(const SRBTreeNode *, const SRBTreeNode *);
 #define tRBTreeMax(T) ((T)->max == ((T)->NIL) ? NULL : (T)->max)
 
 void         tRBTreeCreate(SRBTree *pTree, tRBTreeCmprFn cmprFn);
+void         tRBTreeClear(SRBTree *pTree);
 SRBTreeNode *tRBTreePut(SRBTree *pTree, SRBTreeNode *z);
 void         tRBTreeDrop(SRBTree *pTree, SRBTreeNode *z);
 SRBTreeNode *tRBTreeDropByKey(SRBTree *pTree, void *pKey);
+SRBTreeNode *tRBTreeDropMin(SRBTree *pTree);
+SRBTreeNode *tRBTreeDropMax(SRBTree *pTree);
 SRBTreeNode *tRBTreeGet(SRBTree *pTree, const SRBTreeNode *pKeyNode);
 
 // SRBTreeIter =============================================

packaging/tools/install.sh

@@ -35,6 +35,20 @@ dumpName="taosdump"
 demoName="taosdemo"
 xname="taosx"
 
+clientName2="taos"
+serverName2="taosd"
+productName2="TDengine"
+emailName2="taosdata.com"
+
+benchmarkName2="${clientName2}Benchmark"
+dumpName2="${clientName2}dump"
+uninstallScript2="rm${clientName2}"
+
+historyFile="${clientName2}_history"
+logDir="/var/log/${clientName2}"
+configDir="/etc/${clientName2}"
+installDir="/usr/local/${clientName}"
+
 data_dir=${dataDir}
 log_dir=${logDir}
 cfg_install_dir=${configDir}
@@ -217,6 +231,13 @@ function install_bin() {
   [ -x ${install_main_dir}/bin/TDinsight.sh ] && ${csudo}ln -s ${install_main_dir}/bin/TDinsight.sh ${bin_link_dir}/TDinsight.sh || :
   [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript} || :
   [ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo}ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
+
+  if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    [ -x ${install_main_dir}/bin/${clientName} ] && ${csudo}ln -s ${install_main_dir}/bin/${clientName} ${bin_link_dir}/${clientName2} || :
+    [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${benchmarkName2} || :
+    [ -x ${install_main_dir}/bin/${dumpName} ] && ${csudo}ln -s ${install_main_dir}/bin/${dumpName} ${bin_link_dir}/${dumpName2} || :
+    [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript2} || :
+  fi
 }
 
 function install_lib() {
@@ -518,7 +539,7 @@ function install_config() {
   local_fqdn_check
 
   echo
-  echo -e -n "${GREEN}Enter FQDN:port (like h1.${emailName}:6030) of an existing ${productName} cluster node to join${NC}"
+  echo -e -n "${GREEN}Enter FQDN:port (like h1.${emailName2}:6030) of an existing ${productName2} cluster node to join${NC}"
   echo
   echo -e -n "${GREEN}OR leave it blank to build one${NC}:"
   read firstEp
@@ -655,6 +676,9 @@ function clean_service_on_systemd() {
   fi
   ${csudo}systemctl disable tarbitratord &>/dev/null || echo &>/dev/null
   ${csudo}rm -f ${tarbitratord_service_config}
+  # if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+  #     ${csudo}rm -f ${service_config_dir}/${serverName2}.service
+  # fi
 }
 
 function install_service_on_systemd() {
@@ -663,6 +687,13 @@ function install_service_on_systemd() {
   [ -f ${script_dir}/cfg/${serverName}.service ] &&
     ${csudo}cp ${script_dir}/cfg/${serverName}.service \
       ${service_config_dir}/ || :
+
+  # if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+  #   [ -f ${script_dir}/cfg/${serverName}.service ] &&
+  #   ${csudo}cp ${script_dir}/cfg/${serverName}.service \
+  #     ${service_config_dir}/${serverName2}.service || :
+  # fi
+
   ${csudo}systemctl daemon-reload
 
   ${csudo}systemctl enable ${serverName}
@@ -793,7 +824,7 @@ function updateProduct() {
   tar -zxf ${tarName}
   install_jemalloc
 
-  echo -e "${GREEN}Start to update ${productName}...${NC}"
+  echo -e "${GREEN}Start to update ${productName2}...${NC}"
   # Stop the service if running
   if ps aux | grep -v grep | grep ${serverName} &>/dev/null; then
     if ((${service_mod} == 0)); then
@@ -830,25 +861,25 @@ function updateProduct() {
     echo
     echo -e "${GREEN_DARK}To configure ${productName} ${NC}: edit ${cfg_install_dir}/${configFile}"
     [ -f ${configDir}/taosadapter.toml ] && [ -f ${installDir}/bin/taosadapter ] && \
-      echo -e "${GREEN_DARK}To configure Taos Adapter ${NC}: edit ${configDir}/taosadapter.toml"
+      echo -e "${GREEN_DARK}To configure Adapter ${NC}: edit ${configDir}/taosadapter.toml"
     if ((${service_mod} == 0)); then
       echo -e "${GREEN_DARK}To start ${productName}     ${NC}: ${csudo}systemctl start ${serverName}${NC}"
       [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \
-        echo -e "${GREEN_DARK}To start Taos Adatper ${NC}: ${csudo}systemctl start taosadapter ${NC}"
+        echo -e "${GREEN_DARK}To start Adatper ${NC}: ${csudo}systemctl start taosadapter ${NC}"
     elif ((${service_mod} == 1)); then
       echo -e "${GREEN_DARK}To start ${productName}     ${NC}: ${csudo}service ${serverName} start${NC}"
       [ -f ${service_config_dir}/taosadapter.service ] && [ -f ${installDir}/bin/taosadapter ] && \
-        echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: ${csudo}service taosadapter start${NC}"
+        echo -e "${GREEN_DARK}To start Adapter ${NC}: ${csudo}service taosadapter start${NC}"
     else
       echo -e "${GREEN_DARK}To start ${productName}     ${NC}: ./${serverName}${NC}"
       [ -f ${installDir}/bin/taosadapter ] && \
-        echo -e "${GREEN_DARK}To start Taos Adapter ${NC}: taosadapter &${NC}"
+        echo -e "${GREEN_DARK}To start ${clientName} Adapter ${NC}: taosadapter &${NC}"
     fi
 
     if [ ${openresty_work} = 'true' ]; then
-      echo -e "${GREEN_DARK}To access ${productName}    ${NC}: use ${GREEN_UNDERLINE}${clientName} -h $serverFqdn${NC} in shell OR from ${GREEN_UNDERLINE}http://127.0.0.1:${web_port}${NC}"
+      echo -e "${GREEN_DARK}To access ${productName2}    ${NC}: 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 ${productName}    ${NC}: use ${GREEN_UNDERLINE}${clientName} -h $serverFqdn${NC} in shell${NC}"
+      echo -e "${GREEN_DARK}To access ${productName2}    ${NC}: use ${GREEN_UNDERLINE}${clientName2} -h $serverFqdn${NC} in shell${NC}"
     fi
 
     if ((${prompt_force} == 1)); then
@@ -856,13 +887,13 @@ function updateProduct() {
       echo -e "${RED}Please run '${serverName} --force-keep-file' at first time for the exist ${productName} $exist_version!${NC}"
     fi
     echo
-    echo -e "\033[44;32;1m${productName} is updated successfully!${NC}"
+    echo -e "\033[44;32;1m${productName2} is updated successfully!${NC}"
   else
     install_bin
     install_config
 
     echo
-    echo -e "\033[44;32;1m${productName} client is updated successfully!${NC}"
+    echo -e "\033[44;32;1m${productName2} client is updated successfully!${NC}"
   fi
 
   rm -rf $(tar -tf ${tarName} | grep -v "^\./$")
@@ -876,7 +907,7 @@ function installProduct() {
   fi
   tar -zxf ${tarName}
 
-  echo -e "${GREEN}Start to install ${productName}...${NC}"
+  echo -e "${GREEN}Start to install ${productName2}...${NC}"
 
   install_main_path
 
@@ -965,7 +996,7 @@ serverFqdn=$(hostname)
 if [ "$verType" == "server" ]; then
   # Check default 2.x data file.
   if [ -x ${data_dir}/dnode/dnodeCfg.json ]; then
-    echo -e "\033[44;31;5mThe default data directory ${data_dir} contains old data of tdengine 2.x, please clear it before installing!\033[0m"
+    echo -e "\033[44;31;5mThe default data directory ${data_dir} contains old data of ${productName2} 2.x, please clear it before installing!\033[0m"
   else
     # Install server and client
     if [ -x ${bin_dir}/${serverName} ]; then

packaging/tools/install_client.sh

@@ -23,6 +23,16 @@ osType=Linux
 pagMode=full
 verMode=edge
 
+clientName2="taos"
+serverName2="taosd"
+productName2="TDengine"
+emailName2="taosdata.com"
+
+benchmarkName2="${clientName2}Benchmark"
+dumpName2="${clientName2}dump"
+demoName2="${clientName2}demo"
+uninstallScript2="rm${clientName2}"
+
 if [ "$osType" != "Darwin" ]; then
     script_dir=$(dirname $(readlink -f "$0"))
     # Dynamic directory
@@ -112,6 +122,15 @@ function install_bin() {
   fi
   [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/${uninstallScript} || :
   [ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo}ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
+
+  if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    #Make link
+    [ -x ${install_main_dir}/bin/${clientName} ] && ${csudo}ln -s ${install_main_dir}/bin/${clientName} ${bin_link_dir}/${clientName2}                 || :
+    if [ "$osType" != "Darwin" ]; then
+        [ -x ${install_main_dir}/bin/taosdemo ] && ${csudo}ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/${demoName2}  || :
+    fi
+    [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/${uninstallScript2} || :
+  fi
 }
 
 function clean_lib() {
@@ -263,9 +282,9 @@ function update_TDengine() {
         exit 1
     fi
     tar -zxf ${tarName}
-    echo -e "${GREEN}Start to update ${productName} client...${NC}"
+    echo -e "${GREEN}Start to update ${productName2} client...${NC}"
     # Stop the client shell if running
-    if ps aux | grep -v grep | grep ${clientName} &> /dev/null; then
+    if ps aux | grep -v grep | grep ${clientName2} &> /dev/null; then
         kill_client
         sleep 1
     fi
@@ -284,7 +303,7 @@ function update_TDengine() {
     install_config
 
     echo
-    echo -e "\033[44;32;1m${productName} client is updated successfully!${NC}"
+    echo -e "\033[44;32;1m${productName2} client is updated successfully!${NC}"
 
     rm -rf $(tar -tf ${tarName})
 }
@@ -296,7 +315,7 @@ function install_TDengine() {
         exit 1
     fi
     tar -zxf ${tarName}
-    echo -e "${GREEN}Start to install ${productName} client...${NC}"
+    echo -e "${GREEN}Start to install ${productName2} client...${NC}"
 
     install_main_path
     install_log
@@ -311,7 +330,7 @@ function install_TDengine() {
     install_config
 
     echo
-    echo -e "\033[44;32;1m${productName} client is installed successfully!${NC}"
+    echo -e "\033[44;32;1m${productName2} client is installed successfully!${NC}"
 
     rm -rf $(tar -tf ${tarName})
 }
@@ -321,7 +340,7 @@ function install_TDengine() {
 # Install or updata client and client
 # if server is already install, don't install client
 if [ -e ${bin_dir}/${serverName} ]; then
-    echo -e "\033[44;32;1mThere are already installed ${productName} server, so don't need install client!${NC}"
+    echo -e "\033[44;32;1mThere are already installed ${productName2} server, so don't need install client!${NC}"
     exit 0
 fi
 

packaging/tools/make_install.bat

@@ -2,12 +2,20 @@
 
 for /F %%a in ('echo prompt $E ^| cmd') do set "ESC=%%a"
 
-goto %1
+if "%1" NEQ "" goto %1
+
 :needAdmin
 
 if exist C:\\TDengine\\data\\dnode\\dnodeCfg.json (
   echo The default data directory C:/TDengine/data contains old data of tdengine 2.x, please clear it before installing!
 )
+
+rem // stop and delete service
+mshta vbscript:createobject("shell.application").shellexecute("%~s0",":stop_delete","","runas",1)(window.close)
+echo This might take a few moment to accomplish deleting service taosd/taosadapter ...
+call :check_svc taosd
+call :check_svc taosadapter
+
 set source_dir=%2
 set source_dir=%source_dir:/=\\%
 set binary_dir=%3
@@ -87,7 +95,6 @@ if %Enterprise% == TRUE (
     
 copy %binary_dir%\\build\\bin\\taosd.exe %target_dir% > nul
 copy %binary_dir%\\build\\bin\\udfd.exe %target_dir% > nul
-
 if exist %binary_dir%\\build\\bin\\taosadapter.exe (
     copy %binary_dir%\\build\\bin\\taosadapter.exe %target_dir% > nul
 )
@@ -107,22 +114,23 @@ goto :eof
 
 :hasAdmin
 
-sc query "taosd" && sc stop taosd && sc delete taosd
-sc query "taosadapter" && sc stop taosadapter && sc delete taosd
+call :stop_delete
+call :check_svc taosd
+call :check_svc taosadapter
 
 copy /y C:\\TDengine\\driver\\taos.dll C:\\Windows\\System32 > nul
 if exist C:\\TDengine\\driver\\taosws.dll (
     copy /y C:\\TDengine\\driver\\taosws.dll C:\\Windows\\System32 > nul
 )
 
-sc query "taosd" >nul || sc create "taosd" binPath= "C:\\TDengine\\taosd.exe --win_service" start= DEMAND
-sc query "taosadapter" >nul || sc create "taosadapter" binPath= "C:\\TDengine\\taosadapter.exe" start= DEMAND
+rem // create services
+sc create "taosd" binPath= "C:\\TDengine\\taosd.exe --win_service" start= DEMAND
+sc create "taosadapter" binPath= "C:\\TDengine\\taosadapter.exe" start= DEMAND
 
 set "env=HKLM\System\CurrentControlSet\Control\Session Manager\Environment"
 for /f "tokens=2*" %%I in ('reg query "%env%" /v Path ^| findstr /i "\<Path\>"') do (
 
-    rem // make addition persistent through reboots
-    reg add "%env%" /f /v Path /t REG_EXPAND_SZ /d "%%J;C:\TDengine"
+    call :append_if_not_exists %%J
 
     rem // apply change to the current process
     for %%a in ("%%J;C:\TDengine") do path %%~a
@@ -132,3 +140,36 @@ rem // use setx to set a temporary throwaway value to trigger a WM_SETTINGCHANGE
 rem // applies change to new console windows without requiring a reboot
 (setx /m foo bar & reg delete "%env%" /f /v foo) >NUL 2>NUL
 
+goto :end
+
+:append_if_not_exists
+set "_origin_paths=%*"
+set "_paths=%*"
+set "_found=0"
+:loop
+for /f "tokens=1* delims=;" %%x in ("%_paths%") do (
+    if "%%x" EQU "C:\TDengine" (
+      set "_found=1"
+    ) else (
+      set "_paths=%%y"
+      goto :loop
+    )
+)
+if "%_found%" == "0" (
+  rem // make addition persistent through reboots
+  reg add "%env%" /f /v Path /t REG_EXPAND_SZ /d "%_origin_paths%;C:\TDengine"
+)
+exit /B 0
+
+:stop_delete
+sc stop taosd
+sc delete taosd
+sc stop taosadapter
+sc delete taosadapter
+exit /B 0
+
+:check_svc
+sc query %1 >nul 2>nul && goto :check_svc %1
+exit /B 0
+
+:end

packaging/tools/make_install.sh

-#!/bin/bash
+#!/bin/sh
 #
 # This file is used to install TAOS time-series database on linux systems. The operating system
 # is required to use systemd to manage services at boot
@@ -340,7 +340,7 @@ function install_lib() {
   #install_avro lib64
 
   if [ "$osType" != "Darwin" ]; then
-    ${csudo}ldconfig
+    ${csudo}ldconfig /etc/ld.so.conf.d
   fi
 }
 

packaging/tools/makeclient.sh

@@ -13,7 +13,13 @@ osType=$5
 verMode=$6
 verType=$7
 pagMode=$8
-dbName=$9
+#comVersion=$9
+dbName=$10
+
+productName2="${11}"
+#serverName2="${12}d"
+clientName2="${12}"
+# cusEmail2=${13}
 
 productName="TDengine"
 clientName="taos"
@@ -38,15 +44,21 @@ release_dir="${top_dir}/release"
 #package_name='linux'
 
 if [ "$verMode" == "cluster" ]; then
-  install_dir="${release_dir}/${productName}-enterprise-client-${version}"
+  install_dir="${release_dir}/${productName2}-enterprise-client-${version}"
 elif [ "$verMode" == "cloud" ]; then
-  install_dir="${release_dir}/${productName}-cloud-client-${version}"
+  install_dir="${release_dir}/${productName2}-cloud-client-${version}"
 else
-  install_dir="${release_dir}/${productName}-client-${version}"
+  install_dir="${release_dir}/${productName2}-client-${version}"
 fi
 
 # Directories and files.
 
+if [ "$verMode" == "cluster" ]; then
+  sed -i 's/verMode=edge/verMode=cluster/g' ${script_dir}/remove_client.sh
+  sed -i "s/clientName2=\"taos\"/clientName2=\"${clientName2}\"/g" ${script_dir}/remove_client.sh
+  sed -i "s/productName2=\"TDengine\"/productName2=\"${productName2}\"/g" ${script_dir}/remove_client.sh
+fi
+
 if [ "$osType" != "Darwin" ]; then
   if [ "$pagMode" == "lite" ]; then
     strip ${build_dir}/bin/${clientName}
@@ -131,22 +143,28 @@ fi
 
 cd ${curr_dir}
 cp ${install_files} ${install_dir}
+cp ${install_dir}/install_client.sh install_client_temp.sh
 if [ "$osType" == "Darwin" ]; then
-  sed 's/osType=Linux/osType=Darwin/g' ${install_dir}/install_client.sh >>install_client_temp.sh
+  sed -i 's/osType=Linux/osType=Darwin/g' install_client_temp.sh
   mv install_client_temp.sh ${install_dir}/install_client.sh
 fi
 
 if [ "$verMode" == "cluster" ]; then
-  sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/install_client.sh >>install_client_temp.sh
+  sed -i 's/verMode=edge/verMode=cluster/g' install_client_temp.sh
+  sed -i "s/serverName2=\"taosd\"/serverName2=\"${serverName2}\"/g" install_client_temp.sh
+  sed -i "s/clientName2=\"taos\"/clientName2=\"${clientName2}\"/g" install_client_temp.sh
+  sed -i "s/productName2=\"TDengine\"/productName2=\"${productName2}\"/g" install_client_temp.sh
+  sed -i "s/emailName2=\"taosdata.com\"/emailName2=\"${cusEmail2}\"/g" install_client_temp.sh
+
   mv install_client_temp.sh ${install_dir}/install_client.sh
 fi
 if [ "$verMode" == "cloud" ]; then
-  sed 's/verMode=edge/verMode=cloud/g' ${install_dir}/install_client.sh >>install_client_temp.sh
+  sed -i 's/verMode=edge/verMode=cloud/g' install_client_temp.sh
   mv install_client_temp.sh ${install_dir}/install_client.sh
 fi
 
 if [ "$pagMode" == "lite" ]; then
-  sed 's/pagMode=full/pagMode=lite/g' ${install_dir}/install_client.sh >>install_client_temp.sh
+  sed -i 's/pagMode=full/pagMode=lite/g' install_client_temp.sh
   mv install_client_temp.sh ${install_dir}/install_client.sh
 fi
 chmod a+x ${install_dir}/install_client.sh

packaging/tools/makepkg.sh

@@ -16,6 +16,10 @@ verType=$7
 pagMode=$8
 versionComp=$9
 dbName=${10}
+productName2="${11}"
+serverName2="${12}d"
+clientName2="${12}"
+cusEmail2="${13}"
 
 script_dir="$(dirname $(readlink -f $0))"
 top_dir="$(readlink -f ${script_dir}/../..)"
@@ -38,11 +42,11 @@ release_dir="${top_dir}/release"
 
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
-  install_dir="${release_dir}/${productName}-enterprise-server-${version}"
+  install_dir="${release_dir}/${productName2}-enterprise-server-${version}"
 elif [ "$verMode" == "cloud" ]; then
-  install_dir="${release_dir}/${productName}-cloud-server-${version}"
+  install_dir="${release_dir}/${productName2}-cloud-server-${version}"
 else
-  install_dir="${release_dir}/${productName}-server-${version}"
+  install_dir="${release_dir}/${productName2}-server-${version}"
 fi
 
 if [ -d ${top_dir}/tools/taos-tools/packaging/deb ]; then
@@ -50,11 +54,11 @@ if [ -d ${top_dir}/tools/taos-tools/packaging/deb ]; then
   [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
 
   taostools_ver=$(git tag |grep -v taos | sort | tail -1)
-  taostools_install_dir="${release_dir}/${clientName}Tools-${taostools_ver}"
+  taostools_install_dir="${release_dir}/${clientName2}Tools-${taostools_ver}"
 
   cd ${curr_dir}
 else
-  taostools_install_dir="${release_dir}/${clientName}Tools-${version}"
+  taostools_install_dir="${release_dir}/${clientName2}Tools-${version}"
 fi
 
 # Directories and files
@@ -225,6 +229,10 @@ fi
 
 if [ "$verMode" == "cluster" ]; then
   sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/bin/remove.sh >>remove_temp.sh
+  sed -i "s/serverName2=\"taosd\"/serverName2=\"${serverName2}\"/g" remove_temp.sh
+  sed -i "s/clientName2=\"taos\"/clientName2=\"${clientName2}\"/g" remove_temp.sh
+  sed -i "s/productName2=\"TDengine\"/productName2=\"${productName2}\"/g" remove_temp.sh
+  sed -i "s/emailName2=\"taosdata.com\"/emailName2=\"${cusEmail2}\"/g" remove_temp.sh
   mv remove_temp.sh ${install_dir}/bin/remove.sh
 fi
 if [ "$verMode" == "cloud" ]; then
@@ -247,16 +255,21 @@ fi
 
 cd ${curr_dir}
 cp ${install_files} ${install_dir}
+cp ${install_dir}/install.sh install_temp.sh
 if [ "$verMode" == "cluster" ]; then
-  sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/install.sh >>install_temp.sh
+  sed -i 's/verMode=edge/verMode=cluster/g' install_temp.sh
+  sed -i "s/serverName2=\"taosd\"/serverName2=\"${serverName2}\"/g" install_temp.sh
+  sed -i "s/clientName2=\"taos\"/clientName2=\"${clientName2}\"/g" install_temp.sh
+  sed -i "s/productName2=\"TDengine\"/productName2=\"${productName2}\"/g" install_temp.sh
+  sed -i "s/emailName2=\"taosdata.com\"/emailName2=\"${cusEmail2}\"/g" install_temp.sh
   mv install_temp.sh ${install_dir}/install.sh
 fi
 if [ "$verMode" == "cloud" ]; then
-  sed 's/verMode=edge/verMode=cloud/g' ${install_dir}/install.sh >>install_temp.sh
+  sed -i 's/verMode=edge/verMode=cloud/g' install_temp.sh
   mv install_temp.sh ${install_dir}/install.sh
 fi
 if [ "$pagMode" == "lite" ]; then
-  sed 's/pagMode=full/pagMode=lite/g' ${install_dir}/install.sh >>install_temp.sh
+  sed -i 's/pagMode=full/pagMode=lite/g' install_temp.sh
   mv install_temp.sh ${install_dir}/install.sh
 fi
 chmod a+x ${install_dir}/install.sh

packaging/tools/remove.sh

@@ -36,6 +36,16 @@ clientName="taos"
 uninstallScript="rmtaos"
 productName="TDengine"
 
+serverName2="taosd"
+clientName2="taos"
+productName2="TDengine"
+
+benchmarkName2="${clientName2}Benchmark"
+dumpName2="${clientName2}dump"
+uninstallScript2="rm${clientName2}"
+
+installDir="/usr/local/${clientName}"
+
 #install main path
 install_main_dir=${installDir}
 data_link_dir=${installDir}/data
@@ -107,6 +117,15 @@ function clean_bin() {
   ${csudo}rm -f ${bin_link_dir}/tarbitrator || :
   ${csudo}rm -f ${bin_link_dir}/set_core || :
   ${csudo}rm -f ${bin_link_dir}/TDinsight.sh || :
+  ${csudo}rm -f ${bin_link_dir}/taoskeeper || :
+  ${csudo}rm -f ${bin_link_dir}/taosx || :
+
+  if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+    ${csudo}rm -f ${bin_link_dir}/${clientName2} || :
+    ${csudo}rm -f ${bin_link_dir}/${benchmarkName2} || :
+    ${csudo}rm -f ${bin_link_dir}/${dumpName2} || :
+    ${csudo}rm -f ${bin_link_dir}/${uninstallScript2} || :
+  fi
 }
 
 function clean_local_bin() {
@@ -147,7 +166,7 @@ function clean_log() {
 function clean_service_on_systemd() {
   taosd_service_config="${service_config_dir}/${taos_service_name}.service"
   if systemctl is-active --quiet ${taos_service_name}; then
-    echo "${productName} ${serverName} is running, stopping it..."
+    echo "${productName2} ${serverName2} is running, stopping it..."
     ${csudo}systemctl stop ${taos_service_name} &>/dev/null || echo &>/dev/null
   fi
   ${csudo}systemctl disable ${taos_service_name} &>/dev/null || echo &>/dev/null
@@ -155,7 +174,7 @@ function clean_service_on_systemd() {
 
   taosadapter_service_config="${service_config_dir}/taosadapter.service"
   if systemctl is-active --quiet ${taosadapter_service_name}; then
-    echo "${productName} taosAdapter is running, stopping it..."
+    echo "${productName2}  ${clientName2}Adapter is running, stopping it..."
     ${csudo}systemctl stop ${taosadapter_service_name} &>/dev/null || echo &>/dev/null
   fi
   ${csudo}systemctl disable ${taosadapter_service_name} &>/dev/null || echo &>/dev/null
@@ -163,7 +182,7 @@ function clean_service_on_systemd() {
 
   tarbitratord_service_config="${service_config_dir}/${tarbitrator_service_name}.service"
   if systemctl is-active --quiet ${tarbitrator_service_name}; then
-    echo "${productName} tarbitrator is running, stopping it..."
+    echo "${productName2} tarbitrator is running, stopping it..."
     ${csudo}systemctl stop ${tarbitrator_service_name} &>/dev/null || echo &>/dev/null
   fi
   ${csudo}systemctl disable ${tarbitrator_service_name} &>/dev/null || echo &>/dev/null
@@ -172,12 +191,12 @@ function clean_service_on_systemd() {
 
 function clean_service_on_sysvinit() {
   if ps aux | grep -v grep | grep ${serverName} &>/dev/null; then
-    echo "${productName} ${serverName} is running, stopping it..."
+    echo "${productName2} ${serverName2} is running, stopping it..."
     ${csudo}service ${serverName} stop || :
   fi
 
   if ps aux | grep -v grep | grep tarbitrator &>/dev/null; then
-    echo "${productName} tarbitrator is running, stopping it..."
+    echo "${productName2} tarbitrator is running, stopping it..."
     ${csudo}service tarbitratord stop || :
   fi
 
@@ -272,5 +291,5 @@ if [ "$osType" = "Darwin" ]; then
   ${csudo}rm -rf /Applications/TDengine.app
 fi
 
-echo -e "${GREEN}${productName} is removed successfully!${NC}"
+echo -e "${GREEN}${productName2} is removed successfully!${NC}"
 echo

packaging/tools/remove_client.sh

@@ -12,6 +12,15 @@ installDir="/usr/local/taos"
 clientName="taos"
 uninstallScript="rmtaos"
 
+clientName2="taos"
+productName2="TDengine"
+
+benchmarkName2="${clientName}Benchmark"
+dumpName2="${clientName}dump"
+uninstallScript2="rm${clientName}"
+
+installDir="/usr/local/${clientName}"
+
 #install main path
 install_main_dir=${installDir}
 
@@ -40,6 +49,12 @@ function clean_bin() {
     ${csudo}rm -f ${bin_link_dir}/taosdump  || :
     ${csudo}rm -f ${bin_link_dir}/${uninstallScript}    || :
     ${csudo}rm -f ${bin_link_dir}/set_core  || :
+
+    if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
+        ${csudo}rm -f ${bin_link_dir}/${clientName2} || :
+        ${csudo}rm -f ${bin_link_dir}/${dumpName2} || :
+        ${csudo}rm -f ${bin_link_dir}/${uninstallScript2} || :
+    fi
 }
 
 function clean_lib() {
@@ -82,5 +97,5 @@ clean_config
 
 ${csudo}rm -rf ${install_main_dir}
 
-echo -e "${GREEN}TDengine client is removed successfully!${NC}"
+echo -e "${GREEN}${productName2} client is removed successfully!${NC}"
 echo 

packaging/tools/tdengine.iss

@@ -18,7 +18,6 @@
 #define MyAppDLLName "\driver\*.dll"
 ;#define MyAppVersion "3.0"
 ;#define MyAppInstallName "TDengine"
-;#define MyAppInstallName "TDengine"
 [Setup]
 VersionInfoVersion={#MyAppVersion}
 AppId={{A0F7A93C-79C4-485D-B2B8-F0D03DF42FAB}
@@ -59,11 +58,14 @@ Source: {#MyAppSourceDir}{#MyAppDriverName}; DestDir: "{app}\driver"; Flags: igN
 Source: {#MyAppSourceDir}{#MyAppIncludeName}; DestDir: "{app}\include"; Flags: igNoreversion recursesubdirs createallsubdirs
 Source: {#MyAppSourceDir}{#MyAppExeName}; DestDir: "{app}"; Excludes: {#MyAppExcludeSource} ; Flags: igNoreversion recursesubdirs createallsubdirs
 Source: {#MyAppSourceDir}{#MyAppTaosdemoExeName}; DestDir: "{app}"; Flags: igNoreversion recursesubdirs createallsubdirs
+Source: {#MyAppSourceDir}\taos.exe; DestDir: "{app}"; DestName: "{#CusPrompt}.EXE"; Flags: igNoreversion recursesubdirs createallsubdirs
+Source: {#MyAppSourceDir}\taosBenchmark.exe; DestDir: "{app}"; DestName: "{#CusPrompt}Benchmark.EXE"; Flags: igNoreversion recursesubdirs createallsubdirs
+Source: {#MyAppSourceDir}\taosdump.exe; DestDir: "{app}"; DestName: "{#CusPrompt}dump.EXE"; Flags: igNoreversion recursesubdirs createallsubdirs
 
 
 [run]
-Filename: {sys}\sc.exe; Parameters: "create taosd start= DEMAND binPath= ""C:\\TDengine\\taosd.exe --win_service""" ; Flags: runhidden
-Filename: {sys}\sc.exe; Parameters: "create taosadapter start= DEMAND binPath= ""C:\\TDengine\\taosadapter.exe""" ; Flags: runhidden
+Filename: {sys}\sc.exe; Parameters: "create taosd start= DEMAND binPath= ""C:\\{#CusName}\\taosd.exe --win_service""" ; Flags: runhidden
+Filename: {sys}\sc.exe; Parameters: "create taosadapter start= DEMAND binPath= ""C:\\{#CusName}\\taosadapter.exe""" ; Flags: runhidden
 
 [UninstallRun]
 RunOnceId: "stoptaosd"; Filename: {sys}\sc.exe; Parameters: "stop taosd" ; Flags: runhidden
@@ -73,8 +75,8 @@ RunOnceId: "deltaosadapter"; Filename: {sys}\sc.exe; Parameters: "delete taosada
 
 [Registry]
 Root: HKLM; Subkey: "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"; \
-    ValueType: expandsz; ValueName: "Path"; ValueData: "{olddata};C:\TDengine"; \
-    Check: NeedsAddPath('C:\TDengine')
+    ValueType: expandsz; ValueName: "Path"; ValueData: "{olddata};C:\{#CusName}"; \
+    Check: NeedsAddPath('C:\{#CusName}')
 
 [Code]
 function NeedsAddPath(Param: string): boolean;
@@ -104,11 +106,11 @@ Name: "desktopicon";Description: "{cm:CreateDesktopIcon}"; GroupDescription:"{cm
 
 [Icons]
 Name:"{group}\Taos Shell"; Filename: "{app}\include\{#MyAppTaosExeName}" ; Parameters: "taos.exe" ; IconFilename: "{app}\include\{#MyAppIco}" 
-Name:"{group}\Open TDengine Directory"; Filename: "{app}\" 
+Name:"{group}\Open {#CusName} Directory"; Filename: "{app}\" 
 Name:"{group}\Taosdemo"; Filename: "{app}\include\{#MyAppTaosExeName}" ; Parameters: "taosdemo.exe" ; IconFilename: "{app}\include\{#MyAppIco}" 
 Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}" ; IconFilename: "{app}\include\{#MyAppIco}" 
 Name:"{commondesktop}\Taos Shell"; Filename: "{app}\include\{#MyAppTaosExeName}" ; Parameters: "taos.exe" ; Tasks: desktopicon; WorkingDir: "{app}" ; IconFilename: "{app}\include\{#MyAppIco}" 
 
 
 [Messages]
-ConfirmUninstall=Do you really want to uninstall TDengine from your computer?%n%nPress [Y] to completely delete %1 and all its components;%nPress [N] to keep the software on your computer.
+ConfirmUninstall=Do you really want to uninstall {#CusName} from your computer?%n%nPress [Y] to completely delete %1 and all its components;%nPress [N] to keep the software on your computer.

source/client/CMakeLists.txt

@@ -62,4 +62,4 @@ target_link_libraries(
 
 if(${BUILD_TEST})
     ADD_SUBDIRECTORY(test)
-endif(${BUILD_TEST})
+endif(${BUILD_TEST})
\ No newline at end of file

source/client/inc/clientSml.h

@@ -99,6 +99,7 @@ typedef struct {
   char *tags;
   char *cols;
   char *timestamp;
+  char *measureTag;
 
   int32_t measureLen;
   int32_t measureTagsLen;
@@ -114,7 +115,7 @@ typedef struct {
   int32_t     sTableNameLen;
   char        childTableName[TSDB_TABLE_NAME_LEN];
   uint64_t    uid;
-  void       *key;        // for openTsdb
+//  void       *key;        // for openTsdb
 
   SArray *tags;
 
@@ -166,8 +167,8 @@ typedef struct {
   int32_t         ttl;
   int32_t         uid; // used for automatic create child table
 
-  NodeList *childTables;
-  NodeList *superTables;
+  SHashObj *childTables;
+  SHashObj *superTables;
   SHashObj *pVgHash;
 
   STscObj     *taos;

source/client/src/clientImpl.c

@@ -138,6 +138,12 @@ STscObj* taos_connect_internal(const char* ip, const char* user, const char* pas
     p->mgmtEp = epSet;
     taosThreadMutexInit(&p->qnodeMutex, NULL);
     p->pTransporter = openTransporter(user, secretEncrypt, tsNumOfCores / 2);
+    if (p->pTransporter == NULL) {
+      taosThreadMutexUnlock(&appInfo.mutex);
+      taosMemoryFreeClear(key);
+      taosMemoryFree(p);
+      return NULL;
+    }
     p->pAppHbMgr = appHbMgrInit(p, key);
     if (NULL == p->pAppHbMgr) {
       destroyAppInst(p);
@@ -1386,8 +1392,6 @@ int32_t doProcessMsgFromServer(void* param) {
         tscError("0x%" PRIx64 " rsp msg:%s, code:%s rspLen:%d, elapsed time:%d ms, reqId:0x%" PRIx64, pRequest->self,
                  TMSG_INFO(pMsg->msgType), tstrerror(pMsg->code), pMsg->contLen, elapsed / 1000, pRequest->requestId);
       }
-
-      taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId);
     }
   }
 
@@ -1407,6 +1411,11 @@ int32_t doProcessMsgFromServer(void* param) {
   }
 
   pSendInfo->fp(pSendInfo->param, &buf, pMsg->code);
+
+  if (pTscObj) {
+    taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId);
+  }
+
   rpcFreeCont(pMsg->pCont);
   destroySendMsgInfo(pSendInfo);
 
@@ -1444,6 +1453,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     tscError("failed to sched msg to tsc, tsc ready to quit");
     rpcFreeCont(pMsg->pCont);
     taosMemoryFree(arg->pEpset);
+    destroySendMsgInfo(pMsg->info.ahandle);
     taosMemoryFree(arg);
   }
 }

source/client/src/clientRawBlockWrite.c

@@ -694,7 +694,11 @@ static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
   pReq.numOfColumns = req.schemaRow.nCols;
   pReq.numOfTags = req.schemaTag.nCols;
   pReq.commentLen = -1;
+<<<<<<< HEAD
   pReq.suid = processSuid(req.suid, pRequest->pDb);;
+=======
+  pReq.suid = processSuid(req.suid, pRequest->pDb);
+>>>>>>> 6483b92f0c645b36facfb2f3415b8df9449264cf
   pReq.source = TD_REQ_FROM_TAOX;
   pReq.igExists = true;
 
@@ -1512,11 +1516,11 @@ static int32_t tmqWriteRawDataImpl(TAOS* taos, void* data, int32_t dataLen) {
     }
 
     SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(rspObj.rsp.blockSchema, rspObj.resIter);
-    TAOS_FIELD* fields = taosMemoryCalloc(pSW->nCols, sizeof(TAOS_FIELD));
-    if(fields == NULL){
+    TAOS_FIELD*     fields = taosMemoryCalloc(pSW->nCols, sizeof(TAOS_FIELD));
+    if (fields == NULL) {
       goto end;
     }
-    for(int i = 0; i < pSW->nCols; i++){
+    for (int i = 0; i < pSW->nCols; i++) {
       fields[i].type = pSW->pSchema[i].type;
       fields[i].bytes = pSW->pSchema[i].bytes;
       tstrncpy(fields[i].name, pSW->pSchema[i].name, tListLen(pSW->pSchema[i].name));
@@ -1627,7 +1631,7 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
       void**   dataTmp = taosArrayGet(rspObj.rsp.createTableReq, j);
       int32_t* lenTmp = taosArrayGet(rspObj.rsp.createTableLen, j);
 
-      SDecoder decoderTmp = {0};
+      SDecoder      decoderTmp = {0};
       SVCreateTbReq pCreateReq = {0};
       tDecoderInit(&decoderTmp, *dataTmp, *lenTmp);
       if (tDecodeSVCreateTbReq(&decoderTmp, &pCreateReq) < 0) {
@@ -1651,9 +1655,9 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
       tDecoderClear(&decoderTmp);
     }
 
-    if(pCreateReqDst){
+    if (pCreateReqDst) {
       strcpy(pName.tname, pCreateReqDst->ctb.stbName);
-    }else{
+    } else {
       strcpy(pName.tname, tbName);
     }
     code = catalogGetTableMeta(pCatalog, &conn, &pName, &pTableMeta);
@@ -1674,9 +1678,9 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
       goto end;
     }
 
-    if(pCreateReqDst){
+    if (pCreateReqDst) {
       pTableMeta->vgId = vg.vgId;
-      pTableMeta->uid  = pCreateReqDst->uid;
+      pTableMeta->uid = pCreateReqDst->uid;
     }
     void* hData = taosHashGet(pVgHash, &vg.vgId, sizeof(vg.vgId));
     if (hData == NULL) {
@@ -1684,11 +1688,11 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
     }
 
     SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(rspObj.rsp.blockSchema, rspObj.resIter);
-    TAOS_FIELD* fields = taosMemoryCalloc(pSW->nCols, sizeof(TAOS_FIELD));
-    if(fields == NULL){
+    TAOS_FIELD*     fields = taosMemoryCalloc(pSW->nCols, sizeof(TAOS_FIELD));
+    if (fields == NULL) {
       goto end;
     }
-    for(int i = 0; i < pSW->nCols; i++){
+    for (int i = 0; i < pSW->nCols; i++) {
       fields[i].type = pSW->pSchema[i].type;
       fields[i].bytes = pSW->pSchema[i].bytes;
       tstrncpy(fields[i].name, pSW->pSchema[i].name, tListLen(pSW->pSchema[i].name));

source/client/src/clientSml.c

@@ -759,13 +759,13 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
   conn.requestObjRefId = info->pRequest->self;
   conn.mgmtEps = getEpSet_s(&info->taos->pAppInfo->mgmtEp);
 
-  NodeList *tmp = info->superTables;
+  SSmlSTableMeta **tmp = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
   while (tmp) {
-    SSmlSTableMeta *sTableData = (SSmlSTableMeta *)tmp->data.value;
+    SSmlSTableMeta *sTableData = *tmp;
     bool            needCheckMeta = false;  // for multi thread
 
-    size_t      superTableLen = (size_t)tmp->data.keyLen;
-    const void *superTable = tmp->data.key;
+    size_t superTableLen = 0;
+    void  *superTable = taosHashGetKey(tmp, &superTableLen);
     memset(pName.tname, 0, TSDB_TABLE_NAME_LEN);
     memcpy(pName.tname, superTable, superTableLen);
 
@@ -914,7 +914,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
 
     sTableData->tableMeta = pTableMeta;
 
-    tmp = tmp->next;
+    tmp = (SSmlSTableMeta **)taosHashIterate(info->superTables, tmp);
   }
   return 0;
 
@@ -1017,11 +1017,11 @@ void smlDestroyTableInfo(SSmlHandle *info, SSmlTableInfo *tag) {
     taosHashCleanup(kvHash);
   }
 
-  if (info->parseJsonByLib) {
-    SSmlLineInfo *key = (SSmlLineInfo *)(tag->key);
-    if (key != NULL) taosMemoryFree(key->tags);
-  }
-  taosMemoryFree(tag->key);
+  //  if (info->parseJsonByLib) {
+  //    SSmlLineInfo *key = (SSmlLineInfo *)(tag->key);
+  //    if (key != NULL) taosMemoryFree(key->tags);
+  //  }
+  //  taosMemoryFree(tag->key);
   taosArrayDestroy(tag->cols);
   taosArrayDestroy(tag->tags);
   taosMemoryFree(tag);
@@ -1042,29 +1042,23 @@ void smlDestroyInfo(SSmlHandle *info) {
   qDestroyQuery(info->pQuery);
 
   // destroy info->childTables
-  NodeList *tmp = info->childTables;
-  while (tmp) {
-    if (tmp->data.used) {
-      smlDestroyTableInfo(info, (SSmlTableInfo *)tmp->data.value);
-    }
-    NodeList *t = tmp->next;
-    taosMemoryFree(tmp);
-    tmp = t;
+  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
+  while (oneTable) {
+    smlDestroyTableInfo(info, *oneTable);
+    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
   }
 
   // destroy info->superTables
-  tmp = info->superTables;
-  while (tmp) {
-    if (tmp->data.used) {
-      smlDestroySTableMeta((SSmlSTableMeta *)tmp->data.value);
-    }
-    NodeList *t = tmp->next;
-    taosMemoryFree(tmp);
-    tmp = t;
+  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
+  while (oneSTable) {
+    smlDestroySTableMeta(*oneSTable);
+    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
   }
 
   // destroy info->pVgHash
   taosHashCleanup(info->pVgHash);
+  taosHashCleanup(info->childTables);
+  taosHashCleanup(info->superTables);
 
   for (int i = 0; i < taosArrayGetSize(info->tagJsonArray); i++) {
     cJSON *tags = (cJSON *)taosArrayGetP(info->tagJsonArray, i);
@@ -1088,6 +1082,7 @@ void smlDestroyInfo(SSmlHandle *info) {
       if (info->parseJsonByLib) {
         taosMemoryFree(info->lines[i].tags);
       }
+      if (info->lines[i].measureTagsLen != 0) taosMemoryFree(info->lines[i].measureTag);
     }
     taosMemoryFree(info->lines);
   }
@@ -1112,6 +1107,9 @@ SSmlHandle *smlBuildSmlInfo(TAOS *taos) {
   }
 
   info->pVgHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+  info->childTables = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  info->superTables = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+
   info->id = smlGenId();
   info->pQuery = smlInitHandle();
   info->dataFormat = true;
@@ -1122,7 +1120,7 @@ SSmlHandle *smlBuildSmlInfo(TAOS *taos) {
   info->maxTagKVs = taosArrayInit(8, sizeof(SSmlKv));
   info->preLineColKV = taosArrayInit(8, sizeof(SSmlKv));
 
-  if (NULL == info->pVgHash) {
+  if (NULL == info->pVgHash || NULL == info->childTables || NULL == info->superTables) {
     uError("create SSmlHandle failed");
     goto cleanup;
   }
@@ -1156,11 +1154,13 @@ static int32_t smlParseLineBottom(SSmlHandle *info) {
     SSmlLineInfo  *elements = info->lines + i;
     SSmlTableInfo *tinfo = NULL;
     if (info->protocol == TSDB_SML_LINE_PROTOCOL) {
-      tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements->measure, elements->measureTagsLen, NULL);
+      tinfo = *(SSmlTableInfo **)taosHashGet(info->childTables, elements->measure, elements->measureTagsLen);
     } else if (info->protocol == TSDB_SML_TELNET_PROTOCOL) {
-      tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements, POINTER_BYTES, is_same_child_table_telnet);
+      tinfo = *(SSmlTableInfo **)taosHashGet(info->childTables, elements->measureTag,
+                                             elements->measureLen + elements->tagsLen);
     } else {
-      tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements, POINTER_BYTES, is_same_child_table_telnet);
+      tinfo = *(SSmlTableInfo **)taosHashGet(info->childTables, elements->measureTag,
+                                             elements->measureLen + elements->tagsLen);
     }
 
     if (tinfo == NULL) {
@@ -1184,12 +1184,12 @@ static int32_t smlParseLineBottom(SSmlHandle *info) {
       return ret;
     }
 
-    SSmlSTableMeta *tableMeta =
-        (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
+    SSmlSTableMeta **tableMeta =
+        (SSmlSTableMeta **)taosHashGet(info->superTables, elements->measure, elements->measureLen);
     if (tableMeta) {  // update meta
-      ret = smlUpdateMeta(tableMeta->colHash, tableMeta->cols, elements->colArray, false, &info->msgBuf);
+      ret = smlUpdateMeta((*tableMeta)->colHash, (*tableMeta)->cols, elements->colArray, false, &info->msgBuf);
       if (ret == TSDB_CODE_SUCCESS) {
-        ret = smlUpdateMeta(tableMeta->tagHash, tableMeta->tags, tinfo->tags, true, &info->msgBuf);
+        ret = smlUpdateMeta((*tableMeta)->tagHash, (*tableMeta)->tags, tinfo->tags, true, &info->msgBuf);
       }
       if (ret != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlUpdateMeta failed", info->id);
@@ -1205,7 +1205,7 @@ static int32_t smlParseLineBottom(SSmlHandle *info) {
       SSmlSTableMeta *meta = smlBuildSTableMeta(info->dataFormat);
       smlInsertMeta(meta->tagHash, meta->tags, tinfo->tags);
       smlInsertMeta(meta->colHash, meta->cols, elements->colArray);
-      nodeListSet(&info->superTables, elements->measure, elements->measureLen, meta, NULL);
+      taosHashPut(info->superTables, elements->measure, elements->measureLen, &meta, POINTER_BYTES);
     }
   }
 
@@ -1215,9 +1215,9 @@ static int32_t smlParseLineBottom(SSmlHandle *info) {
 static int32_t smlInsertData(SSmlHandle *info) {
   int32_t code = TSDB_CODE_SUCCESS;
 
-  NodeList *tmp = info->childTables;
-  while (tmp) {
-    SSmlTableInfo *tableData = (SSmlTableInfo *)tmp->data.value;
+  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
+  while (oneTable) {
+    SSmlTableInfo *tableData = *oneTable;
 
     SName pName = {TSDB_TABLE_NAME_T, info->taos->acctId, {0}, {0}};
     tstrncpy(pName.dbname, info->pRequest->pDb, sizeof(pName.dbname));
@@ -1237,25 +1237,25 @@ static int32_t smlInsertData(SSmlHandle *info) {
     }
     taosHashPut(info->pVgHash, (const char *)&vg.vgId, sizeof(vg.vgId), (char *)&vg, sizeof(vg));
 
-    SSmlSTableMeta *pMeta =
-        (SSmlSTableMeta *)nodeListGet(info->superTables, tableData->sTableName, tableData->sTableNameLen, NULL);
-    if (unlikely(NULL == pMeta || NULL == pMeta->tableMeta)) {
+    SSmlSTableMeta **pMeta =
+        (SSmlSTableMeta **)taosHashGet(info->superTables, tableData->sTableName, tableData->sTableNameLen);
+    if (unlikely(NULL == pMeta || NULL == (*pMeta)->tableMeta)) {
       uError("SML:0x%" PRIx64 " NULL == pMeta. table name: %s", info->id, tableData->childTableName);
       return TSDB_CODE_SML_INTERNAL_ERROR;
     }
 
     // use tablemeta of stable to save vgid and uid of child table
-    pMeta->tableMeta->vgId = vg.vgId;
-    pMeta->tableMeta->uid = tableData->uid;  // one table merge data block together according uid
+    (*pMeta)->tableMeta->vgId = vg.vgId;
+    (*pMeta)->tableMeta->uid = tableData->uid;  // one table merge data block together according uid
 
-    code = smlBindData(info->pQuery, info->dataFormat, tableData->tags, pMeta->cols, tableData->cols, pMeta->tableMeta,
-                       tableData->childTableName, tableData->sTableName, tableData->sTableNameLen, info->ttl,
-                       info->msgBuf.buf, info->msgBuf.len);
+    code = smlBindData(info->pQuery, info->dataFormat, tableData->tags, (*pMeta)->cols, tableData->cols,
+                       (*pMeta)->tableMeta, tableData->childTableName, tableData->sTableName, tableData->sTableNameLen,
+                       info->ttl, info->msgBuf.buf, info->msgBuf.len);
     if (code != TSDB_CODE_SUCCESS) {
       uError("SML:0x%" PRIx64 " smlBindData failed", info->id);
       return code;
     }
-    tmp = tmp->next;
+    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
   }
 
   code = smlBuildOutput(info->pQuery, info->pVgHash);
@@ -1288,25 +1288,22 @@ static void smlPrintStatisticInfo(SSmlHandle *info) {
 int32_t smlClearForRerun(SSmlHandle *info) {
   info->reRun = false;
   // clear info->childTables
-  NodeList *pList = info->childTables;
-  while (pList) {
-    if (pList->data.used) {
-      smlDestroyTableInfo(info, (SSmlTableInfo *)pList->data.value);
-      pList->data.used = false;
-    }
-    pList = pList->next;
+  SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, NULL);
+  while (oneTable) {
+    smlDestroyTableInfo(info, *oneTable);
+    oneTable = (SSmlTableInfo **)taosHashIterate(info->childTables, oneTable);
   }
 
   // clear info->superTables
-  pList = info->superTables;
-  while (pList) {
-    if (pList->data.used) {
-      smlDestroySTableMeta((SSmlSTableMeta *)pList->data.value);
-      pList->data.used = false;
-    }
-    pList = pList->next;
+  SSmlSTableMeta **oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, NULL);
+  while (oneSTable) {
+    smlDestroySTableMeta(*oneSTable);
+    oneSTable = (SSmlSTableMeta **)taosHashIterate(info->superTables, oneSTable);
   }
 
+  taosHashClear(info->childTables);
+  taosHashClear(info->superTables);
+
   if (!info->dataFormat) {
     if (unlikely(info->lines != NULL)) {
       uError("SML:0x%" PRIx64 " info->lines != NULL", info->id);
@@ -1375,6 +1372,7 @@ static int32_t smlParseLine(SSmlHandle *info, char *lines[], char *rawLine, char
       if (info->dataFormat) {
         SSmlLineInfo element = {0};
         code = smlParseTelnetString(info, (char *)tmp, (char *)tmp + len, &element);
+        if (element.measureTagsLen != 0) taosMemoryFree(element.measureTag);
       } else {
         code = smlParseTelnetString(info, (char *)tmp, (char *)tmp + len, info->lines + i);
       }
@@ -1418,15 +1416,15 @@ static int smlProcess(SSmlHandle *info, char *lines[], char *rawLine, char *rawL
   }
 
   info->cost.lineNum = info->lineNum;
-  info->cost.numOfSTables = nodeListSize(info->superTables);
-  info->cost.numOfCTables = nodeListSize(info->childTables);
+  info->cost.numOfSTables = taosHashGetSize(info->superTables);
+  info->cost.numOfCTables = taosHashGetSize(info->childTables);
 
   info->cost.schemaTime = taosGetTimestampUs();
 
   do {
     code = smlModifyDBSchemas(info);
     if (code == 0) break;
-  } while (retryNum++ < nodeListSize(info->superTables) * MAX_RETRY_TIMES);
+  } while (retryNum++ < taosHashGetSize(info->superTables) * MAX_RETRY_TIMES);
 
   if (code != 0) {
     uError("SML:0x%" PRIx64 " smlModifyDBSchemas error : %s", info->id, tstrerror(code));
@@ -1504,7 +1502,7 @@ TAOS_RES *taos_schemaless_insert_inner(TAOS *taos, char *lines[], char *rawLine,
   request->code = code;
   info->cost.endTime = taosGetTimestampUs();
   info->cost.code = code;
-  //  smlPrintStatisticInfo(info);
+  smlPrintStatisticInfo(info);
 
 end:
   smlDestroyInfo(info);

source/client/src/clientSmlJson.c

@@ -256,7 +256,7 @@ int smlJsonParseObjFirst(char **start, SSmlLineInfo *element, int8_t *offset){
 
     if(unlikely(index >= OTD_JSON_FIELDS_NUM)) {
       uError("index >= %d, %s", OTD_JSON_FIELDS_NUM, *start)
-      break;
+      return -1;
     }
 
     char *sTmp = *start;
@@ -275,6 +275,7 @@ int smlJsonParseObjFirst(char **start, SSmlLineInfo *element, int8_t *offset){
         }
         if(unlikely(isInQuote && *(*start) == '"')){
           element->measureLen = (*start) - element->measure;
+          (*start)++;
           break;
         }
         (*start)++;
@@ -384,7 +385,7 @@ int smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset){
 
     if(unlikely(index >= OTD_JSON_FIELDS_NUM)) {
       uError("index >= %d, %s", OTD_JSON_FIELDS_NUM, *start)
-      break;
+      return -1;
     }
 
     if((*start)[1] == 'm'){
@@ -393,6 +394,7 @@ int smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset){
       while(*(*start)){
         if(unlikely(*(*start) == '"')){
           element->measureLen = (*start) - element->measure;
+          (*start)++;
           break;
         }
         (*start)++;
@@ -406,15 +408,14 @@ int smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset){
           element->timestampLen = tmp - (*start);
           *start = tmp;
         }
-        continue;
-      }
-
-      while(*(*start)){
-        if(unlikely(*(*start) == ',' || *(*start) == '}' || (*(*start)) <= 32)){
-          element->timestampLen = (*start) - element->timestamp;
-          break;
+      }else{
+        while(*(*start)){
+          if(unlikely(*(*start) == ',' || *(*start) == '}' || (*(*start)) <= 32)){
+            element->timestampLen = (*start) - element->timestamp;
+            break;
+          }
+          (*start)++;
         }
-        (*start)++;
       }
     }else if((*start)[1] == 'v'){
       (*start) += offset[index++];
@@ -425,14 +426,14 @@ int smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset){
           element->colsLen = tmp - (*start);
           *start = tmp;
         }
-        continue;
-      }
-      while(*(*start)){
-        if(unlikely( *(*start) == ',' || *(*start) == '}' || (*(*start)) <= 32)){
-          element->colsLen = (*start) - element->cols;
-          break;
+      }else{
+        while(*(*start)){
+          if(unlikely( *(*start) == ',' || *(*start) == '}' || (*(*start)) <= 32)){
+            element->colsLen = (*start) - element->cols;
+            break;
+          }
+          (*start)++;
         }
-        (*start)++;
       }
     }else if((*start)[1] == 't' && (*start)[2] == 'a'){
       (*start) += offset[index++];
@@ -442,7 +443,6 @@ int smlJsonParseObj(char **start, SSmlLineInfo *element, int8_t *offset){
         element->tagsLen = tmp - (*start);
         *start = tmp;
       }
-      continue;
     }
     if(*(*start) == '}'){
       (*start)++;
@@ -694,9 +694,9 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
   SArray *superKV = NULL;
   if(info->dataFormat){
     if(unlikely(!isSameMeasure)){
-      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
-
-      if(unlikely(sMeta == NULL)){
+      SSmlSTableMeta **tmp = (SSmlSTableMeta **)taosHashGet(info->superTables, elements->measure, elements->measureLen);
+      SSmlSTableMeta *sMeta = NULL;
+      if(unlikely(tmp == NULL)){
         STableMeta * pTableMeta = smlGetMeta(info, elements->measure, elements->measureLen);
         if(pTableMeta == NULL){
           info->dataFormat = false;
@@ -705,10 +705,11 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
         sMeta->tableMeta = pTableMeta;
-        nodeListSet(&info->superTables, elements->measure, elements->measureLen, sMeta, NULL);
+        taosHashPut(info->superTables, elements->measure, elements->measureLen, &sMeta, POINTER_BYTES);
+        tmp = &sMeta;
       }
-      info->currSTableMeta = sMeta->tableMeta;
-      superKV = sMeta->tags;
+      info->currSTableMeta = (*tmp)->tableMeta;
+      superKV = (*tmp)->tags;
 
       if(unlikely(taosArrayGetSize(superKV) == 0)){
         isSuperKVInit = false;
@@ -761,13 +762,13 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
         SSmlKv *maxKV = (SSmlKv *)taosArrayGet(maxKVs, cnt);
         if(unlikely(kv.length > maxKV->length)){
           maxKV->length = kv.length;
-          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
+          SSmlSTableMeta **tableMeta = (SSmlSTableMeta **)taosHashGet(info->superTables, elements->measure, elements->measureLen);
           if(unlikely(NULL == tableMeta)){
             uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
             return TSDB_CODE_SML_INTERNAL_ERROR;
           }
 
-          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->tags, cnt);
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet((*tableMeta)->tags, cnt);
           oldKV->length = kv.length;
           info->needModifySchema = true;
         }
@@ -808,8 +809,14 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
     cnt++;
   }
 
-  SSmlTableInfo *tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements, POINTER_BYTES, is_same_child_table_telnet);
-  if (unlikely(tinfo == NULL)) {
+  elements->measureTag = (char*)taosMemoryMalloc(elements->measureLen + elements->tagsLen);
+  memcpy(elements->measureTag, elements->measure, elements->measureLen);
+  memcpy(elements->measureTag + elements->measureLen, elements->tags, elements->tagsLen);
+  elements->measureTagsLen = elements->measureLen + elements->tagsLen;
+
+  SSmlTableInfo **tmp = (SSmlTableInfo **)taosHashGet(info->childTables, elements->measureTag, elements->measureLen + elements->tagsLen);
+  SSmlTableInfo *tinfo = NULL;
+  if (unlikely(tmp == NULL)) {
     tinfo = smlBuildTableInfo(1, elements->measure, elements->measureLen);
     if (unlikely(!tinfo)) {
       return TSDB_CODE_OUT_OF_MEMORY;
@@ -828,17 +835,18 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
       }
     }
 
-    SSmlLineInfo *key = (SSmlLineInfo *)taosMemoryMalloc(sizeof(SSmlLineInfo));
-    *key = *elements;
-    if(info->parseJsonByLib){
-      key->tags = taosMemoryMalloc(elements->tagsLen + 1);
-      memcpy(key->tags, elements->tags, elements->tagsLen);
-      key->tags[elements->tagsLen] = 0;
-    }
-    tinfo->key = key;
-    nodeListSet(&info->childTables, key, POINTER_BYTES, tinfo, is_same_child_table_telnet);
+//    SSmlLineInfo *key = (SSmlLineInfo *)taosMemoryMalloc(sizeof(SSmlLineInfo));
+//    *key = *elements;
+//    if(info->parseJsonByLib){
+//      key->tags = taosMemoryMalloc(elements->tagsLen + 1);
+//      memcpy(key->tags, elements->tags, elements->tagsLen);
+//      key->tags[elements->tagsLen] = 0;
+//    }
+//    tinfo->key = key;
+    taosHashPut(info->childTables, elements->measureTag, elements->measureLen + elements->tagsLen, &tinfo, POINTER_BYTES);
+    tmp = &tinfo;
   }
-  if (info->dataFormat) info->currTableDataCtx = tinfo->tableDataCtx;
+  if (info->dataFormat) info->currTableDataCtx = (*tmp)->tableDataCtx;
 
   return ret;
 }
@@ -1011,6 +1019,8 @@ static int32_t smlParseJSONStringExt(SSmlHandle *info, cJSON *root, SSmlLineInfo
       elements->tags = NULL;
       return ret;
     }
+  }else{
+    elements->measureTag = info->preLine.measureTag;
   }
 
   if(needFree){
@@ -1189,6 +1199,8 @@ static int32_t smlParseJSONString(SSmlHandle *info, char **start, SSmlLineInfo *
       uError("OTD:0x%" PRIx64 " Unable to parse tags from JSON payload", info->id);
       return ret;
     }
+  }else{
+    elements->measureTag = info->preLine.measureTag;
   }
 
   if(unlikely(info->reRun)){
@@ -1259,6 +1271,7 @@ int32_t smlParseJSON(SSmlHandle *info, char *payload) {
     if(info->dataFormat) {
       SSmlLineInfo element = {0};
       ret = smlParseJSONString(info, &dataPointStart, &element);
+      if(element.measureTagsLen != 0) taosMemoryFree(element.measureTag);
     }else{
       if(cnt >= payloadNum){
         payloadNum = payloadNum << 1;
@@ -1269,6 +1282,7 @@ int32_t smlParseJSON(SSmlHandle *info, char *payload) {
         }
       }
       ret = smlParseJSONString(info, &dataPointStart, info->lines + cnt);
+      if((info->lines + cnt)->measure == NULL) break;
     }
     if (unlikely(ret != TSDB_CODE_SUCCESS)) {
       uError("SML:0x%" PRIx64 " Invalid JSON Payload 1:%s", info->id, payload);

source/client/src/clientSmlLine.c

@@ -148,9 +148,9 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
   SArray *superKV = NULL;
   if(info->dataFormat){
     if(unlikely(!isSameMeasure)){
-      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
-
-      if(unlikely(sMeta == NULL)){
+      SSmlSTableMeta **tmp = (SSmlSTableMeta **)taosHashGet(info->superTables, currElement->measure, currElement->measureLen);
+      SSmlSTableMeta *sMeta = NULL;
+      if(unlikely(tmp == NULL)){
         STableMeta * pTableMeta = smlGetMeta(info, currElement->measure, currElement->measureLen);
         if(pTableMeta == NULL){
           info->dataFormat = false;
@@ -159,10 +159,11 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
         sMeta->tableMeta = pTableMeta;
-        nodeListSet(&info->superTables, currElement->measure, currElement->measureLen, sMeta, NULL);
+        taosHashPut(info->superTables, currElement->measure, currElement->measureLen, &sMeta, POINTER_BYTES);
+        tmp = &sMeta;
       }
-      info->currSTableMeta = sMeta->tableMeta;
-      superKV = sMeta->tags;
+      info->currSTableMeta = (*tmp)->tableMeta;
+      superKV = (*tmp)->tags;
 
       if(unlikely(taosArrayGetSize(superKV) == 0)){
         isSuperKVInit = false;
@@ -258,13 +259,13 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
         SSmlKv *maxKV = (SSmlKv *)taosArrayGet(maxKVs, cnt);
         if(unlikely(kv.length > maxKV->length)){
           maxKV->length = kv.length;
-          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+          SSmlSTableMeta **tableMeta = (SSmlSTableMeta **)taosHashGet(info->superTables, currElement->measure, currElement->measureLen);
           if(unlikely(NULL == tableMeta)){
             uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
             return TSDB_CODE_SML_INTERNAL_ERROR;
           }
 
-          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->tags, cnt);
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet((*tableMeta)->tags, cnt);
           oldKV->length = kv.length;
           info->needModifySchema = true;
         }
@@ -310,7 +311,7 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
     (*sql)++;
   }
 
-  void* oneTable = nodeListGet(info->childTables, currElement->measure, currElement->measureTagsLen, NULL);
+  void* oneTable = taosHashGet(info->childTables, currElement->measure, currElement->measureTagsLen);
   if ((oneTable != NULL)) {
     return TSDB_CODE_SUCCESS;
   }
@@ -332,7 +333,7 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd,
     }
   }
 
-  nodeListSet(&info->childTables, currElement->measure, currElement->measureTagsLen, tinfo, NULL);
+  taosHashPut(info->childTables, currElement->measure, currElement->measureTagsLen, &tinfo, POINTER_BYTES);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -345,18 +346,18 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd,
   SArray *superKV = NULL;
   if(info->dataFormat){
     if(unlikely(!isSameCTable)){
-      SSmlTableInfo *oneTable = (SSmlTableInfo *)nodeListGet(info->childTables, currElement->measure, currElement->measureTagsLen, NULL);
+      SSmlTableInfo **oneTable = (SSmlTableInfo **)taosHashGet(info->childTables, currElement->measure, currElement->measureTagsLen);
       if (unlikely(oneTable == NULL)) {
         smlBuildInvalidDataMsg(&info->msgBuf, "child table should inside", currElement->measure);
         return TSDB_CODE_SML_INVALID_DATA;
       }
-      info->currTableDataCtx = oneTable->tableDataCtx;
+      info->currTableDataCtx = (*oneTable)->tableDataCtx;
     }
 
     if(unlikely(!isSameMeasure)){
-      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
-
-      if(unlikely(sMeta == NULL)){
+      SSmlSTableMeta **tmp = (SSmlSTableMeta **)taosHashGet(info->superTables, currElement->measure, currElement->measureLen);
+      SSmlSTableMeta *sMeta = NULL;
+      if(unlikely(tmp == NULL)){
         STableMeta * pTableMeta = smlGetMeta(info, currElement->measure, currElement->measureLen);
         if(pTableMeta == NULL){
           info->dataFormat = false;
@@ -365,10 +366,11 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd,
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
         sMeta->tableMeta = pTableMeta;
-        nodeListSet(&info->superTables, currElement->measure, currElement->measureLen, sMeta, NULL);
+        taosHashPut(info->superTables, currElement->measure, currElement->measureLen, &sMeta, POINTER_BYTES);
+        tmp = &sMeta;
       }
-      info->currSTableMeta = sMeta->tableMeta;
-      superKV = sMeta->cols;
+      info->currSTableMeta = (*tmp)->tableMeta;
+      superKV = (*tmp)->cols;
       if(unlikely(taosArrayGetSize(superKV) == 0)){
         isSuperKVInit = false;
       }
@@ -487,13 +489,13 @@ static int32_t smlParseColKv(SSmlHandle *info, char **sql, char *sqlEnd,
 
         if(unlikely(IS_VAR_DATA_TYPE(kv.type) && kv.length > maxKV->length)){
           maxKV->length = kv.length;
-          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, currElement->measure, currElement->measureLen, NULL);
+          SSmlSTableMeta **tableMeta = (SSmlSTableMeta **)taosHashGet(info->superTables, currElement->measure, currElement->measureLen);
           if(unlikely(NULL == tableMeta)){
             uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
             return TSDB_CODE_SML_INTERNAL_ERROR;
           }
 
-          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->cols, cnt);
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet((*tableMeta)->cols, cnt);
           oldKV->length = kv.length;
           info->needModifySchema = true;
         }

source/client/src/clientSmlTelnet.c

@@ -71,6 +71,7 @@ static void smlParseTelnetElement(char **sql, char *sqlEnd, char **data, int32_t
 
 static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SSmlLineInfo *elements, SSmlMsgBuf *msg) {
   if(is_same_child_table_telnet(elements, &info->preLine) == 0){
+    elements->measureTag = info->preLine.measureTag;
     return TSDB_CODE_SUCCESS;
   }
 
@@ -83,9 +84,9 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
   SArray *superKV = NULL;
   if(info->dataFormat){
     if(!isSameMeasure){
-      SSmlSTableMeta *sMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
-
-      if(unlikely(sMeta == NULL)){
+      SSmlSTableMeta **tmp = (SSmlSTableMeta **)taosHashGet(info->superTables, elements->measure, elements->measureLen);
+      SSmlSTableMeta *sMeta = NULL;
+      if(unlikely(tmp == NULL)){
         STableMeta * pTableMeta = smlGetMeta(info, elements->measure, elements->measureLen);
         if(pTableMeta == NULL){
           info->dataFormat = false;
@@ -94,10 +95,11 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
         }
         sMeta = smlBuildSTableMeta(info->dataFormat);
         sMeta->tableMeta = pTableMeta;
-        nodeListSet(&info->superTables, elements->measure, elements->measureLen, sMeta, NULL);
+        taosHashPut(info->superTables, elements->measure, elements->measureLen, &sMeta, POINTER_BYTES);
+        tmp = &sMeta;
       }
-      info->currSTableMeta = sMeta->tableMeta;
-      superKV = sMeta->tags;
+      info->currSTableMeta = (*tmp)->tableMeta;
+      superKV = (*tmp)->tags;
 
       if(unlikely(taosArrayGetSize(superKV) == 0)){
         isSuperKVInit = false;
@@ -183,13 +185,13 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
         SSmlKv *maxKV = (SSmlKv *)taosArrayGet(maxKVs, cnt);
         if(unlikely(kv.length > maxKV->length)){
           maxKV->length = kv.length;
-          SSmlSTableMeta *tableMeta = (SSmlSTableMeta *)nodeListGet(info->superTables, elements->measure, elements->measureLen, NULL);
+          SSmlSTableMeta **tableMeta = (SSmlSTableMeta **)taosHashGet(info->superTables, elements->measure, elements->measureLen);
           if(unlikely(NULL == tableMeta)){
             uError("SML:0x%" PRIx64 " NULL == tableMeta", info->id);
             return TSDB_CODE_SML_INTERNAL_ERROR;
           }
 
-          SSmlKv *oldKV = (SSmlKv *)taosArrayGet(tableMeta->tags, cnt);
+          SSmlKv *oldKV = (SSmlKv *)taosArrayGet((*tableMeta)->tags, cnt);
           oldKV->length = kv.length;
           info->needModifySchema = true;
         }
@@ -229,8 +231,15 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
     taosArrayPush(preLineKV, &kv);
     cnt++;
   }
-  SSmlTableInfo *tinfo = (SSmlTableInfo *)nodeListGet(info->childTables, elements, POINTER_BYTES, is_same_child_table_telnet);
-  if (unlikely(tinfo == NULL)) {
+
+  elements->measureTag = (char*)taosMemoryMalloc(elements->measureLen + elements->tagsLen);
+  memcpy(elements->measureTag, elements->measure, elements->measureLen);
+  memcpy(elements->measureTag + elements->measureLen, elements->tags, elements->tagsLen);
+  elements->measureTagsLen = elements->measureLen + elements->tagsLen;
+
+  SSmlTableInfo **tmp = (SSmlTableInfo **)taosHashGet(info->childTables, elements->measureTag, elements->measureLen + elements->tagsLen);
+  SSmlTableInfo *tinfo = NULL;
+  if (unlikely(tmp == NULL)) {
     tinfo = smlBuildTableInfo(1, elements->measure, elements->measureLen);
     if (!tinfo) {
       return TSDB_CODE_OUT_OF_MEMORY;
@@ -249,12 +258,13 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
       }
     }
 
-    SSmlLineInfo *key = (SSmlLineInfo *)taosMemoryMalloc(sizeof(SSmlLineInfo));
-    *key = *elements;
-    tinfo->key = key;
-    nodeListSet(&info->childTables, key, POINTER_BYTES, tinfo, is_same_child_table_telnet);
+//    SSmlLineInfo *key = (SSmlLineInfo *)taosMemoryMalloc(sizeof(SSmlLineInfo));
+//    *key = *elements;
+//    tinfo->key = key;
+    taosHashPut(info->childTables, elements->measureTag, elements->measureLen + elements->tagsLen, &tinfo, POINTER_BYTES);
+    tmp = &tinfo;
   }
-  if (info->dataFormat) info->currTableDataCtx = tinfo->tableDataCtx;
+  if (info->dataFormat) info->currTableDataCtx = (*tmp)->tableDataCtx;
 
   return TSDB_CODE_SUCCESS;
 }

source/client/test/clientTests.cpp

@@ -112,7 +112,7 @@ void createNewTable(TAOS* pConn, int32_t index) {
   }
   taos_free_result(pRes);
 
-  for(int32_t i = 0; i < 20; i += 20) {
+  for(int32_t i = 0; i < 2000; i += 20) {
     char sql[1024] = {0};
     sprintf(sql,
             "insert into tu%d values(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
@@ -692,6 +692,7 @@ TEST(testCase, insert_test) {
   taos_free_result(pRes);
   taos_close(pConn);
 }
+#endif
 
 TEST(testCase, projection_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -725,7 +726,7 @@ TEST(testCase, projection_query_tables) {
   }
   taos_free_result(pRes);
 
-  for (int32_t i = 0; i < 200000; ++i) {
+  for (int32_t i = 0; i < 2; ++i) {
     printf("create table :%d\n", i);
     createNewTable(pConn, i);
   }
@@ -751,6 +752,7 @@ TEST(testCase, projection_query_tables) {
   taos_close(pConn);
 }
 
+#if 0
 TEST(testCase, tsbs_perf_test) {
   TdThread qid[20] = {0};
 
@@ -760,8 +762,6 @@ TEST(testCase, tsbs_perf_test) {
   getchar();
 }
 
-#endif
-
 TEST(testCase, projection_query_stables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
@@ -790,7 +790,6 @@ TEST(testCase, projection_query_stables) {
   taos_close(pConn);
 }
 
-#if 0
 TEST(testCase, agg_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
@@ -831,7 +830,7 @@ TEST(testCase, async_api_test) {
   ASSERT_NE(pConn, nullptr);
 
   taos_query(pConn, "use abc1");
-#if 0
+
   TAOS_RES* pRes = taos_query(pConn, "insert into tu(ts) values('2022-02-27 12:12:61')");
   if (taos_errno(pRes) != 0) {
     printf("failed, reason:%s\n", taos_errstr(pRes));
@@ -854,7 +853,6 @@ TEST(testCase, async_api_test) {
     printf("%s\n", str);
     memset(str, 0, sizeof(str));
   }
-#endif
 
   taos_query_a(pConn, "select count(*) from tu", queryCallback, pConn);
   getchar();

source/common/src/systable.c

@@ -230,6 +230,7 @@ static const SSysDbTableSchema vgroupsSchema[] = {
     {.name = "v4_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "cacheload", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
     {.name = "tsma", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = true},
+    // {.name = "compact_start_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false},
 };
 
 static const SSysDbTableSchema smaSchema[] = {

source/common/src/tglobal.c

@@ -351,7 +351,9 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "SIMD-builtins", tsSIMDBuiltins, 0) != 0) return -1;
 
   if (cfgAddInt64(pCfg, "openMax", tsOpenMax, 0, INT64_MAX, 1) != 0) return -1;
+#if !defined(_ALPINE)
   if (cfgAddInt64(pCfg, "streamMax", tsStreamMax, 0, INT64_MAX, 1) != 0) return -1;
+#endif
   if (cfgAddInt32(pCfg, "pageSizeKB", tsPageSizeKB, 0, INT64_MAX, 1) != 0) return -1;
   if (cfgAddInt64(pCfg, "totalMemoryKB", tsTotalMemoryKB, 0, INT64_MAX, 1) != 0) return -1;
   if (cfgAddString(pCfg, "os sysname", info.sysname, 1) != 0) return -1;

source/common/src/tmsg.c

@@ -3992,9 +3992,7 @@ int32_t tSerializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
-  for (int32_t i = 0; i < 8; ++i) {
-    if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1;
-  }
+  if (tEncodeI64(&encoder, pReq->compactStartTime) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -4009,9 +4007,7 @@ int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
-  for (int32_t i = 0; i < 8; ++i) {
-    if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1;
-  }
+  if (tDecodeI64(&decoder, &pReq->compactStartTime) < 0) return -1;
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
@@ -5489,6 +5485,7 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
     if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
     if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
   }
+
   if (tEncodeI8(&encoder, pReq->createStb) < 0) return -1;
   if (tEncodeU64(&encoder, pReq->targetStbUid) < 0) return -1;
   if (tEncodeI32(&encoder, taosArrayGetSize(pReq->fillNullCols)) < 0) return -1;
@@ -5498,6 +5495,7 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
     if (tEncodeI16(&encoder, pCol->colId) < 0) return -1;
     if (tEncodeI8(&encoder, pCol->type) < 0) return -1;
   }
+  if (tEncodeI8(&encoder, pReq->igUpdate) < 0) return -1;
 
   tEndEncode(&encoder);
 
@@ -5581,6 +5579,8 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
     }
   }
 
+  if (tDecodeI8(&decoder, &pReq->igUpdate) < 0) return -1;
+
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);

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

@@ -48,7 +48,7 @@ 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(SRpcMsg *pMsg);
+int32_t dmProcessGrantReq(void *pInfo, SRpcMsg *pMsg);
 
 // dmWorker.c
 int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg);

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

@@ -234,7 +234,7 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
       code = dmProcessRetrieve(pMgmt, pMsg);
       break;
     case TDMT_MND_GRANT:
-      code = dmProcessGrantReq(pMsg);
+      code = dmProcessGrantReq(&pMgmt->pData->clusterId, pMsg);
       break;
     default:
       terrno = TSDB_CODE_MSG_NOT_PROCESSED;

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

@@ -49,7 +49,7 @@ static void mmProcessRpcMsg(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   pMsg->info.node = pMgmt->pMnode;
 
   const STraceId *trace = &pMsg->info.traceId;
-  dGTrace("msg:%p, get from mnode queue", pMsg);
+  dGTrace("msg:%p, get from mnode queue, type:%s", pMsg, TMSG_INFO(pMsg->msgType));
 
   int32_t code = mndProcessRpcMsg(pMsg);
 

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

@@ -311,7 +311,7 @@ int32_t vmProcessAlterHashRangeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 
   int32_t srcVgId = req.srcVgId;
   int32_t dstVgId = req.dstVgId;
-  dInfo("vgId:%d, start to alter vnode hashrange[%u, %u), dstVgId:%d", req.srcVgId, req.hashBegin, req.hashEnd,
+  dInfo("vgId:%d, start to alter vnode hashrange:[%u, %u], dstVgId:%d", req.srcVgId, req.hashBegin, req.hashEnd,
         req.dstVgId);
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, srcVgId);
@@ -342,7 +342,7 @@ int32_t vmProcessAlterHashRangeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dInfo("vgId:%d, start to open vnode", dstVgId);
+  dInfo("vgId:%d, open vnode", dstVgId);
   SVnode *pImpl = vnodeOpen(dstPath, pMgmt->pTfs, pMgmt->msgCb);
   if (pImpl == NULL) {
     dError("vgId:%d, failed to open vnode at %s since %s", dstVgId, dstPath, terrstr());
@@ -376,7 +376,7 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   }
 
   int32_t vgId = alterReq.vgId;
-  dInfo("vgId:%d, start to alter vnode, replica:%d selfIndex:%d strict:%d", vgId, alterReq.replica, alterReq.selfIndex,
+  dInfo("vgId:%d, start to alter vnode replica:%d selfIndex:%d strict:%d", vgId, alterReq.replica, alterReq.selfIndex,
         alterReq.strict);
   for (int32_t i = 0; i < alterReq.replica; ++i) {
     SReplica *pReplica = &alterReq.replicas[i];
@@ -423,7 +423,7 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dInfo("vgId:%d, start to open vnode", vgId);
+  dInfo("vgId:%d, close vnode", vgId);
   SVnode *pImpl = vnodeOpen(path, pMgmt->pTfs, pMgmt->msgCb);
   if (pImpl == NULL) {
     dError("vgId:%d, failed to open vnode at %s since %s", vgId, path, terrstr());

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

@@ -57,7 +57,7 @@ static void vmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
   if (IsReq(pMsg)) {
     if (code != 0) {
       if (terrno != 0) code = terrno;
-      dGError("msg:%p, failed to process since %s", pMsg, terrstr(code));
+      dGError("msg:%p, failed to process since %s, type:%s", pMsg, terrstr(code), TMSG_INFO(pMsg->msgType));
     }
     vmSendRsp(pMsg, code);
   }

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

@@ -328,6 +328,7 @@ typedef struct {
   SDbCfg   cfg;
   SRWLatch lock;
   int64_t  stateTs;
+  int64_t  compactStartTime;
 } SDbObj;
 
 typedef struct {
@@ -649,6 +650,7 @@ typedef struct {
   int64_t checkpointFreq;  // ms
   int64_t currentTick;     // do not serialize
   int64_t deleteMark;
+  int8_t  igCheckUpdate;
 } SStreamObj;
 
 int32_t tEncodeSStreamObj(SEncoder* pEncoder, const SStreamObj* pObj);

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

@@ -81,7 +81,7 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
 int32_t mndTransProcessRsp(SRpcMsg *pRsp);
 void    mndTransPullup(SMnode *pMnode);
 int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans);
-void    mndTransExecute(SMnode *pMnode, STrans *pTrans);
+void    mndTransExecute(SMnode *pMnode, STrans *pTrans, bool isLeader);
 int32_t mndSetRpcInfoForDbTrans(SMnode *pMnode, SRpcMsg *pMsg, EOperType oper, const char *dbname);
 
 #ifdef __cplusplus

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

@@ -43,6 +43,7 @@ int32_t mndAddDropVnodeAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVg
 int32_t mndSetMoveVgroupsInfoToTrans(SMnode *, STrans *pTrans, int32_t dropDnodeId, bool force);
 int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb, SVgObj *pVgroup,
                                   SArray *pArray);
+int32_t mndBuildCompactVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int64_t compactTs);
 
 void *mndBuildCreateVnodeReq(SMnode *, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 void *mndBuildDropVnodeReq(SMnode *, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);

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

@@ -30,7 +30,7 @@
 #include "systable.h"
 
 #define DB_VER_NUMBER   1
-#define DB_RESERVE_SIZE 54
+#define DB_RESERVE_SIZE 46
 
 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);
 static int32_t  mndDbActionInsert(SSdb *pSdb, SDbObj *pDb);
@@ -126,6 +126,7 @@ SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER)
   SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER)
 
   SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
   SDB_SET_DATALEN(pRaw, dataPos, _OVER)
@@ -215,6 +216,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER)
   SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER)
   SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER)
 
   SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
   taosInitRWLatch(&pDb->lock);
@@ -274,6 +276,7 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
   pOld->cfg.replications = pNew->cfg.replications;
   pOld->cfg.sstTrigger = pNew->cfg.sstTrigger;
   pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize;
+  pOld->compactStartTime = pNew->compactStartTime;
   taosWUnLockLatch(&pOld->lock);
   return 0;
 }
@@ -1378,7 +1381,63 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   return 0;
 }
 
-static int32_t mndCompactDb(SMnode *pMnode, SDbObj *pDb) { return 0; }
+static int32_t mndSetCompactDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) {
+  SDbObj dbObj = {0};
+  memcpy(&dbObj, pDb, sizeof(SDbObj));
+  dbObj.compactStartTime = compactTs;
+
+  SSdbRaw *pCommitRaw = mndDbActionEncode(&dbObj);
+  if (pCommitRaw == NULL) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+    sdbFreeRaw(pCommitRaw);
+    return -1;
+  }
+
+  (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+  return 0;
+}
+
+static int32_t mndSetCompactDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) {
+  SSdb *pSdb = pMnode->pSdb;
+  void *pIter = NULL;
+
+  while (1) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+
+    if (mndVgroupInDb(pVgroup, pDb->uid)) {
+      if (mndBuildCompactVgroupAction(pMnode, pTrans, pDb, pVgroup, compactTs) != 0) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pVgroup);
+        return -1;
+      }
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  return 0;
+}
+
+static int32_t mndCompactDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
+  int64_t compactTs = taosGetTimestampMs();
+  int32_t code = -1;
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "compact-db");
+  if (pTrans == NULL) goto _OVER;
+
+  mInfo("trans:%d, used to compact db:%s", pTrans->id, pDb->name);
+  mndTransSetDbName(pTrans, pDb->name, NULL);
+  if (mndTrancCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  if (mndSetCompactDbCommitLogs(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER;
+  if (mndSetCompactDbRedoActions(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  code = 0;
+
+_OVER:
+  mndTransDrop(pTrans);
+  return code;
+}
 
 static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) {
   SMnode       *pMnode = pReq->info.node;
@@ -1402,10 +1461,11 @@ static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  code = mndCompactDb(pMnode, pDb);
+  code = mndCompactDb(pMnode, pReq, pDb);
+  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
 _OVER:
-  if (code != 0) {
+  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("db:%s, failed to process compact db req since %s", compactReq.db, terrstr());
   }
 

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

@@ -78,6 +78,7 @@ int32_t tEncodeSStreamObj(SEncoder *pEncoder, const SStreamObj *pObj) {
 
   // 3.0.20
   if (tEncodeI64(pEncoder, pObj->checkpointFreq) < 0) return -1;
+  if (tEncodeI8(pEncoder, pObj->igCheckUpdate) < 0) return -1;
 
   tEndEncode(pEncoder);
   return pEncoder->pos;
@@ -145,6 +146,7 @@ int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) {
   // 3.0.20
   if (sver >= 2) {
     if (tDecodeI64(pDecoder, &pObj->checkpointFreq) < 0) return -1;
+    if (tDecodeI8(pDecoder, &pObj->igCheckUpdate) < 0) return -1;
   }
   tEndDecode(pDecoder);
   return 0;
@@ -493,7 +495,7 @@ int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) {
     tlen += tEncodeSMqConsumerEp(buf, pConsumerEp);
     cnt++;
   }
-  if(cnt != sz) return -1;
+  if (cnt != sz) return -1;
   tlen += taosEncodeArray(buf, pSub->unassignedVgs, (FEncode)tEncodeSMqVgEp);
   tlen += taosEncodeString(buf, pSub->dbName);
   return tlen;

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

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

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

@@ -669,9 +669,9 @@ _OVER:
 
   mGDebug(
       "msg:%p, type:%s failed to process since %s, mnode restored:%d stopped:%d, sync restored:%d "
-      "role:%s, redirect numOfEps:%d inUse:%d",
+      "role:%s, redirect numOfEps:%d inUse:%d, type:%s",
       pMsg, TMSG_INFO(pMsg->msgType), terrstr(), pMnode->restored, pMnode->stopped, state.restored,
-      syncStr(state.restored), epSet.numOfEps, epSet.inUse);
+      syncStr(state.restored), epSet.numOfEps, epSet.inUse, TMSG_INFO(pMsg->msgType));
 
   if (epSet.numOfEps <= 0) return -1;
 

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

@@ -31,6 +31,8 @@
 #define MND_STREAM_VER_NUMBER   2
 #define MND_STREAM_RESERVE_SIZE 64
 
+#define MND_STREAM_MAX_NUM 10
+
 static int32_t mndStreamActionInsert(SSdb *pSdb, SStreamObj *pStream);
 static int32_t mndStreamActionDelete(SSdb *pSdb, SStreamObj *pStream);
 static int32_t mndStreamActionUpdate(SSdb *pSdb, SStreamObj *pStream, SStreamObj *pNewStream);
@@ -295,6 +297,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
   pObj->triggerParam = pCreate->maxDelay;
   pObj->watermark = pCreate->watermark;
   pObj->fillHistory = pCreate->fillHistory;
+  pObj->igCheckUpdate = pCreate->igUpdate;
 
   memcpy(pObj->sourceDb, pCreate->sourceDB, TSDB_DB_FNAME_LEN);
   SDbObj *pSourceDb = mndAcquireDb(pMnode, pCreate->sourceDB);
@@ -377,6 +380,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
       .triggerType = pObj->trigger == STREAM_TRIGGER_MAX_DELAY ? STREAM_TRIGGER_WINDOW_CLOSE : pObj->trigger,
       .watermark = pObj->watermark,
       .igExpired = pObj->igExpired,
+      .igCheckUpdate = pObj->igCheckUpdate,
   };
 
   // using ast and param to build physical plan
@@ -666,6 +670,35 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
+  {
+    int32_t numOfStream = 0;
+
+    SStreamObj *pStream = NULL;
+    void       *pIter = NULL;
+
+    while (1) {
+      pIter = sdbFetch(pMnode->pSdb, SDB_STREAM, pIter, (void **)&pStream);
+      if (pIter == NULL) {
+        if (numOfStream > MND_STREAM_MAX_NUM) {
+          mError("too many streams, no more than 10 for each database");
+          terrno = TSDB_CODE_MND_TOO_MANY_STREAMS;
+          goto _OVER;
+        }
+        break;
+      }
+
+      if (pStream->sourceDbUid == streamObj.sourceDbUid) {
+        ++numOfStream;
+      }
+      sdbRelease(pMnode->pSdb, pStream);
+      if (numOfStream > MND_STREAM_MAX_NUM) {
+        mError("too many streams, no more than 10 for each database");
+        terrno = TSDB_CODE_MND_TOO_MANY_STREAMS;
+        goto _OVER;
+      }
+    }
+  }
+
   pDb = mndAcquireDb(pMnode, streamObj.sourceDb);
   if (pDb->cfg.replications != 1) {
     mError("stream source db must have only 1 replica, but %s has %d", pDb->name, pDb->cfg.replications);

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

@@ -85,7 +85,11 @@ int32_t mndProcessWriteMsg(const SSyncFSM *pFsm, SRpcMsg *pMsg, const SFsmCbMeta
         pRaw, pMgmt->transSec, pMgmt->transSeq);
 
   if (pMeta->code == 0) {
-    sdbWriteWithoutFree(pMnode->pSdb, pRaw);
+    int32_t code = sdbWriteWithoutFree(pMnode->pSdb, pRaw);
+    if (code != 0) {
+      mError("trans:%d, failed to write to sdb since %s", transId, terrstr());
+      return 0;
+    }
     sdbSetApplyInfo(pMnode->pSdb, pMeta->index, pMeta->term, pMeta->lastConfigIndex);
   }
 
@@ -110,8 +114,9 @@ int32_t mndProcessWriteMsg(const SSyncFSM *pFsm, SRpcMsg *pMsg, const SFsmCbMeta
     taosThreadMutexUnlock(&pMgmt->lock);
     STrans *pTrans = mndAcquireTrans(pMnode, transId);
     if (pTrans != NULL) {
-      mInfo("trans:%d, execute in mnode which not leader or sync timeout", transId);
-      mndTransExecute(pMnode, pTrans);
+      mInfo("trans:%d, execute in mnode which not leader or sync timeout, createTime:%" PRId64 " saved trans:%d",
+            transId, pTrans->createdTime, pMgmt->transId);
+      mndTransExecute(pMnode, pTrans, false);
       mndReleaseTrans(pMnode, pTrans);
       // sdbWriteFile(pMnode->pSdb, SDB_WRITE_DELTA);
     } else {
@@ -368,7 +373,7 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
   taosThreadMutexLock(&pMgmt->lock);
   pMgmt->errCode = 0;
 
-  if (pMgmt->transId != 0) {
+  if (pMgmt->transId != 0 /* && pMgmt->transId != transId*/) {
     mError("trans:%d, can't be proposed since trans:%d already waiting for confirm", transId, pMgmt->transId);
     taosThreadMutexUnlock(&pMgmt->lock);
     rpcFreeCont(req.pCont);

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

@@ -572,8 +572,20 @@ static void mndTransUpdateActions(SArray *pOldArray, SArray *pNewArray) {
 }
 
 static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) {
-  mTrace("trans:%d, perform update action, old row:%p stage:%s, new row:%p stage:%s", pOld->id, pOld,
-         mndTransStr(pOld->stage), pNew, mndTransStr(pNew->stage));
+  mTrace("trans:%d, perform update action, old row:%p stage:%s create:%" PRId64 ", new row:%p stage:%s create:%" PRId64,
+         pOld->id, pOld, mndTransStr(pOld->stage), pOld->createdTime, pNew, mndTransStr(pNew->stage),
+         pNew->createdTime);
+
+  if (pOld->createdTime != pNew->createdTime) {
+    mError("trans:%d, failed to perform update action since createTime not match, old row:%p stage:%s create:%" PRId64
+           ", new row:%p stage:%s create:%" PRId64,
+           pOld->id, pOld, mndTransStr(pOld->stage), pOld->createdTime, pNew, mndTransStr(pNew->stage),
+           pNew->createdTime);
+    // only occured while sync timeout
+    terrno = TSDB_CODE_MND_TRNAS_SYNC_TIMEOUT;
+    return -1;
+  }
+
   mndTransUpdateActions(pOld->redoActions, pNew->redoActions);
   mndTransUpdateActions(pOld->undoActions, pNew->undoActions);
   mndTransUpdateActions(pOld->commitActions, pNew->commitActions);
@@ -779,16 +791,18 @@ static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) {
   }
   (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
 
-  mInfo("trans:%d, sync to other mnodes, stage:%s", pTrans->id, mndTransStr(pTrans->stage));
+  mInfo("trans:%d, sync to other mnodes, stage:%s createTime:%" PRId64, pTrans->id, mndTransStr(pTrans->stage),
+        pTrans->createdTime);
   int32_t code = mndSyncPropose(pMnode, pRaw, pTrans->id);
   if (code != 0) {
-    mError("trans:%d, failed to sync, errno:%s code:%s", pTrans->id, terrstr(), tstrerror(code));
+    mError("trans:%d, failed to sync, errno:%s code:%s createTime:%" PRId64 " saved trans:%d", pTrans->id, terrstr(),
+           tstrerror(code), pTrans->createdTime, pMnode->syncMgmt.transId);
     sdbFreeRaw(pRaw);
     return -1;
   }
 
   sdbFreeRaw(pRaw);
-  mInfo("trans:%d, sync finished", pTrans->id);
+  mInfo("trans:%d, sync finished, createTime:%" PRId64, pTrans->id, pTrans->createdTime);
   return 0;
 }
 
@@ -891,7 +905,7 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
   pTrans->rpcRsp = NULL;
   pTrans->rpcRspLen = 0;
 
-  mndTransExecute(pMnode, pNew);
+  mndTransExecute(pMnode, pNew, true);
   mndReleaseTrans(pMnode, pNew);
   return 0;
 }
@@ -1054,7 +1068,7 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) {
 
   mInfo("trans:%d, %s:%d response is received, code:0x%x, accept:0x%x retry:0x%x", transId, mndTransStr(pAction->stage),
         action, pRsp->code, pAction->acceptableCode, pAction->retryCode);
-  mndTransExecute(pMnode, pTrans);
+  mndTransExecute(pMnode, pTrans, true);
 
 _OVER:
   mndReleaseTrans(pMnode, pTrans);
@@ -1483,15 +1497,17 @@ static bool mndTransPerfromFinishedStage(SMnode *pMnode, STrans *pTrans) {
     mError("trans:%d, failed to write sdb since %s", pTrans->id, terrstr());
   }
 
-  mInfo("trans:%d, execute finished, code:0x%x, failedTimes:%d", pTrans->id, pTrans->code, pTrans->failedTimes);
+  mInfo("trans:%d, execute finished, code:0x%x, failedTimes:%d createTime:%" PRId64, pTrans->id, pTrans->code,
+        pTrans->failedTimes, pTrans->createdTime);
   return continueExec;
 }
 
-void mndTransExecute(SMnode *pMnode, STrans *pTrans) {
+void mndTransExecute(SMnode *pMnode, STrans *pTrans, bool isLeader) {
   bool continueExec = true;
 
   while (continueExec) {
-    mInfo("trans:%d, continue to execute, stage:%s", pTrans->id, mndTransStr(pTrans->stage));
+    mInfo("trans:%d, continue to execute, stage:%s createTime:%" PRId64 " leader:%d", pTrans->id,
+          mndTransStr(pTrans->stage), pTrans->createdTime, isLeader);
     pTrans->lastExecTime = taosGetTimestampMs();
     switch (pTrans->stage) {
       case TRN_STAGE_PREPARE:
@@ -1501,13 +1517,23 @@ void mndTransExecute(SMnode *pMnode, STrans *pTrans) {
         continueExec = mndTransPerformRedoActionStage(pMnode, pTrans);
         break;
       case TRN_STAGE_COMMIT:
-        continueExec = mndTransPerformCommitStage(pMnode, pTrans);
+        if (isLeader) {
+          continueExec = mndTransPerformCommitStage(pMnode, pTrans);
+        } else {
+          mInfo("trans:%d, can not commit since not leader", pTrans->id);
+          continueExec = false;
+        }
         break;
       case TRN_STAGE_COMMIT_ACTION:
         continueExec = mndTransPerformCommitActionStage(pMnode, pTrans);
         break;
       case TRN_STAGE_ROLLBACK:
-        continueExec = mndTransPerformRollbackStage(pMnode, pTrans);
+        if (isLeader) {
+          continueExec = mndTransPerformRollbackStage(pMnode, pTrans);
+        } else {
+          mInfo("trans:%d, can not rollback since not leader", pTrans->id);
+          continueExec = false;
+        }
         break;
       case TRN_STAGE_UNDO_ACTION:
         continueExec = mndTransPerformUndoActionStage(pMnode, pTrans);
@@ -1550,7 +1576,7 @@ int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans) {
     pAction->errCode = 0;
   }
 
-  mndTransExecute(pMnode, pTrans);
+  mndTransExecute(pMnode, pTrans, true);
   return 0;
 }
 
@@ -1608,7 +1634,7 @@ void mndTransPullup(SMnode *pMnode) {
     int32_t *pTransId = taosArrayGet(pArray, i);
     STrans  *pTrans = mndAcquireTrans(pMnode, *pTransId);
     if (pTrans != NULL) {
-      mndTransExecute(pMnode, pTrans);
+      mndTransExecute(pMnode, pTrans, true);
     }
     mndReleaseTrans(pMnode, pTrans);
   }

source/dnode/vnode/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(
     "src/vnd/vnodeSvr.c"
     "src/vnd/vnodeSync.c"
     "src/vnd/vnodeSnapshot.c"
+    "src/vnd/vnodeCompact.c"
 
     # meta
     "src/meta/metaOpen.c"
@@ -53,6 +54,7 @@ target_sources(
     "src/tsdb/tsdbDiskData.c"
     "src/tsdb/tsdbCompact.c"
     "src/tsdb/tsdbMergeTree.c"
+    "src/tsdb/tsdbDataIter.c"
 
     # tq
     "src/tq/tq.c"

source/dnode/vnode/inc/vnode.h

@@ -181,7 +181,6 @@ int32_t tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, void *pTableL
 
 void         tsdbReaderClose(STsdbReader *pReader);
 bool         tsdbNextDataBlock(STsdbReader *pReader);
-void         tsdbRetrieveDataBlockInfo(const STsdbReader *pReader, int32_t *rows, uint64_t *uid, STimeWindow *pWindow);
 int32_t      tsdbRetrieveDatablockSMA(STsdbReader *pReader, SSDataBlock *pDataBlock, bool *allHave);
 void         tsdbReleaseDataBlock(STsdbReader *pReader);
 SSDataBlock *tsdbRetrieveDataBlock(STsdbReader *pTsdbReadHandle, SArray *pColumnIdList);

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

@@ -209,6 +209,8 @@ static FORCE_INLINE void tdUnRefSmaStat(SSma *pSma, SSmaStat *pStat) {
   smaDebug("vgId:%d, unref sma stat:%p, val:%d", SMA_VID(pSma), pStat, ref);
 }
 
+int32_t smaPreClose(SSma *pSma);
+
 // rsma
 void   *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo, bool isDeepFree);
 int32_t tdRSmaFSOpen(SSma *pSma, int64_t version, int8_t rollback);

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

@@ -1409,6 +1409,9 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   int32_t        ret = 0;
   // get super table
   if (tdbTbGet(pMeta->pUidIdx, &pCtbEntry->ctbEntry.suid, sizeof(tb_uid_t), &pData, &nData) != 0) {
+    metaError("vgId:%d, failed to get stable suid for update. version:%" PRId64, TD_VID(pMeta->pVnode),
+              pCtbEntry->version);
+    terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
     ret = -1;
     goto end;
   }