Merge remote-tracking branch 'origin/3.0' into feat/TD-25204

2023-10-20 08:46:32 +08:00 · 2023-10-20 08:46:32 +08:00 · 42f440b0fb
parent 969b002936 614bdd9fb9
commit 42f440b0fb
83 changed files with 5015 additions and 3632 deletions
--- a/cmake/cmake.version
+++ b/cmake/cmake.version
@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.2.0.0.alpha")
+  SET(TD_VER_NUMBER "3.2.1.0.alpha")
 ENDIF ()

 IF (DEFINED VERCOMPATIBLE)
--- a/docs/en/07-develop/03-insert-data/30-influxdb-line.mdx
+++ b/docs/en/07-develop/03-insert-data/30-influxdb-line.mdx
@ -38,7 +38,10 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
 - All the data in `tag_set` will be converted to NCHAR type automatically
 - Each data in `field_set` must be self-descriptive for its data type. For example 1.2f32 means a value 1.2 of float type. Without the "f" type suffix, it will be treated as type double
 - Multiple kinds of precision can be used for the `timestamp` field. Time precision can be from nanosecond (ns) to hour (h)
- The child table name is created automatically in a rule to guarantee its uniqueness. But you can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be created automatically. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored
+- The rule of table name
+  - The child table name is created automatically in a rule to guarantee its uniqueness.
+  - You can configure `smlAutoChildTableNameDelimiter` in taos.cfg to specify a delimiter between tag values as the table names. For example, you set `smlAutoChildTableNameDelimiter=-` in taos.cfg, when you insert `st,t0=cpu1,t1=4 c1=3 1626006833639000000`, the child table will be `cpu1-4`
+  - You can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be created automatically. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored
 - It is assumed that the order of field_set in a supertable is consistent, meaning that the first record contains all fields and subsequent records store fields in the same order. If the order is not consistent, set smlDataFormat in taos.cfg to false. Otherwise, data will be written out of order and a database error will occur.(smlDataFormat in taos.cfg default to false after version of 3.0.1.3, smlDataFormat is discarded since 3.0.3.0)

 :::
--- a/docs/en/07-develop/03-insert-data/40-opentsdb-telnet.mdx
+++ b/docs/en/07-develop/03-insert-data/40-opentsdb-telnet.mdx
@ -33,7 +33,10 @@ For example:
 meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
 ```

- The child table name is created automatically in a rule to guarantee its uniqueness. But you can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
+- The rule of table name
+  - The child table name is created automatically in a rule to guarantee its uniqueness.
+  - You can configure `smlAutoChildTableNameDelimiter` in taos.cfg to specify a delimiter between tag values as the table names. For example, you set `smlAutoChildTableNameDelimiter=-` in taos.cfg, when you insert `st,t0=cpu1,t1=4 c1=3 1626006833639000000`, the child table will be `cpu1-4`
+  - You can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be created automatically. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored

  Please refer to [OpenTSDB Telnet API](http://opentsdb.net/docs/build/html/api_telnet/put.html) for more details.

--- a/docs/en/07-develop/03-insert-data/50-opentsdb-json.mdx
+++ b/docs/en/07-develop/03-insert-data/50-opentsdb-json.mdx
@ -48,7 +48,10 @@ Please refer to [OpenTSDB HTTP API](http://opentsdb.net/docs/build/html/api_http
 :::note

 - In JSON protocol, strings will be converted to NCHAR type and numeric values will be converted to double type.
- The child table name is created automatically in a rule to guarantee its uniqueness. But you can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.
+- The rule of table name
+  - The child table name is created automatically in a rule to guarantee its uniqueness.
+  - You can configure `smlAutoChildTableNameDelimiter` in taos.cfg to specify a delimiter between tag values as the table names. For example, you set `smlAutoChildTableNameDelimiter=-` in taos.cfg, when you insert `st,t0=cpu1,t1=4 c1=3 1626006833639000000`, the child table will be `cpu1-4`
+  - You can configure `smlChildTableName` in taos.cfg to specify a tag value as the table names if the tag value is unique globally. For example, if a tag is called `tname` and you set `smlChildTableName=tname` in taos.cfg, when you insert `st,tname=cpu1,t1=4 c1=3 1626006833639000000`, the child table `cpu1` will be created automatically. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored

 :::

--- a/docs/en/07-develop/07-tmq.mdx
+++ b/docs/en/07-develop/07-tmq.mdx
@ -356,6 +356,7 @@ You configure the following parameters when creating a consumer:
 |      `enable.auto.commit`      | boolean | Commit automatically; true: user application doesn't need to explicitly commit; false: user application need to handle commit by itself                                           | Default value is true                  |
 |   `auto.commit.interval.ms`    | integer | Interval for automatic commits, in milliseconds                           |
 |     `msg.with.table.name`      | boolean | Specify whether to deserialize table names from messages. Not applicable if subscribe to a column (tbname can be written as a column in the subquery statement during column subscriptions) (This parameter has been deprecated since version 3.2.0.0 and remains true)                                 | default value: false
+|     `enable.replay`            | boolean | Specify whether data replay function enabled or not                   |default value: false |

 The method of specifying these parameters depends on the language used:

@ -421,7 +422,7 @@ public class MetersDeserializer extends ReferenceDeserializer<Meters> {
 ```go
 conf := &tmq.ConfigMap{
 "group.id":                     "test",
- "auto.offset.reset":            "earliest",
+ "auto.offset.reset":            "latest",
 "td.connect.ip":                "127.0.0.1",
 "td.connect.user":              "root",
 "td.connect.pass":              "taosdata",
@ -510,7 +511,7 @@ var cfg = new ConsumerConfig
    GourpId = "TDengine-TMQ-C#",
    TDConnectUser = "root",
    TDConnectPasswd = "taosdata",
-    AutoOffsetReset = "earliest"
+    AutoOffsetReset = "latest"
    MsgWithTableName = "true",
    TDConnectIp = "127.0.0.1",
    TDConnectPort = "6030"
@ -526,6 +527,24 @@ var consumer = new ConsumerBuilder(cfg).Build();

 A consumer group is automatically created when multiple consumers are configured with the same consumer group ID.

+Data replay function description:
+- Subscription adds replay function, which replays according to the time of data writing.
+  For example, writing three pieces of data at the following time.
+  ```sql
+    2023/09/22 00:00:00.000
+    2023/09/22 00:00:05.000
+    2023/09/22 00:00:08.000
+    ```
+  After subscribing to the first data for 5 seconds, the second data is returned, and after obtaining the second data for 3 seconds, the third data is returned.
+- Only column subscriptions support data replay.
+  - Replay needs to ensure an independent timeline
+  - If it is a sub table subscription or a normal table subscription, only one vnode has data, ensuring a timeline.
+  - If subscribing to a super table, it is necessary to ensure that the DB has only one vnode, otherwise an error will be reported (because the data subscribed to on multiple vnodes is not on the same timeline).
+- Super table and database subscriptions do not support replay
+- Add the enable.replay parameter. True indicates that the subscription replay function is enabled, while false indicates that the subscription replay function is not enabled by default.
+- Replay does not support progress saving, so when the replay parameter enable, auto commit will automatically close.
+- Due to the processing time required for data replay, there is an error of tens of milliseconds in the accuracy of replay.
+
 ## Subscribe to a Topic

 A single consumer can subscribe to multiple topics.
--- a/docs/en/14-reference/03-connector/05-go.mdx
+++ b/docs/en/14-reference/03-connector/05-go.mdx
@ -794,7 +794,7 @@ The TDengine Go Connector supports subscription functionality with the following
 ```go
    consumer, err := tmq.NewConsumer(&tmqcommon.ConfigMap{
        "group.id":                     "test",
-        "auto.offset.reset":            "earliest",
+        "auto.offset.reset":            "latest",
        "td.connect.ip":                "127.0.0.1",
        "td.connect.user":              "root",
        "td.connect.pass":              "taosdata",
@ -870,6 +870,7 @@ package main
 import (
    "fmt"
    "os"
+    "time"

    "github.com/taosdata/driver-go/v3/af"
    "github.com/taosdata/driver-go/v3/af/tmq"
@ -890,19 +891,16 @@ func main() {
    if err != nil {
        panic(err)
    }
-    if err != nil {
-        panic(err)
-    }
    consumer, err := tmq.NewConsumer(&tmqcommon.ConfigMap{
-        "group.id":                     "test",
-        "auto.offset.reset":            "earliest",
-        "td.connect.ip":                "127.0.0.1",
-        "td.connect.user":              "root",
-        "td.connect.pass":              "taosdata",
-        "td.connect.port":              "6030",
-        "client.id":                    "test_tmq_client",
-        "enable.auto.commit":           "false",
-        "msg.with.table.name":          "true",
+        "group.id":            "test",
+        "auto.offset.reset":   "latest",
+        "td.connect.ip":       "127.0.0.1",
+        "td.connect.user":     "root",
+        "td.connect.pass":     "taosdata",
+        "td.connect.port":     "6030",
+        "client.id":           "test_tmq_client",
+        "enable.auto.commit":  "false",
+        "msg.with.table.name": "true",
    })
    if err != nil {
        panic(err)
@ -915,10 +913,16 @@ func main() {
    if err != nil {
        panic(err)
    }
-    _, err = db.Exec("insert into example_tmq.t1 values(now,1)")
-    if err != nil {
-        panic(err)
-    }
+    go func() {
+        for {
+            _, err = db.Exec("insert into example_tmq.t1 values(now,1)")
+            if err != nil {
+                panic(err)
+            }
+            time.Sleep(time.Millisecond * 100)
+        }
+    }()
+
    for i := 0; i < 5; i++ {
        ev := consumer.Poll(500)
        if ev != nil {
@ -972,6 +976,7 @@ package main
 import (
    "database/sql"
    "fmt"
+    "time"

    "github.com/taosdata/driver-go/v3/common"
    tmqcommon "github.com/taosdata/driver-go/v3/common/tmq"
@ -995,7 +1000,7 @@ func main() {
        "td.connect.pass":       "taosdata",
        "group.id":              "example",
        "client.id":             "example_consumer",
-        "auto.offset.reset":     "earliest",
+        "auto.offset.reset":     "latest",
    })
    if err != nil {
        panic(err)
@ -1004,29 +1009,34 @@ func main() {
    if err != nil {
        panic(err)
    }
+
+    _, err = db.Exec("create table example_ws_tmq.t_all(ts timestamp," +
+        "c1 bool," +
+        "c2 tinyint," +
+        "c3 smallint," +
+        "c4 int," +
+        "c5 bigint," +
+        "c6 tinyint unsigned," +
+        "c7 smallint unsigned," +
+        "c8 int unsigned," +
+        "c9 bigint unsigned," +
+        "c10 float," +
+        "c11 double," +
+        "c12 binary(20)," +
+        "c13 nchar(20)" +
+        ")")
+    if err != nil {
+        panic(err)
+    }
    go func() {
-        _, err := db.Exec("create table example_ws_tmq.t_all(ts timestamp," +
-            "c1 bool," +
-            "c2 tinyint," +
-            "c3 smallint," +
-            "c4 int," +
-            "c5 bigint," +
-            "c6 tinyint unsigned," +
-            "c7 smallint unsigned," +
-            "c8 int unsigned," +
-            "c9 bigint unsigned," +
-            "c10 float," +
-            "c11 double," +
-            "c12 binary(20)," +
-            "c13 nchar(20)" +
-            ")")
-        if err != nil {
-            panic(err)
-        }
-        _, err = db.Exec("insert into example_ws_tmq.t_all values(now,true,2,3,4,5,6,7,8,9,10.123,11.123,'binary','nchar')")
-        if err != nil {
-            panic(err)
+        for {
+            _, err = db.Exec("insert into example_ws_tmq.t_all values(now,true,2,3,4,5,6,7,8,9,10.123,11.123,'binary','nchar')")
+            if err != nil {
+                panic(err)
+            }
+            time.Sleep(time.Millisecond * 100)
        }
+
    }()
    for i := 0; i < 5; i++ {
        ev := consumer.Poll(500)
--- a/docs/en/14-reference/03-connector/06-rust.mdx
+++ b/docs/en/14-reference/03-connector/06-rust.mdx
@ -442,7 +442,7 @@ The following parameters can be configured for the TMQ DSN. Only `group.id` is m

 - `group.id`: Within a consumer group, load balancing is implemented by consuming messages on an at-least-once basis.
 - `client.id`: Subscriber client ID.
- `auto.offset.reset`: Initial point of subscription. *earliest* subscribes from the beginning, and *latest* subscribes from the newest message. The default is earliest. Note: This parameter is set per consumer group.
+- `auto.offset.reset`: Initial point of subscription. *earliest* subscribes from the beginning, and *latest* subscribes from the newest message. The default value varies depending on the TDengine version. For details, see [Data Subscription](https://docs.tdengine.com/develop/tmq/). Note: This parameter is set per consumer group.
 - `enable.auto.commit`: Automatically commits. This can be enabled when data consistency is not essential.
 - `auto.commit.interval.ms`: Interval for automatic commits.

--- a/docs/en/14-reference/12-config/index.md
+++ b/docs/en/14-reference/12-config/index.md
@ -652,6 +652,15 @@ The charset that takes effect is UTF-8.
 | Type          | String                                     |
 | Default Value | None                                       |

+### smlAutoChildTableNameDelimiter
+
+| Attribute     | Description                                |
+| ------------- | ------------------------------------------ |
+| Applicable    | Client only                                |
+| Meaning       | Delimiter between tags as table name|
+| Type          | String                                     |
+| Default Value | None                                       |
+
 ### smlTagName

 | Attribute     | Description                                                   |
--- a/docs/en/14-reference/13-schemaless/13-schemaless.md
+++ b/docs/en/14-reference/13-schemaless/13-schemaless.md
@ -93,6 +93,8 @@ Note that tag_key1, tag_key2 are not the original order of the tags entered by t
 The string's MD5 hash value "md5_val" is calculated after the ranking is completed. The calculation result is then combined with the string to generate the table name: "t_md5_val". "t\_" is a fixed prefix that every table generated by this mapping relationship has.
 :::

+If you do not want to use an automatically generated table name, there are two ways to specify sub table names, the first one has a higher priority.
+You can configure smlAutoChildTableNameDelimiter in taos.cfg, for example, `smlAutoChildTableNameDelimiter=tname`. You can insert `st,t0=cpul,t1=4 c1=3 1626006833639000000` and the table name will be cpu1-4.
 You can configure smlChildTableName in taos.cfg to specify table names, for example, `smlChildTableName=tname`. You can insert `st,tname=cpul,t1=4 c1=3 1626006833639000000` and the cpu1 table will be automatically created. Note that if multiple rows have the same tname but different tag_set values, the tag_set of the first row is used to create the table and the others are ignored.

 2. If the super table obtained by parsing the line protocol does not exist, this super table is created.
--- a/docs/en/28-releases/01-tdengine.md
+++ b/docs/en/28-releases/01-tdengine.md
@ -10,6 +10,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://t

 import Release from "/components/ReleaseV3";

+## 3.2.0.0
+
+<Release type="tdengine" version="3.2.0.0" />
+
 ## 3.1.1.0

 <Release type="tdengine" version="3.1.1.0" />
--- a/docs/examples/go/sub/main.go
+++ b/docs/examples/go/sub/main.go
@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"time"

 	"github.com/taosdata/driver-go/v3/af"
 	"github.com/taosdata/driver-go/v3/af/tmq"
@ -27,15 +28,15 @@ func main() {
 		panic(err)
 	}
 	consumer, err := tmq.NewConsumer(&tmqcommon.ConfigMap{
-		"group.id":                     "test",
-		"auto.offset.reset":            "earliest",
-		"td.connect.ip":                "127.0.0.1",
-		"td.connect.user":              "root",
-		"td.connect.pass":              "taosdata",
-		"td.connect.port":              "6030",
-		"client.id":                    "test_tmq_client",
-		"enable.auto.commit":           "false",
-		"msg.with.table.name":          "true",
+		"group.id":            "test",
+		"auto.offset.reset":   "latest",
+		"td.connect.ip":       "127.0.0.1",
+		"td.connect.user":     "root",
+		"td.connect.pass":     "taosdata",
+		"td.connect.port":     "6030",
+		"client.id":           "test_tmq_client",
+		"enable.auto.commit":  "false",
+		"msg.with.table.name": "true",
 	})
 	if err != nil {
 		panic(err)
@ -48,12 +49,17 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	_, err = db.Exec("insert into example_tmq.t1 values(now,1)")
-	if err != nil {
-		panic(err)
-	}
+	go func() {
+		for {
+			_, err = db.Exec("insert into example_tmq.t1 values(now,1)")
+			if err != nil {
+				panic(err)
+			}
+			time.Sleep(time.Microsecond * 100)
+		}
+	}()
 	for i := 0; i < 5; i++ {
-		ev := consumer.Poll(0)
+		ev := consumer.Poll(500)
 		if ev != nil {
 			switch e := ev.(type) {
 			case *tmqcommon.DataMessage:
--- a/docs/zh/07-develop/03-insert-data/30-influxdb-line.mdx
+++ b/docs/zh/07-develop/03-insert-data/30-influxdb-line.mdx
@ -38,7 +38,10 @@ meters,location=California.LosAngeles,groupid=2 current=13.4,voltage=223,phase=0
 - field_set 中的每个数据项都需要对自身的数据类型进行描述, 比如 1.2f32 代表 FLOAT 类型的数值 1.2, 如果不带类型后缀会被当作 DOUBLE 处理
 - timestamp 支持多种时间精度。写入数据的时候需要用参数指定时间精度，支持从小时到纳秒的 6 种时间精度
 - 为了提高写入的效率，默认假设同一个超级表中 field_set 的顺序是一样的（第一条数据包含所有的 field，后面的数据按照这个顺序），如果顺序不一样，需要配置参数 smlDataFormat 为 false，否则，数据写入按照相同顺序写入，库中数据会异常。（3.0.1.3 之后的版本 smlDataFormat 默认为 false，从3.0.3.0开始，该配置废弃） [TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
- 默认产生的子表名是根据规则生成的唯一 ID 值。用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1。注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
+- 子表名生成规则
+  - 默认产生的子表名是根据规则生成的唯一 ID 值。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlAutoChildTableNameDelimiter 参数来指定连接标签之间的分隔符，连接起来后作为子表名。举例如下：配置 smlAutoChildTableNameDelimiter=-, 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1-4。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1。注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)

 :::

--- a/docs/zh/07-develop/03-insert-data/40-opentsdb-telnet.mdx
+++ b/docs/zh/07-develop/03-insert-data/40-opentsdb-telnet.mdx
@ -31,8 +31,11 @@ OpenTSDB 行协议同样采用一行字符串来表示一行数据。OpenTSDB
 ```txt
 meters.current 1648432611250 11.3 location=California.LosAngeles groupid=3
 ```
+- 子表名生成规则
+  - 默认产生的子表名是根据规则生成的唯一 ID 值。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlAutoChildTableNameDelimiter 参数来指定连接标签之间的分隔符，连接起来后作为子表名。举例如下：配置 smlAutoChildTableNameDelimiter=-, 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1-4。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1。注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)

- 默认生产的子表名是根据规则生成的唯一 ID 值。用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 meters.current 1648432611250 11.3 tname=cpu1 location=California.LosAngeles groupid=3 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
  参考 [OpenTSDB Telnet API 文档](http://opentsdb.net/docs/build/html/api_telnet/put.html)。

 ## 示例代码
--- a/docs/zh/07-develop/03-insert-data/50-opentsdb-json.mdx
+++ b/docs/zh/07-develop/03-insert-data/50-opentsdb-json.mdx
@ -47,7 +47,10 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
 :::note

 - 对于 JSON 格式协议，TDengine 并不会自动把所有标签转成 NCHAR 类型， 字符串将将转为 NCHAR 类型， 数值将同样转换为 DOUBLE 类型。
- 默认生成的子表名是根据规则生成的唯一 ID 值。用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 `"tags": { "host": "web02","dc": "lga","tname":"cpu1"}` 则创建的子表名为 cpu1。注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。
+- 子表名生成规则
+  - 默认产生的子表名是根据规则生成的唯一 ID 值。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlAutoChildTableNameDelimiter 参数来指定连接标签之间的分隔符，连接起来后作为子表名。举例如下：配置 smlAutoChildTableNameDelimiter=-, 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1-4。
+  - 用户也可以通过在client端的 taos.cfg 里配置 smlChildTableName 参数来指定某个标签值作为子表名。该标签值应该具有全局唯一性。举例如下：假设有个标签名为tname, 配置 smlChildTableName=tname, 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的子表名为 cpu1。注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。[TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)

 :::

--- a/docs/zh/07-develop/07-tmq.md
+++ b/docs/zh/07-develop/07-tmq.md
@ -355,6 +355,7 @@ CREATE TOPIC topic_name [with meta] AS DATABASE db_name;
 |      `enable.auto.commit`      | boolean | 是否启用消费位点自动提交，true: 自动提交，客户端应用无需commit；false：客户端应用需要自行commit     | 默认值为 true                   |
 |   `auto.commit.interval.ms`    | integer | 消费记录自动提交消费位点时间间隔，单位为毫秒           | 默认值为 5000                                |
 |     `msg.with.table.name`      | boolean | 是否允许从消息中解析表名, 不适用于列订阅（列订阅时可将 tbname 作为列写入 subquery 语句）（从3.2.0.0版本该参数废弃，恒为true）               |默认关闭 |
+|     `enable.replay`            | boolean | 是否开启数据回放功能               |默认关闭 |

 对于不同编程语言，其设置方式如下：

@ -420,7 +421,7 @@ public class MetersDeserializer extends ReferenceDeserializer<Meters> {
 ```go
 conf := &tmq.ConfigMap{
 "group.id":                     "test",
- "auto.offset.reset":            "earliest",
+ "auto.offset.reset":            "latest",
 "td.connect.ip":                "127.0.0.1",
 "td.connect.user":              "root",
 "td.connect.pass":              "taosdata",
@ -511,7 +512,7 @@ var cfg = new ConsumerConfig
    GourpId = "TDengine-TMQ-C#",
    TDConnectUser = "root",
    TDConnectPasswd = "taosdata",
-    AutoOffsetReset = "earliest"
+    AutoOffsetReset = "latest"
    MsgWithTableName = "true",
    TDConnectIp = "127.0.0.1",
    TDConnectPort = "6030"
@ -527,6 +528,24 @@ var consumer = new ConsumerBuilder(cfg).Build();

 上述配置中包括 consumer group ID，如果多个 consumer 指定的 consumer group ID 一样，则自动形成一个 consumer group，共享消费进度。

+数据回放功能说明：
+- 订阅增加 replay 功能，按照数据写入的时间回放。
+  比如，如下时间写入三条数据
+  ```sql
+    2023/09/22 00:00:00.000
+    2023/09/22 00:00:05.000
+    2023/09/22 00:00:08.000
+    ```
+  则订阅出第一条数据 5s 后返回第二条数据，获取第二条数据 3s 后返回第三条数据。
+- 仅列订阅支持数据回放
+  - 回放需要保证独立时间线
+  - 如果是子表订阅或者普通表订阅，只有一个vnode上有数据，保证是一个时间线
+  - 如果超级表订阅，则需保证该 DB 只有一个vnode，否则报错（因为多个vnode上订阅出的数据不在一个时间线上）
+- 超级表和库订阅不支持回放
+- 增加 enable.replay 参数，true表示开启订阅回放功能，false表示不开启订阅回放功能，默认不开启。
+- 回放不支持进度保存，所以回放参数 enable.replay = true 时，auto commit 自动关闭
+- 因为数据回放本身需要处理时间，所以回放的精度存在几十ms的误差
+
 ## 订阅 *topics*

 一个 consumer 支持同时订阅多个 topic。
--- a/docs/zh/08-connector/20-go.mdx
+++ b/docs/zh/08-connector/20-go.mdx
@ -797,7 +797,7 @@ TDengine Go 连接器支持订阅功能，应用 API 如下：
 ```go
    consumer, err := tmq.NewConsumer(&tmqcommon.ConfigMap{
        "group.id":                     "test",
-        "auto.offset.reset":            "earliest",
+        "auto.offset.reset":            "latest",
        "td.connect.ip":                "127.0.0.1",
        "td.connect.user":              "root",
        "td.connect.pass":              "taosdata",
@ -873,6 +873,7 @@ package main
 import (
    "fmt"
    "os"
+    "time"

    "github.com/taosdata/driver-go/v3/af"
    "github.com/taosdata/driver-go/v3/af/tmq"
@ -893,19 +894,16 @@ func main() {
    if err != nil {
        panic(err)
    }
-    if err != nil {
-        panic(err)
-    }
    consumer, err := tmq.NewConsumer(&tmqcommon.ConfigMap{
-        "group.id":                     "test",
-        "auto.offset.reset":            "earliest",
-        "td.connect.ip":                "127.0.0.1",
-        "td.connect.user":              "root",
-        "td.connect.pass":              "taosdata",
-        "td.connect.port":              "6030",
-        "client.id":                    "test_tmq_client",
-        "enable.auto.commit":           "false",
-        "msg.with.table.name":          "true",
+        "group.id":            "test",
+        "auto.offset.reset":   "latest",
+        "td.connect.ip":       "127.0.0.1",
+        "td.connect.user":     "root",
+        "td.connect.pass":     "taosdata",
+        "td.connect.port":     "6030",
+        "client.id":           "test_tmq_client",
+        "enable.auto.commit":  "false",
+        "msg.with.table.name": "true",
    })
    if err != nil {
        panic(err)
@ -918,10 +916,16 @@ func main() {
    if err != nil {
        panic(err)
    }
-    _, err = db.Exec("insert into example_tmq.t1 values(now,1)")
-    if err != nil {
-        panic(err)
-    }
+    go func() {
+        for {
+            _, err = db.Exec("insert into example_tmq.t1 values(now,1)")
+            if err != nil {
+                panic(err)
+            }
+            time.Sleep(time.Millisecond * 100)
+        }
+    }()
+
    for i := 0; i < 5; i++ {
        ev := consumer.Poll(500)
        if ev != nil {
@ -975,6 +979,7 @@ package main
 import (
    "database/sql"
    "fmt"
+    "time"

    "github.com/taosdata/driver-go/v3/common"
    tmqcommon "github.com/taosdata/driver-go/v3/common/tmq"
@ -998,7 +1003,7 @@ func main() {
        "td.connect.pass":       "taosdata",
        "group.id":              "example",
        "client.id":             "example_consumer",
-        "auto.offset.reset":     "earliest",
+        "auto.offset.reset":     "latest",
    })
    if err != nil {
        panic(err)
@ -1007,29 +1012,34 @@ func main() {
    if err != nil {
        panic(err)
    }
+
+    _, err = db.Exec("create table example_ws_tmq.t_all(ts timestamp," +
+        "c1 bool," +
+        "c2 tinyint," +
+        "c3 smallint," +
+        "c4 int," +
+        "c5 bigint," +
+        "c6 tinyint unsigned," +
+        "c7 smallint unsigned," +
+        "c8 int unsigned," +
+        "c9 bigint unsigned," +
+        "c10 float," +
+        "c11 double," +
+        "c12 binary(20)," +
+        "c13 nchar(20)" +
+        ")")
+    if err != nil {
+        panic(err)
+    }
    go func() {
-        _, err := db.Exec("create table example_ws_tmq.t_all(ts timestamp," +
-            "c1 bool," +
-            "c2 tinyint," +
-            "c3 smallint," +
-            "c4 int," +
-            "c5 bigint," +
-            "c6 tinyint unsigned," +
-            "c7 smallint unsigned," +
-            "c8 int unsigned," +
-            "c9 bigint unsigned," +
-            "c10 float," +
-            "c11 double," +
-            "c12 binary(20)," +
-            "c13 nchar(20)" +
-            ")")
-        if err != nil {
-            panic(err)
-        }
-        _, err = db.Exec("insert into example_ws_tmq.t_all values(now,true,2,3,4,5,6,7,8,9,10.123,11.123,'binary','nchar')")
-        if err != nil {
-            panic(err)
+        for {
+            _, err = db.Exec("insert into example_ws_tmq.t_all values(now,true,2,3,4,5,6,7,8,9,10.123,11.123,'binary','nchar')")
+            if err != nil {
+                panic(err)
+            }
+            time.Sleep(time.Millisecond * 100)
        }
+
    }()
    for i := 0; i < 5; i++ {
        ev := consumer.Poll(500)
--- a/docs/zh/08-connector/26-rust.mdx
+++ b/docs/zh/08-connector/26-rust.mdx
@ -447,7 +447,7 @@ consumer.unsubscribe().await;

 - `group.id`: 同一个消费者组，将以至少消费一次的方式进行消息负载均衡。
 - `client.id`: 可选的订阅客户端识别项。
- `auto.offset.reset`: 可选初始化订阅起点， *earliest* 为从头开始订阅， *latest* 为仅从最新数据开始订阅，默认为从头订阅。注意，此选项在同一个 `group.id` 中仅生效一次。
+- `auto.offset.reset`: 可选初始化订阅起点， *earliest* 为从头开始订阅， *latest* 为仅从最新数据开始订阅，默认值根据 TDengine 版本有所不同，详细参见 [数据订阅](https://docs.taosdata.com/develop/tmq/)。注意，此选项在同一个 `group.id` 中仅生效一次。
 - `enable.auto.commit`: 当设置为 `true` 时，将启用自动标记模式，当对数据一致性不敏感时，可以启用此方式。
 - `auto.commit.interval.ms`: 自动标记的时间间隔。

--- a/docs/zh/14-reference/12-config/index.md
+++ b/docs/zh/14-reference/12-config/index.md
@ -648,7 +648,16 @@ charset 的有效值是 UTF-8。
 | 适用范围 | 仅客户端适用                    |
 | 含义     | schemaless 自定义的子表名的 key |
 | 类型     | 字符串                          |
-| 缺省值   | 无                              |
+| 缺省值   | 无  
+
+### smlAutoChildTableNameDelimiter
+
+| 属性     | 说明                            |
+| -------- | ------------------------------- |
+| 适用范围 | 仅客户端适用                    |
+| 含义     | schemaless tag之间的连接符，连起来作为子表名 |
+| 类型     | 字符串                          |
+| 缺省值   | 无  |

 ### smlTagName

--- a/docs/zh/14-reference/13-schemaless/13-schemaless.md
+++ b/docs/zh/14-reference/13-schemaless/13-schemaless.md
@ -94,8 +94,11 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
 :::tip
 需要注意的是，这里的 tag_key1, tag_key2 并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
 排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名：“t_md5_val”。其中的 “t_” 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
-:::tip 
-为了让用户可以指定生成的表名，可以通过在taos.cfg里配置 smlChildTableName 参数来指定。
+:::tip
+如果不想用自动生成的表名，有两种指定子表名的方式，第一种优先级更高：
+通过在taos.cfg里配置 smlAutoChildTableNameDelimiter 参数来指定。
+举例如下：配置 smlAutoChildTableNameDelimiter=- 插入数据为 st,t0=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1-4。
+通过在taos.cfg里配置 smlChildTableName 参数来指定。
 举例如下：配置 smlChildTableName=tname 插入数据为 st,tname=cpu1,t1=4 c1=3 1626006833639000000 则创建的表名为 cpu1，注意如果多行数据 tname 相同，但是后面的 tag_set 不同，则使用第一行自动建表时指定的 tag_set，其他的行会忽略）。

 2. 如果解析行协议获得的超级表不存在，则会创建这个超级表（不建议手动创建超级表，不然插入数据可能异常）。
--- a/docs/zh/28-releases/01-tdengine.md
+++ b/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.2.0.0
+
+<Release type="tdengine" version="3.2.0.0" />
+
 ## 3.1.1.0

 <Release type="tdengine" version="3.1.1.0" />
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -179,6 +179,7 @@ extern char tsUdfdLdLibPath[];

 // schemaless
 extern char tsSmlChildTableName[];
+extern char tsSmlAutoChildTableNameDelimiter[];
 extern char tsSmlTagName[];
 extern bool tsSmlDot2Underline;
 extern char tsSmlTsDefaultName[];
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -2374,17 +2374,6 @@ int32_t tSerializeSCMCreateStreamReq(void* buf, int32_t bufLen, const SCMCreateS
 int32_t tDeserializeSCMCreateStreamReq(void* buf, int32_t bufLen, SCMCreateStreamReq* pReq);
 void    tFreeSCMCreateStreamReq(SCMCreateStreamReq* pReq);

-typedef struct {
-  char    name[TSDB_STREAM_FNAME_LEN];
-  int64_t streamId;
-  char*   sql;
-  char*   executorMsg;
-} SMVCreateStreamReq, SMSCreateStreamReq;
-
-typedef struct {
-  int64_t streamId;
-} SMVCreateStreamRsp, SMSCreateStreamRsp;
-
 enum {
  TOPIC_SUB_TYPE__DB = 1,
  TOPIC_SUB_TYPE__TABLE,
@ -2406,16 +2395,9 @@ int32_t tSerializeSCMCreateTopicReq(void* buf, int32_t bufLen, const SCMCreateTo
 int32_t tDeserializeSCMCreateTopicReq(void* buf, int32_t bufLen, SCMCreateTopicReq* pReq);
 void    tFreeSCMCreateTopicReq(SCMCreateTopicReq* pReq);

-typedef struct {
-  int64_t topicId;
-} SCMCreateTopicRsp;
-
-int32_t tSerializeSCMCreateTopicRsp(void* buf, int32_t bufLen, const SCMCreateTopicRsp* pRsp);
-int32_t tDeserializeSCMCreateTopicRsp(void* buf, int32_t bufLen, SCMCreateTopicRsp* pRsp);
-
 typedef struct {
  int64_t consumerId;
-} SMqConsumerLostMsg, SMqConsumerRecoverMsg, SMqConsumerClearMsg;
+} SMqConsumerRecoverMsg, SMqConsumerClearMsg;

 typedef struct {
  int64_t consumerId;
@ -2427,6 +2409,7 @@ typedef struct {
  int8_t  autoCommit;
  int32_t autoCommitInterval;
  int8_t  resetOffsetCfg;
+  int8_t  enableReplay;
 } SCMSubscribeReq;

 static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubscribeReq* pReq) {
@ -2446,6 +2429,7 @@ static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubsc
  tlen += taosEncodeFixedI8(buf, pReq->autoCommit);
  tlen += taosEncodeFixedI32(buf, pReq->autoCommitInterval);
  tlen += taosEncodeFixedI8(buf, pReq->resetOffsetCfg);
+  tlen += taosEncodeFixedI8(buf, pReq->enableReplay);

  return tlen;
 }
@ -2469,71 +2453,7 @@ static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq
  buf = taosDecodeFixedI8(buf, &pReq->autoCommit);
  buf = taosDecodeFixedI32(buf, &pReq->autoCommitInterval);
  buf = taosDecodeFixedI8(buf, &pReq->resetOffsetCfg);
-  return buf;
-}
-
-typedef struct SMqSubTopic {
-  int32_t vgId;
-  int64_t topicId;
-  SEpSet  epSet;
-} SMqSubTopic;
-
-typedef struct {
-  int32_t     topicNum;
-  SMqSubTopic topics[];
-} SCMSubscribeRsp;
-
-static FORCE_INLINE int32_t tSerializeSCMSubscribeRsp(void** buf, const SCMSubscribeRsp* pRsp) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pRsp->topicNum);
-  for (int32_t i = 0; i < pRsp->topicNum; i++) {
-    tlen += taosEncodeFixedI32(buf, pRsp->topics[i].vgId);
-    tlen += taosEncodeFixedI64(buf, pRsp->topics[i].topicId);
-    tlen += taosEncodeSEpSet(buf, &pRsp->topics[i].epSet);
-  }
-  return tlen;
-}
-
-static FORCE_INLINE void* tDeserializeSCMSubscribeRsp(void* buf, SCMSubscribeRsp* pRsp) {
-  buf = taosDecodeFixedI32(buf, &pRsp->topicNum);
-  for (int32_t i = 0; i < pRsp->topicNum; i++) {
-    buf = taosDecodeFixedI32(buf, &pRsp->topics[i].vgId);
-    buf = taosDecodeFixedI64(buf, &pRsp->topics[i].topicId);
-    buf = taosDecodeSEpSet(buf, &pRsp->topics[i].epSet);
-  }
-  return buf;
-}
-
-typedef struct {
-  int64_t topicId;
-  int64_t consumerId;
-  int64_t consumerGroupId;
-  int64_t offset;
-  char*   sql;
-  char*   logicalPlan;
-  char*   physicalPlan;
-} SMVSubscribeReq;
-
-static FORCE_INLINE int32_t tSerializeSMVSubscribeReq(void** buf, SMVSubscribeReq* pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pReq->topicId);
-  tlen += taosEncodeFixedI64(buf, pReq->consumerId);
-  tlen += taosEncodeFixedI64(buf, pReq->consumerGroupId);
-  tlen += taosEncodeFixedI64(buf, pReq->offset);
-  tlen += taosEncodeString(buf, pReq->sql);
-  tlen += taosEncodeString(buf, pReq->logicalPlan);
-  tlen += taosEncodeString(buf, pReq->physicalPlan);
-  return tlen;
-}
-
-static FORCE_INLINE void* tDeserializeSMVSubscribeReq(void* buf, SMVSubscribeReq* pReq) {
-  buf = taosDecodeFixedI64(buf, &pReq->topicId);
-  buf = taosDecodeFixedI64(buf, &pReq->consumerId);
-  buf = taosDecodeFixedI64(buf, &pReq->consumerGroupId);
-  buf = taosDecodeFixedI64(buf, &pReq->offset);
-  buf = taosDecodeString(buf, &pReq->sql);
-  buf = taosDecodeString(buf, &pReq->logicalPlan);
-  buf = taosDecodeString(buf, &pReq->physicalPlan);
+  buf = taosDecodeFixedI8(buf, &pReq->enableReplay);
  return buf;
 }

@ -3629,6 +3549,7 @@ typedef struct {
  int64_t      consumerId;
  int64_t      timeout;
  STqOffsetVal reqOffset;
+  int8_t       enableReplay;
 } SMqPollReq;

 int32_t tSerializeSMqPollReq(void* buf, int32_t bufLen, SMqPollReq* pReq);
@ -3688,6 +3609,7 @@ typedef struct {
  SArray*      blockData;
  SArray*      blockTbName;
  SArray*      blockSchema;
+  int64_t      sleepTime;
 } SMqDataRsp;

 int32_t tEncodeMqDataRsp(SEncoder* pEncoder, const SMqDataRsp* pRsp);
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@ -368,6 +368,7 @@



+
 #define TK_NK_SPACE         600
 #define TK_NK_COMMENT       601
 #define TK_NK_ILLEGAL       602
--- a/include/libs/executor/storageapi.h
+++ b/include/libs/executor/storageapi.h
@ -227,6 +227,7 @@ typedef struct SStoreTqReader {
  bool (*tqReaderNextBlockInWal)();
  bool (*tqNextBlockImpl)();  // todo remove it
  SSDataBlock* (*tqGetResultBlock)();
+  int64_t (*tqGetResultBlockTime)();

  void (*tqReaderSetColIdList)();
  int32_t (*tqReaderSetQueryTableList)();
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@ -35,6 +35,7 @@ typedef struct SRawExprNode {
  char*     p;
  uint32_t  n;
  SNode*    pNode;
+  bool isPseudoColumn;
 } SRawExprNode;

 typedef struct SDataType {
--- a/include/libs/stream/tstreamFileState.h
+++ b/include/libs/stream/tstreamFileState.h
@ -79,6 +79,9 @@ int32_t getSessionFlushedBuff(SStreamFileState* pFileState, SSessionKey* pKey, v
 int32_t deleteSessionWinStateBuffFn(void* pBuff, const void *key, size_t keyLen);
 int32_t deleteSessionWinStateBuffByPosFn(SStreamFileState* pFileState, SRowBuffPos* pPos);

+SRowBuffPos* createSessionWinBuff(SStreamFileState* pFileState, SSessionKey* pKey, void* p, int32_t* pVLen);
+int32_t      recoverSesssion(SStreamFileState* pFileState, int64_t ckId);
+
 void sessionWinStateClear(SStreamFileState* pFileState);
 void sessionWinStateCleanup(void* pBuff);

--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -810,6 +810,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TMQ_NEED_INITIALIZED           TAOS_DEF_ERROR_CODE(0, 0x4010)
 #define TSDB_CODE_TMQ_NO_COMMITTED               TAOS_DEF_ERROR_CODE(0, 0x4011)
 #define TSDB_CODE_TMQ_SAME_COMMITTED_VALUE       TAOS_DEF_ERROR_CODE(0, 0x4012)
+#define TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP     TAOS_DEF_ERROR_CODE(0, 0x4013)
+#define TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT         TAOS_DEF_ERROR_CODE(0, 0x4014)

 // stream
 #define TSDB_CODE_STREAM_TASK_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x4100)
--- a/include/util/tbloomfilter.h
+++ b/include/util/tbloomfilter.h
@ -24,6 +24,9 @@
 extern "C" {
 #endif

+#define HASH_FUNCTION_1 taosFastHash
+#define HASH_FUNCTION_2 taosDJB2Hash
+
 typedef struct SBloomFilter {
  uint32_t   hashFunctions;
  uint64_t   expectedEntries;
@ -37,8 +40,9 @@ typedef struct SBloomFilter {
 } SBloomFilter;

 SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate);
+int32_t       tBloomFilterPutHash(SBloomFilter *pBF, uint64_t hash1, uint64_t hash2);
 int32_t       tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len);
-int32_t       tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf, uint32_t len);
+int32_t       tBloomFilterNoContain(const SBloomFilter *pBF, uint64_t h1, uint64_t h2);
 void          tBloomFilterDestroy(SBloomFilter *pBF);
 void          tBloomFilterDump(const SBloomFilter *pBF);
 bool          tBloomFilterIsFull(const SBloomFilter *pBF);
--- a/include/util/tscalablebf.h
+++ b/include/util/tscalablebf.h
@ -26,9 +26,12 @@ typedef struct SScalableBf {
  SArray  *bfArray;  // array of bloom filters
  uint32_t growth;
  uint64_t numBits;
+  _hash_fn_t hashFn1;
+  _hash_fn_t hashFn2;
 } SScalableBf;

 SScalableBf *tScalableBfInit(uint64_t expectedEntries, double errorRate);
+int32_t      tScalableBfPutNoCheck(SScalableBf *pSBf, const void *keyBuf, uint32_t len);
 int32_t      tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len);
 int32_t      tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf, uint32_t len);
 void         tScalableBfDestroy(SScalableBf *pSBf);
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@ -719,6 +719,21 @@ int taos_init() {

 int taos_options_imp(TSDB_OPTION option, const char *str) {
  if (option == TSDB_OPTION_CONFIGDIR) {
+#ifndef WINDOWS
+    char newstr[PATH_MAX];
+    int  len = strlen(str);
+    if (len > 1 && str[0] != '"' && str[0] != '\'') {
+        if (len + 2 >= PATH_MAX) {
+        tscError("Too long path %s", str);
+        return -1;
+      }
+      newstr[0] = '"';
+      strncpy(newstr+1, str, len);
+      newstr[len + 1] = '"';
+      newstr[len + 2] = '\0';
+      str = newstr;
+    }
+#endif
    tstrncpy(configDir, str, PATH_MAX);
    tscInfo("set cfg:%s to %s", configDir, str);
    return 0;
--- a/source/client/src/clientSml.c
+++ b/source/client/src/clientSml.c
@ -193,20 +193,46 @@ cleanup:
 }

 static int32_t smlParseTableName(SArray *tags, char *childTableName) {
-  size_t childTableNameLen = strlen(tsSmlChildTableName);
-  if (childTableNameLen <= 0) return TSDB_CODE_SUCCESS;
-
-  for (int i = 0; i < taosArrayGetSize(tags); i++) {
-    SSmlKv *tag = (SSmlKv *)taosArrayGet(tags, i);
-    // handle child table name
-    if (childTableNameLen == tag->keyLen && strncmp(tag->key, tsSmlChildTableName, tag->keyLen) == 0) {
-      memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
-      strncpy(childTableName, tag->value, (tag->length < TSDB_TABLE_NAME_LEN ? tag->length : TSDB_TABLE_NAME_LEN));
-      if(tsSmlDot2Underline){
-        smlStrReplace(childTableName, strlen(childTableName));
+  bool autoChildName = false;
+  size_t delimiter = strlen(tsSmlAutoChildTableNameDelimiter);
+  if(delimiter > 0){
+    size_t totalNameLen = delimiter * (taosArrayGetSize(tags) - 1);
+    for (int i = 0; i < taosArrayGetSize(tags); i++) {
+      SSmlKv *tag = (SSmlKv *)taosArrayGet(tags, i);
+      totalNameLen += tag->length;
+    }
+    if(totalNameLen < TSDB_TABLE_NAME_LEN){
+      autoChildName = true;
+    }
+  }
+  if(autoChildName){
+    memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
+    for (int i = 0; i < taosArrayGetSize(tags); i++) {
+      SSmlKv *tag = (SSmlKv *)taosArrayGet(tags, i);
+      strncat(childTableName, tag->value, tag->length);
+      if(i != taosArrayGetSize(tags) - 1){
+        strcat(childTableName, tsSmlAutoChildTableNameDelimiter);
+      }
+    }
+    if(tsSmlDot2Underline){
+      smlStrReplace(childTableName, strlen(childTableName));
+    }
+  }else{
+    size_t childTableNameLen = strlen(tsSmlChildTableName);
+    if (childTableNameLen <= 0) return TSDB_CODE_SUCCESS;
+
+    for (int i = 0; i < taosArrayGetSize(tags); i++) {
+      SSmlKv *tag = (SSmlKv *)taosArrayGet(tags, i);
+      // handle child table name
+      if (childTableNameLen == tag->keyLen && strncmp(tag->key, tsSmlChildTableName, tag->keyLen) == 0) {
+        memset(childTableName, 0, TSDB_TABLE_NAME_LEN);
+        strncpy(childTableName, tag->value, (tag->length < TSDB_TABLE_NAME_LEN ? tag->length : TSDB_TABLE_NAME_LEN));
+        if(tsSmlDot2Underline){
+          smlStrReplace(childTableName, strlen(childTableName));
+        }
+        taosArrayRemove(tags, i);
+        break;
      }
-      taosArrayRemove(tags, i);
-      break;
    }
  }

--- a/source/client/src/clientSmlJson.c
+++ b/source/client/src/clientSmlJson.c
@ -853,7 +853,6 @@ static int64_t smlParseTSFromJSONObj(SSmlHandle *info, cJSON *root, int32_t toPr
  size_t  typeLen = strlen(type->valuestring);
  if (typeLen == 1 && (type->valuestring[0] == 's' || type->valuestring[0] == 'S')) {
    // seconds
-//    int8_t fromPrecision = TSDB_TIME_PRECISION_SECONDS;
    if (smlFactorS[toPrecision] < INT64_MAX / tsInt64) {
      return tsInt64 * smlFactorS[toPrecision];
    }
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@ -62,7 +62,7 @@ struct tmq_conf_t {
  int8_t         resetOffset;
  int8_t         withTbName;
  int8_t         snapEnable;
-//  int32_t        snapBatchSize;
+  int8_t         replayEnable;
  uint16_t       port;
  int32_t        autoCommitInterval;
  char*          ip;
@ -81,6 +81,7 @@ struct tmq_t {
  int8_t         autoCommit;
  int32_t        autoCommitInterval;
  int8_t         resetOffsetCfg;
+  int8_t         replayEnable;
  uint64_t       consumerId;
  tmq_commit_cb* commitCb;
  void*          commitCbUserParam;
@ -89,19 +90,13 @@ struct tmq_t {
  SRWLatch        lock;
  int8_t  status;
  int32_t epoch;
-#if 0
-  int8_t  epStatus;
-  int32_t epSkipCnt;
-#endif
  // poll info
  int64_t pollCnt;
  int64_t totalRows;
-//  bool    needReportOffsetRows;

  // timer
  tmr_h       hbLiveTimer;
  tmr_h       epTimer;
-  tmr_h       reportTimer;
  tmr_h       commitTimer;
  STscObj*    pTscObj;       // connection
  SArray*     clientTopics;  // SArray<SMqClientTopic>
@ -149,6 +144,8 @@ typedef struct {
  int32_t       vgStatus;
  int32_t       vgSkipCnt;              // here used to mark the slow vgroups
  int64_t       emptyBlockReceiveTs;    // once empty block is received, idle for ignoreCnt then start to poll data
+  int64_t       blockReceiveTs;         // once empty block is received, idle for ignoreCnt then start to poll data
+  int64_t       blockSleepForReplay;    // once empty block is received, idle for ignoreCnt then start to poll data
  bool          seekUpdated;            // offset is updated by seek operator, therefore, not update by vnode rsp.
  SEpSet        epSet;
 } SMqClientVg;
@ -356,24 +353,6 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
    }
  }

-//  if (strcasecmp(key, "experimental.snapshot.batch.size") == 0) {
-//    conf->snapBatchSize = taosStr2int64(value);
-//    return TMQ_CONF_OK;
-//  }
-
-//  if (strcasecmp(key, "enable.heartbeat.background") == 0) {
-    //    if (strcasecmp(value, "true") == 0) {
-    //      conf->hbBgEnable = true;
-    //      return TMQ_CONF_OK;
-    //    } else if (strcasecmp(value, "false") == 0) {
-    //      conf->hbBgEnable = false;
-    //      return TMQ_CONF_OK;
-    //    } else {
-//    tscError("the default value of enable.heartbeat.background is true, can not be seted");
-//    return TMQ_CONF_INVALID;
-    //    }
-//  }
-
  if (strcasecmp(key, "td.connect.ip") == 0) {
    conf->ip = taosStrdup(value);
    return TMQ_CONF_OK;
@ -394,6 +373,18 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
    return TMQ_CONF_OK;
  }

+  if (strcasecmp(key, "enable.replay") == 0) {
+    if (strcasecmp(value, "true") == 0) {
+      conf->replayEnable = true;
+      return TMQ_CONF_OK;
+    } else if (strcasecmp(value, "false") == 0) {
+      conf->replayEnable = false;
+      return TMQ_CONF_OK;
+    } else {
+      return TMQ_CONF_INVALID;
+    }
+  }
+
  if (strcasecmp(key, "td.connect.db") == 0) {
    return TMQ_CONF_OK;
  }
@ -729,6 +720,17 @@ void tmqAssignAskEpTask(void* param, void* tmrId) {
  taosMemoryFree(param);
 }

+void tmqReplayTask(void* param, void* tmrId) {
+  int64_t refId = *(int64_t*)param;
+  tmq_t* tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
+  if(tmq == NULL) goto END;
+
+  tsem_post(&tmq->rspSem);
+  taosReleaseRef(tmqMgmt.rsetId, refId);
+END:
+  taosMemoryFree(param);
+}
+
 void tmqAssignDelayedCommitTask(void* param, void* tmrId) {
  int64_t refId = *(int64_t*)param;
  generateTimedTask(refId, TMQ_DELAYED_TASK__COMMIT);
@ -1071,6 +1073,10 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
  pTmq->commitCb = conf->commitCb;
  pTmq->commitCbUserParam = conf->commitCbUserParam;
  pTmq->resetOffsetCfg = conf->resetOffset;
+  pTmq->replayEnable = conf->replayEnable;
+  if(conf->replayEnable){
+    pTmq->autoCommit = false;
+  }
  taosInitRWLatch(&pTmq->lock);

  // assign consumerId
@ -1140,6 +1146,7 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
  req.autoCommit = tmq->autoCommit;
  req.autoCommitInterval = tmq->autoCommitInterval;
  req.resetOffsetCfg = tmq->resetOffsetCfg;
+  req.enableReplay = tmq->replayEnable;

  for (int32_t i = 0; i < sz; i++) {
    char* topic = taosArrayGetP(container, i);
@ -1415,6 +1422,8 @@ static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopic
        .vgStatus = pInfo ? pInfo->vgStatus : TMQ_VG_STATUS__IDLE,
        .vgSkipCnt = 0,
        .emptyBlockReceiveTs = 0,
+        .blockReceiveTs = 0,
+        .blockSleepForReplay = 0,
        .numOfRows = pInfo ? pInfo->numOfRows : 0,
    };

@ -1526,6 +1535,7 @@ void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqCl
  pReq->head.vgId = pVg->vgId;
  pReq->useSnapshot = tmq->useSnapshot;
  pReq->reqId = generateRequestId();
+  pReq->enableReplay = tmq->replayEnable;
 }

 SMqMetaRspObj* tmqBuildMetaRspFromWrapper(SMqPollRspWrapper* pWrapper) {
@ -1686,6 +1696,12 @@ static int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
        continue;
      }

+      if (tmq->replayEnable && taosGetTimestampMs() - pVg->blockReceiveTs < pVg->blockSleepForReplay) {  // less than 10ms
+        tscTrace("consumer:0x%" PRIx64 " epoch %d, vgId:%d idle for %" PRId64 "ms before start next poll when replay", tmq->consumerId,
+                 tmq->epoch, pVg->vgId, pVg->blockSleepForReplay);
+        continue;
+      }
+
      int32_t vgStatus = atomic_val_compare_exchange_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE, TMQ_VG_STATUS__WAIT);
      if (vgStatus == TMQ_VG_STATUS__WAIT) {
        int32_t vgSkipCnt = atomic_add_fetch_32(&pVg->vgSkipCnt, 1);
@ -1807,6 +1823,15 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
          SMqRspObj* pRsp = tmqBuildRspFromWrapper(pollRspWrapper, pVg, &numOfRows);
          tmq->totalRows += numOfRows;
          pVg->emptyBlockReceiveTs = 0;
+          if(tmq->replayEnable){
+            pVg->blockReceiveTs = taosGetTimestampMs();
+            pVg->blockSleepForReplay = pRsp->rsp.sleepTime;
+            if(pVg->blockSleepForReplay > 0){
+              int64_t* pRefId1 = taosMemoryMalloc(sizeof(int64_t));
+              *pRefId1 = tmq->refId;
+              taosTmrStart(tmqReplayTask, pVg->blockSleepForReplay, pRefId1, tmqMgmt.timer);
+            }
+          }
          tscDebug("consumer:0x%" PRIx64 " process poll rsp, vgId:%d, offset:%s, blocks:%d, rows:%" PRId64
                   ", vg total:%" PRId64 ", total:%" PRId64 ", reqId:0x%" PRIx64,
                   tmq->consumerId, pVg->vgId, buf, pDataRsp->blockNum, numOfRows, pVg->numOfRows, tmq->totalRows,
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@ -118,7 +118,8 @@ bool tsSmlDot2Underline = true;
 char tsSmlTsDefaultName[TSDB_COL_NAME_LEN] = "_ts";
 char tsSmlTagName[TSDB_COL_NAME_LEN] = "_tag_null";
 char tsSmlChildTableName[TSDB_TABLE_NAME_LEN] = "";  // user defined child table name can be specified in tag value.
-                                                     // If set to empty system will generate table name using MD5 hash.
+char tsSmlAutoChildTableNameDelimiter[TSDB_TABLE_NAME_LEN] = "";
+                                                                   // If set to empty system will generate table name using MD5 hash.
 // true means that the name and order of cols in each line are the same(only for influx protocol)
 // bool    tsSmlDataFormat = false;
 // int32_t tsSmlBatchSize = 10000;
@ -439,7 +440,8 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
  if (cfgAddInt32(pCfg, "queryNodeChunkSize", tsQueryNodeChunkSize, 1024, 128 * 1024, CFG_SCOPE_CLIENT) != 0) return -1;
  if (cfgAddBool(pCfg, "queryUseNodeAllocator", tsQueryUseNodeAllocator, CFG_SCOPE_CLIENT) != 0) return -1;
  if (cfgAddBool(pCfg, "keepColumnName", tsKeepColumnName, CFG_SCOPE_CLIENT) != 0) return -1;
-  if (cfgAddString(pCfg, "smlChildTableName", "", CFG_SCOPE_CLIENT) != 0) return -1;
+  if (cfgAddString(pCfg, "smlChildTableName", tsSmlChildTableName, CFG_SCOPE_CLIENT) != 0) return -1;
+  if (cfgAddString(pCfg, "smlAutoChildTableNameDelimiter", tsSmlAutoChildTableNameDelimiter, CFG_SCOPE_CLIENT) != 0) return -1;
  if (cfgAddString(pCfg, "smlTagName", tsSmlTagName, CFG_SCOPE_CLIENT) != 0) return -1;
  if (cfgAddString(pCfg, "smlTsDefaultName", tsSmlTsDefaultName, CFG_SCOPE_CLIENT) != 0) return -1;
  if (cfgAddBool(pCfg, "smlDot2Underline", tsSmlDot2Underline, CFG_SCOPE_CLIENT) != 0) return -1;
@ -931,6 +933,7 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
    return -1;
  }

+  tstrncpy(tsSmlAutoChildTableNameDelimiter, cfgGetItem(pCfg, "smlAutoChildTableNameDelimiter")->str, TSDB_TABLE_NAME_LEN);
  tstrncpy(tsSmlChildTableName, cfgGetItem(pCfg, "smlChildTableName")->str, TSDB_TABLE_NAME_LEN);
  tstrncpy(tsSmlTagName, cfgGetItem(pCfg, "smlTagName")->str, TSDB_COL_NAME_LEN);
  tstrncpy(tsSmlTsDefaultName, cfgGetItem(pCfg, "smlTsDefaultName")->str, TSDB_COL_NAME_LEN);
@ -1396,6 +1399,8 @@ int32_t taosApplyLocalCfg(SConfig *pCfg, char *name) {
        cfgSetItem(pCfg, "secondEp", tsSecond, pSecondpItem->stype);
      } else if (strcasecmp("smlChildTableName", name) == 0) {
        tstrncpy(tsSmlChildTableName, cfgGetItem(pCfg, "smlChildTableName")->str, TSDB_TABLE_NAME_LEN);
+      } else if (strcasecmp("smlAutoChildTableNameDelimiter", name) == 0) {
+        tstrncpy(tsSmlAutoChildTableNameDelimiter, cfgGetItem(pCfg, "smlAutoChildTableNameDelimiter")->str, TSDB_TABLE_NAME_LEN);
      } else if (strcasecmp("smlTagName", name) == 0) {
        tstrncpy(tsSmlTagName, cfgGetItem(pCfg, "smlTagName")->str, TSDB_COL_NAME_LEN);
        //      } else if (strcasecmp("smlDataFormat", name) == 0) {
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@ -4721,31 +4721,6 @@ void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
  }
 }

-int32_t tSerializeSCMCreateTopicRsp(void *buf, int32_t bufLen, const SCMCreateTopicRsp *pRsp) {
-  SEncoder encoder = {0};
-  tEncoderInit(&encoder, buf, bufLen);
-
-  if (tStartEncode(&encoder) < 0) return -1;
-  if (tEncodeI64(&encoder, pRsp->topicId) < 0) return -1;
-  tEndEncode(&encoder);
-
-  int32_t tlen = encoder.pos;
-  tEncoderClear(&encoder);
-  return tlen;
-}
-
-int32_t tDeserializeSCMCreateTopicRsp(void *buf, int32_t bufLen, SCMCreateTopicRsp *pRsp) {
-  SDecoder decoder = {0};
-  tDecoderInit(&decoder, buf, bufLen);
-
-  if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeI64(&decoder, &pRsp->topicId) < 0) return -1;
-  tEndDecode(&decoder);
-
-  tDecoderClear(&decoder);
-  return 0;
-}
-
 int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);
@ -6388,6 +6363,7 @@ int32_t tSerializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
  if (tEncodeI64(&encoder, pReq->consumerId) < 0) return -1;
  if (tEncodeI64(&encoder, pReq->timeout) < 0) return -1;
  if (tSerializeSTqOffsetVal(&encoder, &pReq->reqOffset) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->enableReplay) < 0) return -1;

  tEndEncode(&encoder);

@ -6424,6 +6400,10 @@ int32_t tDeserializeSMqPollReq(void *buf, int32_t bufLen, SMqPollReq *pReq) {
  if (tDecodeI64(&decoder, &pReq->timeout) < 0) return -1;
  if (tDerializeSTqOffsetVal(&decoder, &pReq->reqOffset) < 0) return -1;

+  if (!tDecodeIsEnd(&decoder)) {
+    if (tDecodeI8(&decoder, &pReq->enableReplay) < 0) return -1;
+  }
+
  tEndDecode(&decoder);

  tDecoderClear(&decoder);
@ -8226,6 +8206,7 @@ int32_t tEncodeMqDataRsp(SEncoder *pEncoder, const SMqDataRsp *pRsp) {
      }
    }
  }
+  if (tEncodeI64(pEncoder, pRsp->sleepTime) < 0) return -1;
  return 0;
 }

@ -8271,6 +8252,8 @@ int32_t tDecodeMqDataRsp(SDecoder *pDecoder, SMqDataRsp *pRsp) {
      }
    }
  }
+  if (tDecodeI64(pDecoder, &pRsp->sleepTime) < 0) return -1;
+
  return 0;
 }

--- a/source/dnode/mgmt/mgmt_mnode/src/mmInt.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmInt.c
@ -32,8 +32,13 @@ static int32_t mmRequire(const SMgmtInputOpt *pInput, bool *required) {

  if (!option.deploy) {
    *required = mmDeployRequired(pInput);
+    if (*required) {
+      dInfo("deploy mnode required. dnodeId:%d<=0, clusterId:%" PRId64 "<=0, localEp:%s==firstEp",
+            pInput->pData->dnodeId, pInput->pData->clusterId, tsLocalEp);
+    }
  } else {
    *required = true;
+    dInfo("deploy mnode required. option deploy:%d", option.deploy);
  }

  return 0;
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@ -495,32 +495,6 @@ typedef struct {
  char           filterTb[TSDB_TABLE_NAME_LEN];
 } SShowObj;

-typedef struct {
-  int64_t id;
-  int8_t  type;
-  int8_t  replica;
-  int16_t numOfColumns;
-  int32_t rowSize;
-  int32_t numOfRows;
-  int32_t numOfReads;
-  int32_t payloadLen;
-  void*   pIter;
-  SMnode* pMnode;
-  char    db[TSDB_DB_FNAME_LEN];
-  int16_t offset[TSDB_MAX_COLUMNS];
-  int32_t bytes[TSDB_MAX_COLUMNS];
-  char    payload[];
-} SSysTableRetrieveObj;
-
-typedef struct {
-  char    key[TSDB_PARTITION_KEY_LEN];
-  int64_t dbUid;
-  int64_t offset;
-} SMqOffsetObj;
-
-int32_t tEncodeSMqOffsetObj(void** buf, const SMqOffsetObj* pOffset);
-void*   tDecodeSMqOffsetObj(void* buf, SMqOffsetObj* pOffset);
-
 typedef struct {
  char           name[TSDB_TOPIC_FNAME_LEN];
  char           db[TSDB_DB_FNAME_LEN];
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@ -18,6 +18,7 @@
 #include "mndPrivilege.h"
 #include "mndVgroup.h"
 #include "mndShow.h"
+#include "mndDb.h"
 #include "mndSubscribe.h"
 #include "mndTopic.h"
 #include "mndTrans.h"
@ -124,30 +125,55 @@ void mndRebCntDec() {
  }
 }

-static int32_t validateTopics(STrans *pTrans, const SArray *pTopicList, SMnode *pMnode, const char *pUser) {
-  int32_t numOfTopics = taosArrayGetSize(pTopicList);
+static int32_t validateTopics(STrans *pTrans, const SArray *pTopicList, SMnode *pMnode, const char *pUser, bool enableReplay) {
+  SMqTopicObj *pTopic = NULL;
+  int32_t code = 0;

+  int32_t numOfTopics = taosArrayGetSize(pTopicList);
  for (int32_t i = 0; i < numOfTopics; i++) {
    char        *pOneTopic = taosArrayGetP(pTopicList, i);
-    SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pOneTopic);
+    pTopic = mndAcquireTopic(pMnode, pOneTopic);
    if (pTopic == NULL) {  // terrno has been set by callee function
-      return -1;
+      code = -1;
+      goto FAILED;
    }

    if (mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic) != 0) {
-      mndReleaseTopic(pMnode, pTopic);
-      return -1;
+      code = -1;
+      goto FAILED;
+    }
+
+    if(enableReplay){
+      if(pTopic->subType != TOPIC_SUB_TYPE__COLUMN){
+        code = TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT;
+        goto FAILED;
+      }else if(pTopic->ntbUid == 0 && pTopic->ctbStbUid == 0) {
+        SDbObj *pDb = mndAcquireDb(pMnode, pTopic->db);
+        if (pDb == NULL) {
+          code = -1;
+          goto FAILED;
+        }
+        if (pDb->cfg.numOfVgroups != 1) {
+          mndReleaseDb(pMnode, pDb);
+          code = TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP;
+          goto FAILED;
+        }
+        mndReleaseDb(pMnode, pDb);
+      }
    }

    mndTransSetDbName(pTrans, pOneTopic, NULL);
    if(mndTransCheckConflict(pMnode, pTrans) != 0){
-      mndReleaseTopic(pMnode, pTopic);
-      return -1;
+      code = -1;
+      goto FAILED;
    }
    mndReleaseTopic(pMnode, pTopic);
  }

  return 0;
+FAILED:
+  mndReleaseTopic(pMnode, pTopic);
+  return code;
 }

 static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
@ -177,7 +203,7 @@ static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
  if (pTrans == NULL) {
    goto FAIL;
  }
-  if(validateTopics(pTrans, pConsumer->assignedTopics, pMnode, pMsg->info.conn.user) != 0){
+  if(validateTopics(pTrans, pConsumer->assignedTopics, pMnode, pMsg->info.conn.user, false) != 0){
    goto FAIL;
  }

@ -697,7 +723,7 @@ int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
    goto _over;
  }

-  code = validateTopics(pTrans, pTopicList, pMnode, pMsg->info.conn.user);
+  code = validateTopics(pTrans, pTopicList, pMnode, pMsg->info.conn.user, subscribe.enableReplay);
  if (code != TSDB_CODE_SUCCESS) {
    goto _over;
  }
--- a/source/dnode/mnode/impl/src/mndDump.c
+++ b/source/dnode/mnode/impl/src/mndDump.c
@ -330,24 +330,6 @@ void dumpSubscribe(SSdb *pSdb, SJson *json) {
  }
 }

-void dumpOffset(SSdb *pSdb, SJson *json) {
-  void  *pIter = NULL;
-  SJson *items = tjsonAddArrayToObject(json, "offsets");
-
-  while (1) {
-    SMqOffsetObj *pObj = NULL;
-    pIter = sdbFetch(pSdb, SDB_OFFSET, pIter, (void **)&pObj);
-    if (pIter == NULL) break;
-
-    SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "key", pObj->key);
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "offset", i642str(pObj->offset));
-    sdbRelease(pSdb, pObj);
-  }
-}
-
 void dumpStream(SSdb *pSdb, SJson *json) {
  void  *pIter = NULL;
  SJson *items = tjsonAddArrayToObject(json, "streams");
@ -608,7 +590,7 @@ void mndDumpSdb() {
  dumpTopic(pSdb, json);
  dumpConsumer(pSdb, json);
  dumpSubscribe(pSdb, json);
-  dumpOffset(pSdb, json);
+//  dumpOffset(pSdb, json);
  dumpStream(pSdb, json);
  dumpAcct(pSdb, json);
  dumpAuth(pSdb, json);
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@ -298,11 +298,6 @@ static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopic
  atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
  atomic_exchange_32(&pOldTopic->version, pNewTopic->version);

-  /*taosWLockLatch(&pOldTopic->lock);*/
-
-  // TODO handle update
-
-  /*taosWUnLockLatch(&pOldTopic->lock);*/
  return 0;
 }

@ -320,23 +315,6 @@ void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
  sdbRelease(pSdb, pTopic);
 }

-static SDDropTopicReq *mndBuildDropTopicMsg(SMnode *pMnode, SVgObj *pVgroup, SMqTopicObj *pTopic) {
-  int32_t contLen = sizeof(SDDropTopicReq);
-
-  SDDropTopicReq *pDrop = taosMemoryCalloc(1, contLen);
-  if (pDrop == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  pDrop->head.contLen = htonl(contLen);
-  pDrop->head.vgId = htonl(pVgroup->vgId);
-  memcpy(pDrop->name, pTopic->name, TSDB_TOPIC_FNAME_LEN);
-  pDrop->tuid = htobe64(pTopic->uid);
-
-  return pDrop;
-}
-
 static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
  terrno = TSDB_CODE_MND_INVALID_TOPIC;

--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@ -226,6 +226,7 @@ typedef struct STqReader {
  int64_t         cachedSchemaUid;
  SSchemaWrapper *pSchemaWrapper;
  SSDataBlock    *pResBlock;
+  int64_t         lastTs;
 } STqReader;

 STqReader *tqReaderOpen(SVnode *pVnode);
@ -244,6 +245,7 @@ bool         tqNextBlockInWal(STqReader *pReader, const char *idstr);
 bool         tqNextBlockImpl(STqReader *pReader, const char *idstr);
 SWalReader  *tqGetWalReader(STqReader *pReader);
 SSDataBlock *tqGetResultBlock(STqReader *pReader);
+int64_t      tqGetResultBlockTime(STqReader *pReader);

 int32_t extractMsgFromWal(SWalReader *pReader, void **pItem, int64_t maxVer, const char *id);
 int32_t tqReaderSetSubmitMsg(STqReader *pReader, void *msgStr, int32_t msgLen, int64_t ver);
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@ -46,6 +46,7 @@ typedef struct STqOffsetStore STqOffsetStore;
 // tqPush
 #define STREAM_EXEC_EXTRACT_DATA_IN_WAL_ID (-1)
 #define STREAM_EXEC_TASK_STATUS_CHECK_ID     (-2)
+#define IS_OFFSET_RESET_TYPE(_t)  ((_t) < 0)

 // tqExec
 typedef struct {
@ -90,6 +91,10 @@ typedef struct {
  STqExecHandle    execHandle;  // exec
  SRpcMsg*         msg;
  tq_handle_status status;
+
+  // for replay
+  SSDataBlock* block;
+  int64_t      blockTime;
 } STqHandle;

 struct STQ {
@ -107,17 +112,13 @@ struct STQ {
  SStreamMeta*    pStreamMeta;
 };

-typedef struct {
-  int32_t size;
-} STqOffsetHead;
-
 int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle);
 int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle);
 void    tqDestroyTqHandle(void* data);

 // tqRead
 int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqMetaRsp* pMetaRsp, STqOffsetVal* offset);
-int32_t tqScanData(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset);
+int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset, const SMqPollReq* pRequest);
 int32_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, uint64_t reqId);

 // tqExec
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@ -82,6 +82,9 @@ void tqDestroyTqHandle(void* data) {
    taosMemoryFree(pData->msg);
    pData->msg = NULL;
  }
+  if (pData->block != NULL){
+    blockDataDestroy(pData->block);
+  }
 }

 static bool tqOffsetEqual(const STqOffset* pLeft, const STqOffset* pRight) {
--- a/source/dnode/vnode/src/tq/tqOffset.c
+++ b/source/dnode/vnode/src/tq/tqOffset.c
@ -37,11 +37,9 @@ int32_t tqOffsetRestoreFromFile(STqOffsetStore* pStore, const char* fname) {

  int32_t vgId = TD_VID(pStore->pTq->pVnode);
  int64_t code = 0;
-
-  STqOffsetHead head = {0};
-
+  int32_t size = 0;
  while (1) {
-    if ((code = taosReadFile(pFile, &head, sizeof(STqOffsetHead))) != sizeof(STqOffsetHead)) {
+    if ((code = taosReadFile(pFile, &size, INT_BYTES)) != INT_BYTES) {
      if (code == 0) {
        break;
      } else {
@ -49,7 +47,6 @@ int32_t tqOffsetRestoreFromFile(STqOffsetStore* pStore, const char* fname) {
      }
    }

-    int32_t size = htonl(head.size);
    void*   pMemBuf = taosMemoryCalloc(1, size);
    if (pMemBuf == NULL) {
      tqError("vgId:%d failed to restore offset from file, since out of memory, malloc size:%d", vgId, size);
@ -175,11 +172,11 @@ int32_t tqOffsetCommitFile(STqOffsetStore* pStore) {
      return -1;
    }

-    int32_t totLen = sizeof(STqOffsetHead) + bodyLen;
+    int32_t totLen = INT_BYTES + bodyLen;
    void*   buf = taosMemoryCalloc(1, totLen);
-    void*   abuf = POINTER_SHIFT(buf, sizeof(STqOffsetHead));
+    void*   abuf = POINTER_SHIFT(buf, INT_BYTES);

-    ((STqOffsetHead*)buf)->size = htonl(bodyLen);
+    *(int32_t*)buf = bodyLen;
    SEncoder encoder;
    tEncoderInit(&encoder, abuf, bodyLen);
    tEncodeSTqOffset(&encoder, pOffset);
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@ -369,82 +369,56 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
 // todo ignore the error in wal?
 bool tqNextBlockInWal(STqReader* pReader, const char* id) {
  SWalReader* pWalReader = pReader->pWalReader;
+  SSDataBlock* pDataBlock = NULL;

  uint64_t st = taosGetTimestampMs();
  while (1) {
-    SArray* pBlockList = pReader->submit.aSubmitTbData;
-    if (pBlockList == NULL || pReader->nextBlk >= taosArrayGetSize(pBlockList)) {
-      // try next message in wal file
-      // todo always retry to avoid read failure caused by wal file deletion
-      if (walNextValidMsg(pWalReader) < 0) {
-        return false;
-      }
-
-      void*   pBody = POINTER_SHIFT(pWalReader->pHead->head.body, sizeof(SSubmitReq2Msg));
-      int32_t bodyLen = pWalReader->pHead->head.bodyLen - sizeof(SSubmitReq2Msg);
-      int64_t ver = pWalReader->pHead->head.version;
-
-      SDecoder decoder = {0};
-      tDecoderInit(&decoder, pBody, bodyLen);
-
-      {
-        int32_t nSubmitTbData = taosArrayGetSize(pReader->submit.aSubmitTbData);
-        for (int32_t i = 0; i < nSubmitTbData; i++) {
-          SSubmitTbData* pData = taosArrayGet(pReader->submit.aSubmitTbData, i);
-          if (pData->pCreateTbReq != NULL) {
-            taosArrayDestroy(pData->pCreateTbReq->ctb.tagName);
-            taosMemoryFreeClear(pData->pCreateTbReq);
-          }
-          pData->aRowP = taosArrayDestroy(pData->aRowP);
-        }
-        pReader->submit.aSubmitTbData = taosArrayDestroy(pReader->submit.aSubmitTbData);
-      }
-
-      if (tDecodeSubmitReq(&decoder, &pReader->submit) < 0) {
-        tDecoderClear(&decoder);
-        tqError("decode wal file error, msgLen:%d, ver:%" PRId64, bodyLen, ver);
-        return false;
-      }
-
-      tDecoderClear(&decoder);
-      pReader->nextBlk = 0;
+    // try next message in wal file
+    if (walNextValidMsg(pWalReader) < 0) {
+      return false;
    }

+    void*   pBody = POINTER_SHIFT(pWalReader->pHead->head.body, sizeof(SSubmitReq2Msg));
+    int32_t bodyLen = pWalReader->pHead->head.bodyLen - sizeof(SSubmitReq2Msg);
+    int64_t ver = pWalReader->pHead->head.version;
+
+    tqReaderSetSubmitMsg(pReader, pBody, bodyLen, ver);
+    pReader->nextBlk = 0;
    int32_t numOfBlocks = taosArrayGetSize(pReader->submit.aSubmitTbData);
    while (pReader->nextBlk < numOfBlocks) {
-      tqTrace("tq reader next data block %d/%d, len:%d %" PRId64 " %d", pReader->nextBlk,
-          numOfBlocks, pReader->msg.msgLen, pReader->msg.ver, pReader->nextBlk);
+      tqTrace("tq reader next data block %d/%d, len:%d %" PRId64, pReader->nextBlk,
+          numOfBlocks, pReader->msg.msgLen, pReader->msg.ver);

      SSubmitTbData* pSubmitTbData = taosArrayGet(pReader->submit.aSubmitTbData, pReader->nextBlk);

-      if (pReader->tbIdHash == NULL) {
-        SSDataBlock* pRes = NULL;
-        int32_t      code = tqRetrieveDataBlock(pReader, &pRes, NULL);
-        if (code == TSDB_CODE_SUCCESS && pRes->info.rows > 0) {
-          return true;
-        }
-      }
-
-      void* ret = taosHashGet(pReader->tbIdHash, &pSubmitTbData->uid, sizeof(int64_t));
-      if (ret != NULL) {
-        tqTrace("tq reader return submit block, uid:%" PRId64 ", ver:%" PRId64, pSubmitTbData->uid, pReader->msg.ver);
-
+      if (pReader->tbIdHash == NULL || taosHashGet(pReader->tbIdHash, &pSubmitTbData->uid, sizeof(int64_t)) != NULL) {
+        tqTrace("tq reader return submit block, uid:%" PRId64, pSubmitTbData->uid);
        SSDataBlock* pRes = NULL;
        int32_t code = tqRetrieveDataBlock(pReader, &pRes, NULL);
        if (code == TSDB_CODE_SUCCESS && pRes->info.rows > 0) {
-          return true;
+          if(pDataBlock == NULL){
+            pDataBlock = createOneDataBlock(pRes, true);
+          }else{
+            blockDataMerge(pDataBlock, pRes);
+          }
        }
      } else {
        pReader->nextBlk += 1;
        tqTrace("tq reader discard submit block, uid:%" PRId64 ", continue", pSubmitTbData->uid);
      }
    }
-
-    qTrace("stream scan return empty, all %d submit blocks consumed, %s", numOfBlocks, id);
    tDestroySubmitReq(&pReader->submit, TSDB_MSG_FLG_DECODE);
-
    pReader->msg.msgStr = NULL;

+    if(pDataBlock != NULL){
+      blockDataCleanup(pReader->pResBlock);
+      copyDataBlock(pReader->pResBlock, pDataBlock);
+      blockDataDestroy(pDataBlock);
+      return true;
+    }else{
+      qTrace("stream scan return empty, all %d submit blocks consumed, %s", numOfBlocks, id);
+    }
+
    if(taosGetTimestampMs() - st > 1000){
      return false;
    }
@ -478,6 +452,10 @@ SSDataBlock* tqGetResultBlock (STqReader* pReader) {
  return pReader->pResBlock;
 }

+int64_t tqGetResultBlockTime(STqReader *pReader){
+  return pReader->lastTs;
+}
+
 bool tqNextBlockImpl(STqReader* pReader, const char* idstr) {
  if (pReader->msg.msgStr == NULL) {
    return false;
@ -644,7 +622,7 @@ int32_t tqRetrieveDataBlock(STqReader* pReader, SSDataBlock** pRes, const char*
  int32_t sversion = pSubmitTbData->sver;
  int64_t suid = pSubmitTbData->suid;
  int64_t uid = pSubmitTbData->uid;
-  pReader->lastBlkUid = uid;
+  pReader->lastTs = pSubmitTbData->ctimeMs;

  pBlock->info.id.uid = uid;
  pBlock->info.version = pReader->msg.ver;
@ -786,7 +764,6 @@ int32_t tqRetrieveTaosxBlock(STqReader* pReader, SArray* blocks, SArray* schemas
  }

  int32_t sversion = pSubmitTbData->sver;
-  int64_t suid = pSubmitTbData->suid;
  int64_t uid = pSubmitTbData->uid;
  pReader->lastBlkUid = uid;

--- a/source/dnode/vnode/src/tq/tqScan.c
+++ b/source/dnode/vnode/src/tq/tqScan.c
@ -64,7 +64,23 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, STaosxRsp* pRsp, in
  return 0;
 }

-int32_t tqScanData(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
+int32_t getDataBlock(qTaskInfo_t task, const STqHandle* pHandle, int32_t vgId, SSDataBlock** res){
+  uint64_t     ts = 0;
+  qStreamSetOpen(task);
+
+  tqDebug("consumer:0x%" PRIx64 " vgId:%d, tmq one task start execute", pHandle->consumerId, vgId);
+  int32_t code = qExecTask(task, res, &ts);
+  if (code != TSDB_CODE_SUCCESS) {
+    tqError("consumer:0x%" PRIx64 " vgId:%d, task exec error since %s", pHandle->consumerId, vgId, tstrerror(code));
+    terrno = code;
+    return -1;
+  }
+
+  tqDebug("consumer:0x%" PRIx64 " vgId:%d tmq one task end executed, pDataBlock:%p", pHandle->consumerId, vgId, *res);
+  return 0;
+}
+
+int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* pOffset, const SMqPollReq* pRequest) {
  const int32_t MAX_ROWS_TO_RETURN = 4096;

  int32_t vgId = TD_VID(pTq->pVnode);
@ -80,34 +96,66 @@ int32_t tqScanData(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffs

  while (1) {
    SSDataBlock* pDataBlock = NULL;
-    uint64_t     ts = 0;
-    qStreamSetOpen(task);
-
-    tqDebug("consumer:0x%" PRIx64 " vgId:%d, tmq one task start execute", pHandle->consumerId, vgId);
-    code = qExecTask(task, &pDataBlock, &ts);
-    if (code != TSDB_CODE_SUCCESS) {
-      tqError("consumer:0x%" PRIx64 " vgId:%d, task exec error since %s", pHandle->consumerId, vgId, tstrerror(code));
-      terrno = code;
-      return -1;
-    }
-
-    tqDebug("consumer:0x%" PRIx64 " vgId:%d tmq one task end executed, pDataBlock:%p", pHandle->consumerId, vgId,
-            pDataBlock);
-    // current scan should be stopped asap, since the rebalance occurs.
-    if (pDataBlock == NULL) {
-      break;
-    }
-
-    code = tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols, pTq->pVnode->config.tsdbCfg.precision);
-    if (code != TSDB_CODE_SUCCESS) {
-      tqError("vgId:%d, failed to add block to rsp msg", vgId);
+    code = getDataBlock(task, pHandle, vgId, &pDataBlock);
+    if (code != 0){
      return code;
    }

-    pRsp->blockNum++;
-    totalRows += pDataBlock->info.rows;
-    if (totalRows >= MAX_ROWS_TO_RETURN) {
+    if(pRequest->enableReplay){
+      if(IS_OFFSET_RESET_TYPE(pRequest->reqOffset.type) && pHandle->block != NULL){
+        blockDataDestroy(pHandle->block);
+        pHandle->block = NULL;
+      }
+      if(pHandle->block == NULL){
+        if (pDataBlock == NULL) {
+          break;
+        }
+        STqOffsetVal offset = {0};
+        qStreamExtractOffset(task, &offset);
+        pHandle->block = createOneDataBlock(pDataBlock, true);
+//        pHandle->block = createDataBlock();
+//        copyDataBlock(pHandle->block, pDataBlock);
+        pHandle->blockTime = offset.ts;
+        code = getDataBlock(task, pHandle, vgId, &pDataBlock);
+        if (code != 0){
+          return code;
+        }
+      }
+
+      code = tqAddBlockDataToRsp(pHandle->block, pRsp, pExec->numOfCols, pTq->pVnode->config.tsdbCfg.precision);
+      if (code != TSDB_CODE_SUCCESS) {
+        tqError("vgId:%d, failed to add block to rsp msg", vgId);
+        return code;
+      }
+
+      pRsp->blockNum++;
+      if (pDataBlock == NULL) {
+        blockDataDestroy(pHandle->block);
+        pHandle->block = NULL;
+      }else{
+        copyDataBlock(pHandle->block, pDataBlock);
+
+        STqOffsetVal offset = {0};
+        qStreamExtractOffset(task, &offset);
+        pRsp->sleepTime = offset.ts - pHandle->blockTime;
+        pHandle->blockTime = offset.ts;
+      }
      break;
+    }else{
+      if (pDataBlock == NULL) {
+        break;
+      }
+      code = tqAddBlockDataToRsp(pDataBlock, pRsp, pExec->numOfCols, pTq->pVnode->config.tsdbCfg.precision);
+      if (code != TSDB_CODE_SUCCESS) {
+        tqError("vgId:%d, failed to add block to rsp msg", vgId);
+        return code;
+      }
+
+      pRsp->blockNum++;
+      totalRows += pDataBlock->info.rows;
+      if (totalRows >= MAX_ROWS_TO_RETURN) {
+        break;
+      }
    }
  }

--- a/source/dnode/vnode/src/tq/tqStreamTaskSnap.c
+++ b/source/dnode/vnode/src/tq/tqStreamTaskSnap.c
@ -198,8 +198,6 @@ int32_t streamTaskSnapWriterClose(SStreamTaskWriter* pWriter, int8_t rollback) {

  taosWLockLatch(&pTq->pStreamMeta->lock);
  tqDebug("vgId:%d, vnode stream-task snapshot writer closed", TD_VID(pTq->pVnode));
-
-  taosWLockLatch(&pTq->pStreamMeta->lock);
  if (rollback) {
    tdbAbort(pTq->pStreamMeta->db, pTq->pStreamMeta->txn);
  } else {
@ -208,12 +206,6 @@ int32_t streamTaskSnapWriterClose(SStreamTaskWriter* pWriter, int8_t rollback) {
    code = tdbPostCommit(pTq->pStreamMeta->db, pTq->pStreamMeta->txn);
    if (code) goto _err;
  }
-  if (tdbBegin(pTq->pStreamMeta->db, &pTq->pStreamMeta->txn, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) {
-    code = -1;
-    goto _err;
-  }
-
-  taosWUnLockLatch(&pTq->pStreamMeta->lock);

  if (tdbBegin(pTq->pStreamMeta->db, &pTq->pStreamMeta->txn, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) {
    code = -1;
--- a/source/dnode/vnode/src/tq/tqUtil.c
+++ b/source/dnode/vnode/src/tq/tqUtil.c
@ -15,8 +15,6 @@

 #include "tq.h"

-#define IS_OFFSET_RESET_TYPE(_t)  ((_t) < 0)
-
 static int32_t tqSendMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq,
                                 const SMqMetaRsp* pRsp, int32_t vgId);

@ -152,7 +150,7 @@ static int32_t extractDataAndRspForNormalSubscribe(STQ* pTq, STqHandle* pHandle,
  tqInitDataRsp(&dataRsp, *pOffset);

  qSetTaskId(pHandle->execHandle.task, consumerId, pRequest->reqId);
-  int code = tqScanData(pTq, pHandle, &dataRsp, pOffset);
+  int code = tqScanData(pTq, pHandle, &dataRsp, pOffset, pRequest);
  if (code != 0 && terrno != TSDB_CODE_WAL_LOG_NOT_EXIST) {
    goto end;
  }
--- a/source/dnode/vnode/src/vnd/vnodeInitApi.c
+++ b/source/dnode/vnode/src/vnd/vnodeInitApi.c
@ -131,6 +131,7 @@ void initTqAPI(SStoreTqReader* pTq) {
  pTq->tqGetResultBlock = tqGetResultBlock;

  pTq->tqReaderNextBlockFilterOut = tqNextDataBlockFilterOut;
+  pTq->tqGetResultBlockTime = tqGetResultBlockTime;
 }

 void initStateStoreAPI(SStateStore* pStore) {
--- a/source/libs/executor/inc/executorInt.h
+++ b/source/libs/executor/inc/executorInt.h
@ -307,7 +307,6 @@ typedef struct STagScanInfo {
  SSDataBlock*          pRes;
  SColMatchInfo         matchInfo;
  int32_t               curPos;
-  SLimitNode*           pSlimit;
  SReadHandle           readHandle;
  STableListInfo*       pTableListInfo;
  uint64_t              suid;
@ -318,6 +317,7 @@ typedef struct STagScanInfo {
  SArray*               aUidTags;     // SArray<STUidTagInfo>
  SArray*               aFilterIdxs;  // SArray<int32_t>
  SStorageAPI*          pStorageAPI;
+  SLimitInfo           limitInfo;
 } STagScanInfo;

 typedef enum EStreamScanMode {
@ -636,6 +636,7 @@ typedef struct SStreamFillSupporter {
  SSHashObj*     pResMap;
  bool           hasDelete;
  SStorageAPI*   pAPI;
+  STimeWindow    winRange;
 } SStreamFillSupporter;

 typedef struct SStreamFillOperatorInfo {
@ -770,6 +771,7 @@ SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int
 bool inSlidingWindow(SInterval* pInterval, STimeWindow* pWin, SDataBlockInfo* pBlockInfo);
 bool inCalSlidingWindow(SInterval* pInterval, STimeWindow* pWin, TSKEY calStart, TSKEY calEnd, EStreamType blockType);
 bool compareVal(const char* v, const SStateKeys* pKey);
+bool inWinRange(STimeWindow* range, STimeWindow* cur);

 int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo,
                               TSKEY* primaryKeys, int32_t prevPosition, int32_t order);
--- a/source/libs/executor/src/filloperator.c
+++ b/source/libs/executor/src/filloperator.c
@ -950,7 +950,10 @@ static bool hasRemainCalc(SStreamFillInfo* pFillInfo) {

 static void doStreamFillNormal(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock) {
  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
-    buildFillResult(pFillInfo->pResRow, pFillSup, pFillInfo->current, pBlock);
+    STimeWindow st = {.skey = pFillInfo->current, .ekey = pFillInfo->current};
+    if (inWinRange(&pFillSup->winRange, &st)) {
+      buildFillResult(pFillInfo->pResRow, pFillSup, pFillInfo->current, pBlock);
+    }
    pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
                                     pFillSup->interval.precision);
  }
@ -960,7 +963,8 @@ static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo*
  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
    uint64_t groupId = pBlock->info.id.groupId;
    SWinKey  key = {.groupId = groupId, .ts = pFillInfo->current};
-    if (pFillSup->hasDelete && !checkResult(pFillSup, pFillInfo->current, groupId)) {
+    STimeWindow st = {.skey = pFillInfo->current, .ekey = pFillInfo->current};
+    if ( ( pFillSup->hasDelete && !checkResult(pFillSup, pFillInfo->current, groupId) ) || !inWinRange(&pFillSup->winRange, &st) ) {
      pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
                                       pFillSup->interval.precision);
      pFillInfo->pLinearInfo->winIndex++;
@ -1345,6 +1349,11 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
        pInfo->pFillInfo->preRowKey = INT64_MIN;
      }

+      pInfo->pFillSup->winRange = pTaskInfo->streamInfo.fillHistoryWindow;
+      if (pInfo->pFillSup->winRange.ekey <= 0) {
+        pInfo->pFillSup->winRange.ekey = INT64_MAX;
+      }
+
      switch (pBlock->info.type) {
        case STREAM_RETRIEVE:
          return pBlock;
--- a/source/libs/executor/src/projectoperator.c
+++ b/source/libs/executor/src/projectoperator.c
@ -110,7 +110,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys
  pInfo->binfo.inputTsOrder = pProjPhyNode->node.inputTsOrder;
  pInfo->binfo.outputTsOrder = pProjPhyNode->node.outputTsOrder;

-  if (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) {
+  if (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM || pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) {
    pInfo->mergeDataBlocks = false;
  } else {
    if (!pProjPhyNode->ignoreGroupId) {
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@ -1863,6 +1863,9 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
      // curVersion move to next
      tqOffsetResetToLog(&pTaskInfo->streamInfo.currentOffset, pWalReader->curVersion);

+      // use ts to pass time when replay, because ts not used if type is log
+      pTaskInfo->streamInfo.currentOffset.ts = pAPI->tqReaderFn.tqGetResultBlockTime(pInfo->tqReader);
+
      if (hasResult) {
        qDebug("doQueueScan get data from log %" PRId64 " rows, version:%" PRId64, pRes->info.rows,
               pTaskInfo->streamInfo.currentOffset.version);
@ -3060,7 +3063,12 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
    setOperatorCompleted(pOperator);
  }
  pRes->info.rows = count;
-  pOperator->resultInfo.totalRows += count;
+
+  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);
+  if (bLimitReached) {
+    setOperatorCompleted(pOperator);
+  }
+  pOperator->resultInfo.totalRows += pRes->info.rows;
  return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
 }

@ -3094,28 +3102,20 @@ static SSDataBlock* doTagScanFromMetaEntry(SOperatorInfo* pOperator) {
    if (++pInfo->curPos >= size) {
      setOperatorCompleted(pOperator);
    }
-    // each table with tbname is a group, hence its own block, but only group when slimit exists for performance reason.
-    if (pInfo->pSlimit != NULL) {
-      if (pInfo->curPos < pInfo->pSlimit->offset) {
-        continue;
-      }
-      pInfo->pRes->info.id.groupId = calcGroupId(mr.me.name, strlen(mr.me.name));
-      if (pInfo->curPos >= (pInfo->pSlimit->offset + pInfo->pSlimit->limit) - 1) {
-        setOperatorCompleted(pOperator);
-      }
-      break;
-    }
  }
+  pRes->info.rows = count;

  pAPI->metaReaderFn.clearReader(&mr);
-
+  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);
+  if (bLimitReached) {
+    setOperatorCompleted(pOperator);
+  }
  // qDebug("QInfo:0x%"PRIx64" create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);
  if (pOperator->status == OP_EXEC_DONE) {
    setTaskStatus(pTaskInfo, TASK_COMPLETED);
  }

-  pRes->info.rows = count;
-  pOperator->resultInfo.totalRows += count;
+  pOperator->resultInfo.totalRows += pRes->info.rows;

  return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
 }
@ -3169,8 +3169,8 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi
  pInfo->pRes = createDataBlockFromDescNode(pDescNode);
  pInfo->readHandle = *pReadHandle;
  pInfo->curPos = 0;
-  pInfo->pSlimit = (SLimitNode*)pPhyNode->node.pSlimit; //TODO: slimit now only indicate group

+  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);
  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,
                  pTaskInfo);
  initResultSizeInfo(&pOperator->resultInfo, 4096);
--- a/source/libs/executor/src/streamtimewindowoperator.c
+++ b/source/libs/executor/src/streamtimewindowoperator.c
@ -3605,7 +3605,6 @@ void streamStateReloadState(SOperatorInfo* pOperator) {
  for (int32_t i = 0; i < num; i++) {
    SStateWindowInfo curInfo = {0};
    SStateWindowInfo nextInfo = {0};
-    SStateWindowInfo dummy = {0};
    qDebug("===stream=== reload state. try process result %" PRId64 ", %" PRIu64 ", index:%d", pSeKeyBuf[i].win.skey,
           pSeKeyBuf[i].groupId, i);
    getStateWindowInfoByKey(pAggSup, pSeKeyBuf + i, &curInfo, &nextInfo);
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@ -2059,7 +2059,6 @@ typedef struct SCollectFuncsCxt {
  char*           tableAlias;
  FFuncClassifier classifier;
  SNodeList*      pFuncs;
-  SHashObj*       pFuncsSet;
 } SCollectFuncsCxt;

 static EDealRes collectFuncs(SNode* pNode, void* pContext) {
@ -2074,9 +2073,15 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) {
      }
    }
    SExprNode* pExpr = (SExprNode*)pNode;
-    if (NULL == taosHashGet(pCxt->pFuncsSet, &pExpr, sizeof(SExprNode*))) {
+    bool bFound = false;
+    SNode* pn = NULL;
+    FOREACH(pn, pCxt->pFuncs) {
+      if (nodesEqualNode(pn, pNode)) {
+        bFound = true;
+      }
+    }
+    if (!bFound) {
      pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode));
-      taosHashPut(pCxt->pFuncsSet, &pExpr, POINTER_BYTES, &pExpr, POINTER_BYTES);
    }
    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
  }
@ -2103,12 +2108,10 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAl
  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
                          .classifier = classifier,
                          .tableAlias = tableAlias,
-                          .pFuncs = (NULL == *pFuncs ? nodesMakeList() : *pFuncs),
-                          .pFuncsSet = taosHashInit(4, funcNodeHash, false, false)};
-  if (NULL == cxt.pFuncs || NULL == cxt.pFuncsSet) {
+                          .pFuncs = (NULL == *pFuncs ? nodesMakeList() : *pFuncs)};
+  if (NULL == cxt.pFuncs) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
-  taosHashSetEqualFp(cxt.pFuncsSet, funcNodeEqual);
  *pFuncs = NULL;
  nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
  if (TSDB_CODE_SUCCESS == cxt.errCode) {
@ -2120,7 +2123,6 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAl
  } else {
    nodesDestroyList(cxt.pFuncs);
  }
-  taosHashCleanup(cxt.pFuncsSet);

  return cxt.errCode;
 }
--- a/source/libs/parser/inc/parAst.h
+++ b/source/libs/parser/inc/parAst.h
@ -99,6 +99,7 @@ void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt);

 SNode* createRawExprNode(SAstCreateContext* pCxt, const SToken* pToken, SNode* pNode);
 SNode* createRawExprNodeExt(SAstCreateContext* pCxt, const SToken* pStart, const SToken* pEnd, SNode* pNode);
+SNode* setRawExprNodeIsPseudoColumn(SAstCreateContext* pCxt, SNode* pNode, bool isPseudoColumn);
 SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode);
 SToken getTokenFromRawExprNode(SAstCreateContext* pCxt, SNode* pNode);

--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@ -828,7 +828,7 @@ expr_or_subquery(A) ::= expression(B).
 //expr_or_subquery(A) ::= subquery(B).                                              { A = createTempTableNode(pCxt, releaseRawExprNode(pCxt, B), NULL); }

 expression(A) ::= literal(B).                                                     { A = B; }
-expression(A) ::= pseudo_column(B).                                               { A = B; }
+expression(A) ::= pseudo_column(B).                                               { A = B; setRawExprNodeIsPseudoColumn(pCxt, A, true); }
 expression(A) ::= column_reference(B).                                            { A = B; }
 expression(A) ::= function_expression(B).                                         { A = B; }
 expression(A) ::= case_when_expression(B).                                        { A = B; }
--- a/source/libs/parser/src/parAstCreater.c
+++ b/source/libs/parser/src/parAstCreater.c
@ -267,6 +267,15 @@ SNode* createRawExprNodeExt(SAstCreateContext* pCxt, const SToken* pStart, const
  return (SNode*)target;
 }

+SNode* setRawExprNodeIsPseudoColumn(SAstCreateContext* pCxt, SNode* pNode, bool isPseudoColumn) {
+  CHECK_PARSER_STATUS(pCxt);
+  if (NULL == pNode || QUERY_NODE_RAW_EXPR != nodeType(pNode)) {
+    return pNode;
+  }
+  ((SRawExprNode*)pNode)->isPseudoColumn = isPseudoColumn;
+  return pNode;
+}
+
 SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
  CHECK_PARSER_STATUS(pCxt);
  SRawExprNode* pRawExpr = (SRawExprNode*)pNode;
@ -276,6 +285,10 @@ SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
    if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
      strcpy(pExpr->aliasName, ((SColumnNode*)pExpr)->colName);
      strcpy(pExpr->userAlias, ((SColumnNode*)pExpr)->colName);
+    } else if (pRawExpr->isPseudoColumn) {
+      // all pseudo column are translate to function with same name
+      strcpy(pExpr->userAlias, ((SFunctionNode*)pExpr)->functionName);
+      strcpy(pExpr->aliasName, ((SFunctionNode*)pExpr)->functionName);     
    } else {
      int32_t len = TMIN(sizeof(pExpr->aliasName) - 1, pRawExpr->n);

--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@ -269,6 +269,8 @@ static int32_t  createLastTsSelectStmt(char* pDb, char* pTable, STableMeta* pMet
 static int32_t  setQuery(STranslateContext* pCxt, SQuery* pQuery);
 static int32_t  setRefreshMate(STranslateContext* pCxt, SQuery* pQuery);

+static int32_t replacePsedudoColumnFuncWithColumn(STranslateContext* pCxt, SNode** ppNode);
+
 static bool afterGroupBy(ESqlClause clause) { return clause > SQL_CLAUSE_GROUP_BY; }

 static bool beforeHaving(ESqlClause clause) { return clause < SQL_CLAUSE_HAVING; }
@ -1610,26 +1612,6 @@ static int32_t translateAggFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
  return TSDB_CODE_SUCCESS;
 }

-static int32_t translateScanPseudoColumnFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
-  if (!fmIsScanPseudoColumnFunc(pFunc->funcId)) {
-    return TSDB_CODE_SUCCESS;
-  }
-  if (0 == LIST_LENGTH(pFunc->pParameterList)) {
-    if (!isSelectStmt(pCxt->pCurrStmt) || NULL == ((SSelectStmt*)pCxt->pCurrStmt)->pFromTable ||
-        QUERY_NODE_REAL_TABLE != nodeType(((SSelectStmt*)pCxt->pCurrStmt)->pFromTable)) {
-      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TBNAME);
-    }
-  } else {
-    SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
-    STableNode* pTable = NULL;
-    pCxt->errCode = findTable(pCxt, pVal->literal, &pTable);
-    if (TSDB_CODE_SUCCESS == pCxt->errCode && (NULL == pTable || QUERY_NODE_REAL_TABLE != nodeType(pTable))) {
-      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TBNAME);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t translateIndefiniteRowsFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
  if (!fmIsIndefiniteRowsFunc(pFunc->funcId)) {
    return TSDB_CODE_SUCCESS;
@ -1699,7 +1681,8 @@ static int32_t translateInterpFunc(STranslateContext* pCxt, SFunctionNode* pFunc
  return TSDB_CODE_SUCCESS;
 }

-static int32_t translateInterpPseudoColumnFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
+static int32_t translateInterpPseudoColumnFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRewriteToColumn) {
+  SFunctionNode* pFunc = (SFunctionNode*)(*ppNode);
  if (!fmIsInterpPseudoColumnFunc(pFunc->funcId)) {
    return TSDB_CODE_SUCCESS;
  }
@ -1711,6 +1694,25 @@ static int32_t translateInterpPseudoColumnFunc(STranslateContext* pCxt, SFunctio
    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_INTERP_CLAUSE,
                                   "%s is not allowed in where clause", pFunc->functionName);
  }
+
+  SSelectStmt* pSelect = (SSelectStmt*)pCxt->pCurrStmt;
+  SNode* pNode = NULL;
+  bool bFound = false;
+  FOREACH(pNode, pSelect->pProjectionList) {
+    if (nodeType(pNode) == QUERY_NODE_FUNCTION && strcasecmp(((SFunctionNode*)pNode)->functionName, "interp") == 0) {
+      bFound = true;
+      break;
+    }
+  }
+  if (!bFound) {
+    *pRewriteToColumn = true;
+    int32_t code = replacePsedudoColumnFuncWithColumn(pCxt, ppNode);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+    translateColumn(pCxt, (SColumnNode**)ppNode);
+    return pCxt->errCode;    
+  }
  return TSDB_CODE_SUCCESS;
 }

@ -1766,20 +1768,6 @@ static int32_t translateForbidFillFunc(STranslateContext* pCxt, SFunctionNode* p
  return TSDB_CODE_SUCCESS;
 }

-static int32_t translateWindowPseudoColumnFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
-  if (!fmIsWindowPseudoColumnFunc(pFunc->funcId)) {
-    return TSDB_CODE_SUCCESS;
-  }
-  if (!isSelectStmt(pCxt->pCurrStmt) || NULL == ((SSelectStmt*)pCxt->pCurrStmt)->pWindow) {
-    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_WINDOW_PC);
-  }
-  if (beforeWindow(pCxt->currClause)) {
-    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_WINDOW_PC, "There mustn't be %s",
-                                   pFunc->functionName);
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t translateForbidStreamFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
  if (!fmIsForbidStreamFunc(pFunc->funcId)) {
    return TSDB_CODE_SUCCESS;
@ -2008,10 +1996,108 @@ static int32_t rewriteSystemInfoFunc(STranslateContext* pCxt, SNode** pNode) {
  return TSDB_CODE_PAR_INTERNAL_ERROR;
 }

-static int32_t translateNormalFunction(STranslateContext* pCxt, SFunctionNode* pFunc) {
+static int32_t replacePsedudoColumnFuncWithColumn(STranslateContext* pCxt, SNode** ppNode) {
+  SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
+  if (pCol == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  SExprNode* pOldExpr = (SExprNode*)(*ppNode);
+  //rewrite a.tbname == tbname(a)
+  if (nodeType(*ppNode) == QUERY_NODE_FUNCTION && ((SFunctionNode*)(*ppNode))->funcType == FUNCTION_TYPE_TBNAME) {
+    SFunctionNode* pFunc = (SFunctionNode*)(*ppNode);
+    if (0 != LIST_LENGTH(pFunc->pParameterList)) {
+      SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
+      pCol->node.resType = pOldExpr->resType;
+      strcpy(pCol->tableAlias, pVal->literal);
+      strcpy(pCol->colName, pFunc->functionName);
+      strcpy(pCol->node.aliasName, pCol->colName);
+      strcpy(pCol->node.userAlias, pCol->colName);
+      nodesDestroyNode(*ppNode);
+      *ppNode = (SNode*)pCol;
+
+      return TSDB_CODE_SUCCESS;      
+    }
+  }
+  pCol->node.resType = pOldExpr->resType;
+  strcpy(pCol->node.aliasName, pOldExpr->aliasName);
+  strcpy(pCol->node.userAlias, pOldExpr->userAlias);
+  strcpy(pCol->colName, pOldExpr->aliasName);
+
+  nodesDestroyNode(*ppNode);
+  *ppNode = (SNode*)pCol;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t rewriteToColumnAndRetranslate(STranslateContext* pCxt, SNode** ppNode, int32_t errCode) {
+    int32_t code = replacePsedudoColumnFuncWithColumn(pCxt, ppNode);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+    translateColumn(pCxt, (SColumnNode**)ppNode);
+    if (pCxt->errCode != TSDB_CODE_SUCCESS) {
+      return generateSyntaxErrMsg(&pCxt->msgBuf, errCode);
+    } else {
+      return TSDB_CODE_SUCCESS;
+    }  
+}
+
+static int32_t translateWindowPseudoColumnFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRewriteToColumn) {
+  SFunctionNode* pFunc = (SFunctionNode*)(*ppNode);
+  if (!fmIsWindowPseudoColumnFunc(pFunc->funcId)) {
+    return TSDB_CODE_SUCCESS;
+  }  
+  if (!isSelectStmt(pCxt->pCurrStmt)) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_WINDOW_PC);
+  }
+  if (((SSelectStmt*)pCxt->pCurrStmt)->pWindow && beforeWindow(pCxt->currClause)) {
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_WINDOW_PC, "There mustn't be %s",
+                                   pFunc->functionName);
+  }
+  if (NULL == ((SSelectStmt*)pCxt->pCurrStmt)->pWindow) {
+    *pRewriteToColumn = true;
+    return rewriteToColumnAndRetranslate(pCxt, ppNode, TSDB_CODE_PAR_INVALID_WINDOW_PC);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateScanPseudoColumnFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRewriteToColumn) {
+  SFunctionNode* pFunc = (SFunctionNode*)(*ppNode);
+    if (!fmIsScanPseudoColumnFunc(pFunc->funcId)) {
+    return TSDB_CODE_SUCCESS;
+  }
+  if (0 == LIST_LENGTH(pFunc->pParameterList)) {
+    if (!isSelectStmt(pCxt->pCurrStmt) || NULL == ((SSelectStmt*)pCxt->pCurrStmt)->pFromTable) {
+      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TBNAME);
+    }
+    if (QUERY_NODE_REAL_TABLE != nodeType(((SSelectStmt*)pCxt->pCurrStmt)->pFromTable)) {
+      *pRewriteToColumn = true;
+      return rewriteToColumnAndRetranslate(pCxt, ppNode, TSDB_CODE_PAR_INVALID_TBNAME);
+    }
+  } else {
+    SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
+    STableNode* pTable = NULL;
+    pCxt->errCode = findTable(pCxt, pVal->literal, &pTable);
+    if (TSDB_CODE_SUCCESS != pCxt->errCode || (NULL == pTable)) {
+      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TBNAME);
+    } 
+    if (nodeType(pTable) != QUERY_NODE_REAL_TABLE) {
+      *pRewriteToColumn = true;
+      return rewriteToColumnAndRetranslate(pCxt, ppNode, TSDB_CODE_PAR_INVALID_TBNAME);
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateNormalFunction(STranslateContext* pCxt, SNode** ppNode) {
+  SFunctionNode* pFunc = (SFunctionNode*)(*ppNode);
  int32_t code = translateAggFunc(pCxt, pFunc);
  if (TSDB_CODE_SUCCESS == code) {
-    code = translateScanPseudoColumnFunc(pCxt, pFunc);
+    bool bRewriteToColumn = false;
+    code = translateScanPseudoColumnFunc(pCxt, ppNode, &bRewriteToColumn);
+    if (bRewriteToColumn) {
+      return code;
+    }
  }
  if (TSDB_CODE_SUCCESS == code) {
    code = translateIndefiniteRowsFunc(pCxt, pFunc);
@ -2020,7 +2106,11 @@ static int32_t translateNormalFunction(STranslateContext* pCxt, SFunctionNode* p
    code = translateForbidFillFunc(pCxt, pFunc);
  }
  if (TSDB_CODE_SUCCESS == code) {
-    code = translateWindowPseudoColumnFunc(pCxt, pFunc);
+    bool bRewriteToColumn = false;
+    code = translateWindowPseudoColumnFunc(pCxt, ppNode, &bRewriteToColumn);
+    if (bRewriteToColumn) {
+      return code;
+    }
  }
  if (TSDB_CODE_SUCCESS == code) {
    code = translateForbidStreamFunc(pCxt, pFunc);
@ -2041,7 +2131,11 @@ static int32_t translateNormalFunction(STranslateContext* pCxt, SFunctionNode* p
    code = translateInterpFunc(pCxt, pFunc);
  }
  if (TSDB_CODE_SUCCESS == code) {
-    code = translateInterpPseudoColumnFunc(pCxt, pFunc);
+    bool bRewriteToColumn = false;
+    code = translateInterpPseudoColumnFunc(pCxt, ppNode, &bRewriteToColumn);
+    if (bRewriteToColumn) {
+      return code;
+    }
  }
  if (TSDB_CODE_SUCCESS == code) {
    code = translateTimelineFunc(pCxt, pFunc);
@ -2112,7 +2206,7 @@ static int32_t translateFunctionImpl(STranslateContext* pCxt, SFunctionNode** pF
  if (fmIsClientPseudoColumnFunc((*pFunc)->funcId)) {
    return rewriteClientPseudoColumnFunc(pCxt, (SNode**)pFunc);
  }
-  return translateNormalFunction(pCxt, *pFunc);
+  return translateNormalFunction(pCxt, (SNode**)pFunc);
 }

 static EDealRes translateFunction(STranslateContext* pCxt, SFunctionNode** pFunc) {
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@ -2730,36 +2730,6 @@ static bool tagScanOptShouldBeOptimized(SLogicNode* pNode) {
  return true;
 }

-static SLogicNode* tagScanOptFindAncestorWithSlimit(SLogicNode* pTableScanNode) {
-  SLogicNode* pNode = pTableScanNode->pParent;
-  while (NULL != pNode) {
-    if (QUERY_NODE_LOGIC_PLAN_PARTITION == nodeType(pNode) || QUERY_NODE_LOGIC_PLAN_AGG == nodeType(pNode) ||
-        QUERY_NODE_LOGIC_PLAN_WINDOW == nodeType(pNode) || QUERY_NODE_LOGIC_PLAN_SORT == nodeType(pNode)) {
-      return NULL;
-    }
-    if (NULL != pNode->pSlimit) {
-      return pNode;
-    }
-    pNode = pNode->pParent;
-  }
-  return NULL;
-}
-
-static void tagScanOptCloneAncestorSlimit(SLogicNode* pTableScanNode) {
-  if (NULL != pTableScanNode->pSlimit) {
-    return;
-  }
-
-  SLogicNode* pNode = tagScanOptFindAncestorWithSlimit(pTableScanNode);
-  if (NULL != pNode) {
-    // TODO: only set the slimit now. push down slimit later
-    pTableScanNode->pSlimit = nodesCloneNode(pNode->pSlimit);
-    ((SLimitNode*)pTableScanNode->pSlimit)->limit += ((SLimitNode*)pTableScanNode->pSlimit)->offset;
-    ((SLimitNode*)pTableScanNode->pSlimit)->offset = 0;
-  }
-  return;
-}
-
 static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
  SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized);
  if (NULL == pScanNode) {
@ -2795,13 +2765,6 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp
    pScanNode->node.pTargets = pScanTargets;
  }

-  int32_t code = replaceLogicNode(pLogicSubplan, pAgg, (SLogicNode*)pScanNode);
-  if (TSDB_CODE_SUCCESS == code) {
-    NODES_CLEAR_LIST(pAgg->pChildren);
-  }
-  nodesDestroyNode((SNode*)pAgg);
-  tagScanOptCloneAncestorSlimit((SLogicNode*)pScanNode);
-
  pScanNode->onlyMetaCtbIdx = false;
  
  pCxt->optimized = true;
--- a/source/libs/stream/src/streamUpdate.c
+++ b/source/libs/stream/src/streamUpdate.c
@ -219,17 +219,22 @@ bool updateInfoIsUpdated(SUpdateInfo *pInfo, uint64_t tableId, TSKEY ts) {
  }

  SScalableBf *pSBf = getSBf(pInfo, ts);
-  // pSBf may be a null pointer
-  if (pSBf) {
-    res = tScalableBfPut(pSBf, &updateKey, sizeof(SUpdateKey));
-  }

  int32_t size = taosHashGetSize(pInfo->pMap);
  if ((!pMapMaxTs && size < DEFAULT_MAP_SIZE) || (pMapMaxTs && *pMapMaxTs < ts)) {
    taosHashPut(pInfo->pMap, &tableId, sizeof(uint64_t), &ts, sizeof(TSKEY));
+    // pSBf may be a null pointer
+    if (pSBf) {
+      res = tScalableBfPutNoCheck(pSBf, &updateKey, sizeof(SUpdateKey));
+    }
    return false;
  }

+  // pSBf may be a null pointer
+  if (pSBf) {
+    res = tScalableBfPut(pSBf, &updateKey, sizeof(SUpdateKey));
+  }
+
  if (!pMapMaxTs && maxTs < ts) {
    taosArraySet(pInfo->pTsBuckets, index, &ts);
    return false;
--- a/source/libs/stream/src/tstreamFileState.c
+++ b/source/libs/stream/src/tstreamFileState.c
@ -177,7 +177,10 @@ SStreamFileState* streamFileStateInit(int64_t memSize, uint32_t keySize, uint32_
  // todo(liuyao) optimize
  if (type == STREAM_STATE_BUFF_HASH) {
    recoverSnapshot(pFileState, checkpointId);
+  } else {
+    recoverSesssion(pFileState, checkpointId);
  }
+
  return pFileState;

 _error:
@ -642,12 +645,24 @@ int32_t deleteExpiredCheckPoint(SStreamFileState* pFileState, TSKEY mark) {
 }

 int32_t recoverSesssion(SStreamFileState* pFileState, int64_t ckId) {
-  int              code = TSDB_CODE_SUCCESS;
+  int code = TSDB_CODE_SUCCESS;
+  if (pFileState->maxTs != INT64_MIN) {
+    int64_t mark = (INT64_MIN + pFileState->deleteMark >= pFileState->maxTs)
+                       ? INT64_MIN
+                       : pFileState->maxTs - pFileState->deleteMark;
+    deleteExpiredCheckPoint(pFileState, mark);
+  }
+
  SStreamStateCur* pCur = streamStateSessionSeekToLast_rocksdb(pFileState->pFileStore);
  if (pCur == NULL) {
    return -1;
  }
+  int32_t recoverNum = TMIN(MIN_NUM_OF_ROW_BUFF, pFileState->maxRowCount);
  while (code == TSDB_CODE_SUCCESS) {
+    if (pFileState->curRowCount >= recoverNum) {
+      break;
+    }
+
    void*       pVal = NULL;
    int32_t     vlen = 0;
    SSessionKey key = {0};
@ -655,12 +670,14 @@ int32_t recoverSesssion(SStreamFileState* pFileState, int64_t ckId) {
    if (code != 0) {
      break;
    }
-    taosMemoryFree(pVal);
+    SRowBuffPos* pPos = createSessionWinBuff(pFileState, &key, pVal, &vlen);
+    putSessionWinResultBuff(pFileState, pPos);
    code = streamStateSessionCurPrev_rocksdb(pCur);
  }
  streamStateFreeCur(pCur);
  return code;
 }
+
 int32_t recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) {
  int32_t code = TSDB_CODE_SUCCESS;
  if (pFileState->maxTs != INT64_MIN) {
@ -674,11 +691,12 @@ int32_t recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) {
  if (pCur == NULL) {
    return -1;
  }
-
+  int32_t recoverNum = TMIN(MIN_NUM_OF_ROW_BUFF, pFileState->maxRowCount);
  while (code == TSDB_CODE_SUCCESS) {
-    if (pFileState->curRowCount == pFileState->maxRowCount) {
+    if (pFileState->curRowCount >= recoverNum) {
      break;
    }
+
    void*        pVal = NULL;
    int32_t      vlen = 0;
    SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState);
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@ -2860,11 +2860,12 @@ int32_t syncNodeChangeConfig(SSyncNode* ths, SSyncRaftEntry* pEntry, char* str){
 }

 int32_t syncNodeAppend(SSyncNode* ths, SSyncRaftEntry* pEntry) {
+  int32_t code = -1;
  if (pEntry->dataLen < sizeof(SMsgHead)) {
    sError("vgId:%d, cannot append an invalid client request with no msg head. type:%s, dataLen:%d", ths->vgId,
           TMSG_INFO(pEntry->originalRpcType), pEntry->dataLen);
    syncEntryDestroy(pEntry);
-    return -1;
+    goto _out;
  }

  // append to log buffer
@ -2873,9 +2874,11 @@ int32_t syncNodeAppend(SSyncNode* ths, SSyncRaftEntry* pEntry) {
    ASSERT(terrno != 0);
    (void)syncFsmExecute(ths, ths->pFsm, ths->state, raftStoreGetTerm(ths), pEntry, terrno, false);
    syncEntryDestroy(pEntry);
-    return -1;
+    goto _out;
  }
- 
+
+  code = 0;
+_out:;
  // proceed match index, with replicating on needed
  SyncIndex matchIndex = syncLogBufferProceed(ths->pLogBuf, ths, NULL, "Append");  

@ -2886,7 +2889,7 @@ int32_t syncNodeAppend(SSyncNode* ths, SSyncRaftEntry* pEntry) {

  // multi replica
  if (ths->replicaNum > 1) {
-    return 0;
+    return code;
  }

  // single replica
@ -2894,10 +2897,10 @@ int32_t syncNodeAppend(SSyncNode* ths, SSyncRaftEntry* pEntry) {

  if (syncLogBufferCommit(ths->pLogBuf, ths, ths->commitIndex) < 0) {
    sError("vgId:%d, failed to commit until commitIndex:%" PRId64 "", ths->vgId, ths->commitIndex);
-    return -1;
+    code = -1;
  }

-  return 0;
+  return code;
 }

 bool syncNodeHeartbeatReplyTimeout(SSyncNode* pSyncNode) {
--- a/source/util/src/tbloomfilter.c
+++ b/source/util/src/tbloomfilter.c
@ -24,9 +24,8 @@

 static FORCE_INLINE bool setBit(uint64_t *buf, uint64_t index) {
  uint64_t unitIndex = index >> UNIT_ADDR_NUM_BITS;
-  uint64_t mask = 1ULL << (index % UNIT_NUM_BITS);
  uint64_t old = buf[unitIndex];
-  buf[unitIndex] |= mask;
+  buf[unitIndex] |= (1ULL << (index % UNIT_NUM_BITS));
  return buf[unitIndex] != old;
 }

@ -57,10 +56,8 @@ SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate) {

  // ln(2) = 0.693147180559945
  pBF->hashFunctions = (uint32_t)ceil(lnRate / 0.693147180559945);
-  /*pBF->hashFn1 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);*/
-  /*pBF->hashFn2 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_NCHAR);*/
-  pBF->hashFn1 = taosFastHash;
-  pBF->hashFn2 = taosDJB2Hash;
+  pBF->hashFn1 = HASH_FUNCTION_1;
+  pBF->hashFn2 = HASH_FUNCTION_2;
  pBF->buffer = taosMemoryCalloc(pBF->numUnits, sizeof(uint64_t));
  if (pBF->buffer == NULL) {
    tBloomFilterDestroy(pBF);
@ -69,14 +66,29 @@ SBloomFilter *tBloomFilterInit(uint64_t expectedEntries, double errorRate) {
  return pBF;
 }

-int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len) {
+int32_t tBloomFilterPutHash(SBloomFilter *pBF, uint64_t hash1, uint64_t hash2) {
  ASSERT(!tBloomFilterIsFull(pBF));
+  bool                    hasChange = false;
+  const register uint64_t size = pBF->numBits;
+  uint64_t                cbHash = hash1;
+  for (uint32_t i = 0; i < pBF->hashFunctions; ++i) {
+    hasChange |= setBit(pBF->buffer, cbHash % size);
+    cbHash += hash2;
+  }
+  if (hasChange) {
+    pBF->size++;
+    return TSDB_CODE_SUCCESS;
+  }
+  return TSDB_CODE_FAILED;
+}
+
+int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len) {
  uint64_t                h1 = (uint64_t)pBF->hashFn1(keyBuf, len);
  uint64_t                h2 = (uint64_t)pBF->hashFn2(keyBuf, len);
  bool                    hasChange = false;
  const register uint64_t size = pBF->numBits;
  uint64_t                cbHash = h1;
-  for (uint64_t i = 0; i < pBF->hashFunctions; ++i) {
+  for (uint32_t i = 0; i < pBF->hashFunctions; ++i) {
    hasChange |= setBit(pBF->buffer, cbHash % size);
    cbHash += h2;
  }
@ -87,16 +99,14 @@ int32_t tBloomFilterPut(SBloomFilter *pBF, const void *keyBuf, uint32_t len) {
  return TSDB_CODE_FAILED;
 }

-int32_t tBloomFilterNoContain(const SBloomFilter *pBF, const void *keyBuf, uint32_t len) {
-  uint64_t                h1 = (uint64_t)pBF->hashFn1(keyBuf, len);
-  uint64_t                h2 = (uint64_t)pBF->hashFn2(keyBuf, len);
+int32_t tBloomFilterNoContain(const SBloomFilter *pBF, uint64_t hash1, uint64_t hash2) {
  const register uint64_t size = pBF->numBits;
-  uint64_t                cbHash = h1;
-  for (uint64_t i = 0; i < pBF->hashFunctions; ++i) {
+  uint64_t                cbHash = hash1;
+  for (uint32_t i = 0; i < pBF->hashFunctions; ++i) {
    if (!getBit(pBF->buffer, cbHash % size)) {
      return TSDB_CODE_SUCCESS;
    }
-    cbHash += h2;
+    cbHash += hash2;
  }
  return TSDB_CODE_FAILED;
 }
@ -137,10 +147,8 @@ SBloomFilter *tBloomFilterDecode(SDecoder *pDecoder) {
    if (tDecodeU64(pDecoder, pUnits + i) < 0) goto _error;
  }
  if (tDecodeDouble(pDecoder, &pBF->errorRate) < 0) goto _error;
-  /*pBF->hashFn1 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP);*/
-  /*pBF->hashFn2 = taosGetDefaultHashFunction(TSDB_DATA_TYPE_NCHAR);*/
-  pBF->hashFn1 = taosFastHash;
-  pBF->hashFn2 = taosDJB2Hash;
+  pBF->hashFn1 = HASH_FUNCTION_1;
+  pBF->hashFn2 = HASH_FUNCTION_2;
  return pBF;

 _error:
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@ -670,6 +670,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_CONSUMER_ERROR,             "Consumer error, to
 TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE,         "Topic num out of range")
 TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_GROUP_OUT_OF_RANGE,         "Group num out of range 100")
 TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_SAME_COMMITTED_VALUE,       "Same committed value")
+TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP,     "Replay need only one vgroup if subscribe super table")
+TAOS_DEFINE_ERROR(TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT,         "Replay is disabled if subscribe db or stable")

 // stream
 TAOS_DEFINE_ERROR(TSDB_CODE_STREAM_TASK_NOT_EXIST,          "Stream task not exist")
--- a/source/util/src/tscalablebf.c
+++ b/source/util/src/tscalablebf.c
@ -39,13 +39,31 @@ SScalableBf *tScalableBfInit(uint64_t expectedEntries, double errorRate) {
    return NULL;
  }
  pSBf->growth = DEFAULT_GROWTH;
+  pSBf->hashFn1 = HASH_FUNCTION_1;
+  pSBf->hashFn2 = HASH_FUNCTION_2;
  return pSBf;
 }

+int32_t tScalableBfPutNoCheck(SScalableBf *pSBf, const void *keyBuf, uint32_t len) {
+  int32_t size = taosArrayGetSize(pSBf->bfArray);
+  SBloomFilter *pNormalBf = taosArrayGetP(pSBf->bfArray, size - 1);
+  ASSERT(pNormalBf);
+  if (tBloomFilterIsFull(pNormalBf)) {
+    pNormalBf = tScalableBfAddFilter(pSBf, pNormalBf->expectedEntries * pSBf->growth,
+                                     pNormalBf->errorRate * DEFAULT_TIGHTENING_RATIO);
+    if (pNormalBf == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  return tBloomFilterPut(pNormalBf, keyBuf, len);
+}
+
 int32_t tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len) {
+  uint64_t h1 = (uint64_t)pSBf->hashFn1(keyBuf, len);
+  uint64_t h2 = (uint64_t)pSBf->hashFn2(keyBuf, len);
  int32_t size = taosArrayGetSize(pSBf->bfArray);
  for (int32_t i = size - 2; i >= 0; --i) {
-    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i), keyBuf, len) != TSDB_CODE_SUCCESS) {
+    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i), h1, h2) != TSDB_CODE_SUCCESS) {
      return TSDB_CODE_FAILED;
    }
  }
@ -59,13 +77,15 @@ int32_t tScalableBfPut(SScalableBf *pSBf, const void *keyBuf, uint32_t len) {
      return TSDB_CODE_OUT_OF_MEMORY;
    }
  }
-  return tBloomFilterPut(pNormalBf, keyBuf, len);
+  return tBloomFilterPutHash(pNormalBf, h1, h2);
 }

 int32_t tScalableBfNoContain(const SScalableBf *pSBf, const void *keyBuf, uint32_t len) {
+  uint64_t h1 = (uint64_t)pSBf->hashFn1(keyBuf, len);
+  uint64_t h2 = (uint64_t)pSBf->hashFn2(keyBuf, len);
  int32_t size = taosArrayGetSize(pSBf->bfArray);
  for (int32_t i = size - 1; i >= 0; --i) {
-    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i), keyBuf, len) != TSDB_CODE_SUCCESS) {
+    if (tBloomFilterNoContain(taosArrayGetP(pSBf->bfArray, i), h1, h2) != TSDB_CODE_SUCCESS) {
      return TSDB_CODE_FAILED;
    }
  }
@ -113,6 +133,8 @@ int32_t tScalableBfEncode(const SScalableBf *pSBf, SEncoder *pEncoder) {

 SScalableBf *tScalableBfDecode(SDecoder *pDecoder) {
  SScalableBf *pSBf = taosMemoryCalloc(1, sizeof(SScalableBf));
+  pSBf->hashFn1 = HASH_FUNCTION_1;
+  pSBf->hashFn2 = HASH_FUNCTION_2;
  pSBf->bfArray = NULL;
  int32_t size = 0;
  if (tDecodeI32(pDecoder, &size) < 0) goto _error;
--- a/source/util/test/bloomFilterTest.cpp
+++ b/source/util/test/bloomFilterTest.cpp
@ -43,12 +43,16 @@ TEST(TD_UTIL_BLOOMFILTER_TEST, normal_bloomFilter) {

  for (int64_t i = 0; i < 1000; i++) {
    int64_t ts = i + ts1;
-    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4, &ts, sizeof(int64_t)), TSDB_CODE_FAILED);
+    uint64_t h1 = (uint64_t) pBF4->hashFn1((const char*)&ts, sizeof(int64_t));
+    uint64_t h2 = (uint64_t) pBF4->hashFn2((const char*)&ts, sizeof(int64_t));
+    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4, h1, h2), TSDB_CODE_FAILED);
  }

  for (int64_t i = 2000; i < 3000; i++) {
    int64_t ts = i + ts1;
-    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4, &ts, sizeof(int64_t)), TSDB_CODE_SUCCESS);
+    uint64_t h1 = (uint64_t) pBF4->hashFn1((const char*)&ts, sizeof(int64_t));
+    uint64_t h2 = (uint64_t) pBF4->hashFn2((const char*)&ts, sizeof(int64_t));
+    GTEST_ASSERT_EQ(tBloomFilterNoContain(pBF4,  h1, h2), TSDB_CODE_SUCCESS);
  }

  tBloomFilterDestroy(pBF1);
--- a/tests/develop-test/2-query/pseudo_column.py
+++ b/tests/develop-test/2-query/pseudo_column.py
@ -0,0 +1,97 @@
+import sys 
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import tdDnodes
+from math import inf
+
+class TDTestCase:
+    def caseDescription(self):
+        '''
+        case1<shenglian zhou>: [TS-3904/TS-3005] pseudo column test case
+        ''' 
+        return
+    
+    def init(self, conn, logSql, replicaVer=1):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), True)
+        self._conn = conn
+        
+    def restartTaosd(self, index=1, dbname="db"):
+        tdDnodes.stop(index)
+        tdDnodes.startWithoutSleep(index)
+        tdSql.execute(f"use pseudo_col")
+
+    def run(self):
+        print("running {}".format(__file__))
+        tdSql.execute("drop database if exists pseudo_col")
+        tdSql.execute("create database if not exists pseudo_col")
+        tdSql.execute('use pseudo_col')
+        tdSql.execute('create table st(ts timestamp, f int) tags (t int)')
+        tdSql.execute("insert into ct1 using st tags(1) values('2023-10-10 14:10:00', 1)('2023-10-10 14:10:01', 11)")
+        tdSql.execute("insert into ct2 using st tags(2) values('2023-10-10 14:10:02', 2)('2023-10-10 14:10:03', 22)")
+
+        tdSql.query('select tbname from (select tbname from st) order by tbname')
+        tdSql.checkCols(1)
+        tdSql.checkRows(4)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(1, 0, 'ct1')
+        tdSql.checkData(2, 0, 'ct2')
+        tdSql.checkData(2, 0, 'ct2')
+
+        tdSql.query('select `tbname` from (select tbname from st) order by tbname')
+        tdSql.checkCols(1)
+        tdSql.checkRows(4)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(1, 0, 'ct1')
+        tdSql.checkData(2, 0, 'ct2')
+        tdSql.checkData(2, 0, 'ct2')
+
+        tdSql.query('select `tbname` from (select tbname from st) order by tbname')
+        tdSql.checkCols(1)
+        tdSql.checkRows(4)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(1, 0, 'ct1')
+        tdSql.checkData(2, 0, 'ct2')
+        tdSql.checkData(2, 0, 'ct2')
+
+        tdSql.query('select tbname from (select st.tbname from st) order by tbname')
+        tdSql.checkCols(1)
+        tdSql.checkRows(4)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(1, 0, 'ct1')
+        tdSql.checkData(2, 0, 'ct2')
+        tdSql.checkData(2, 0, 'ct2')
+        
+        tdSql.query('select * from (select tbname, avg(f) from st partition by tbname) a partition by a.tbname order by a.tbname');       
+        tdSql.checkRows(2)
+        tdSql.checkCols(2)
+        tdSql.checkData(0, 0, 'ct1');
+        tdSql.checkData(0, 1, 6.0);
+        tdSql.checkData(1, 0, 'ct2');
+        tdSql.checkData(1, 1, 12.0);
+                         
+        tdSql.error('select tbname from (select * from st)')
+        tdSql.error('select st.tbname from (select st.tbname from st)')
+        tdSql.error('select `st.tbname` from (select st.tbname from st) order by tbname')
+        
+        tdSql.query('select _wstart, _wend, _wduration, c from (select _wstart, _wend, _wduration, count(*) as c from st interval(1s)) order by _wstart')
+        tdSql.checkCols(4)
+        tdSql.checkRows(4)
+        tdSql.checkData(0, 1, '2023-10-10 14:10:01')
+        tdSql.checkData(0, 3, 1)
+        
+        tdSql.error('select _wstart, _wend, _wduration, c from (select count(*) as c from st) order by _wstart')
+        
+        tdSql.query("select _irowts, if2 from (select _irowts, interp(f) as if2 from st range('2023-10-10 14:10:00', '2023-10-10 14:10:10') every(1s) fill(value, 8))")
+        tdSql.checkRows(11)
+        tdSql.checkData(9, 1, 8);
+        tdSql.execute('drop database pseudo_col')
+        
+        tdSql.error("select _irowts, if2 from (select interp(f) as if2 from st range('2023-10-10 14:10:00', '2023-10-10 14:10:10') every(1s) fill(value, 8))")
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
--- a/tests/develop-test/2-query/tag_scan.py
+++ b/tests/develop-test/2-query/tag_scan.py
@ -0,0 +1,206 @@
+import sys 
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import tdDnodes
+from math import inf
+
+class TDTestCase:
+    def caseDescription(self):
+        '''
+        case1<shenglian zhou>: [TD-11204]Difference improvement that can ignore negative 
+        ''' 
+        return
+    
+    def init(self, conn, logSql, replicaVer=1):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), True)
+        self._conn = conn
+        
+    def restartTaosd(self, index=1, dbname="db"):
+        tdDnodes.stop(index)
+        tdDnodes.startWithoutSleep(index)
+        tdSql.execute(f"use tagscan")
+
+
+    def runSingleVgroup(self):
+        print("running {}".format(__file__))
+        tdSql.execute("drop database if exists tagscan2")
+        tdSql.execute("create database if not exists tagscan2 vgroups 1")
+        tdSql.execute('use tagscan2')
+        tdSql.execute('create table stb1 (ts timestamp, c1 bool, c2 tinyint, c3 smallint, c4 int, c5 bigint, c6 float, c7 double, c8 binary(10), c9 nchar(10), c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned) TAGS(t1 int, t2 binary(10), t3 double);')
+
+        tdSql.execute("create table tb1 using stb1 tags(1,'1',1.0);")
+
+        tdSql.execute("create table tb2 using stb1 tags(2,'2',2.0);")
+
+        tdSql.execute("create table tb3 using stb1 tags(3,'3',3.0);")
+
+        tdSql.execute("create table tb4 using stb1 tags(4,'4',4.0);")
+
+        tdSql.execute("create table tb5 using stb1 tags(5,'5',5.0);")
+
+        tdSql.execute("create table tb6 using stb1 tags(5,'5',5.0);")
+
+        tdSql.execute('insert into tb1 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb2 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb3 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb4 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb5 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb6 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.query('select tags t1,t2 from stb1 order by t1,t2;')
+        tdSql.checkRows(6)
+        tdSql.checkData(0, 0, 1)
+        tdSql.checkData(0, 1, '1')
+        tdSql.checkData(1, 0, 2)
+        tdSql.checkData(1, 1, '2')
+        tdSql.checkData(2, 0, 3)
+        tdSql.checkData(2, 1, '3')
+        tdSql.checkData(3, 0, 4)
+        tdSql.checkData(3, 1, '4')
+        tdSql.checkData(4, 0, 5)
+        tdSql.checkData(4, 1, '5')
+        tdSql.checkData(5, 0, 5)
+        tdSql.checkData(5, 1, '5')
+
+        tdSql.query('select * from (select tags t1,t2 from stb1 group by t1,t2 slimit 2,3) order by t1,t2;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags tbname tn from stb1 group by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn from stb1 group by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn from stb1 group by tbname order by tbname limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+        tdSql.checkData(0, 0, 'tb3')
+
+        tdSql.query('select * from (select distinct tbname tn from stb1 limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select distinct tbname tn, t1,t2 from stb1 limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags t1,t2 from stb1 order by t1, t2 limit 2,3) order by t1, t2;')
+        tdSql.checkRows(3)
+        tdSql.checkData(0, 0, 3)
+        tdSql.checkData(0, 1, '3')
+        tdSql.checkData(1, 0, 4)
+        tdSql.checkData(1, 1, '4')
+        tdSql.checkData(2, 0, 5)
+        tdSql.checkData(2, 1, '5')
+
+        tdSql.query('select * from (select tbname tn, t1,t2 from stb1 partition by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn, t1,t2 from stb1 group by tbname, t1,t2 slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags tbname tn, t1,t2 from stb1 group by tbname, t1,t2 slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+
+        tdSql.execute('drop database tagscan2')
+    def runMultiVgroups(self):
+        print("running {}".format(__file__))
+        tdSql.execute("drop database if exists tagscan")
+        tdSql.execute("create database if not exists tagscan")
+        tdSql.execute('use tagscan')
+        tdSql.execute('create table stb1 (ts timestamp, c1 bool, c2 tinyint, c3 smallint, c4 int, c5 bigint, c6 float, c7 double, c8 binary(10), c9 nchar(10), c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned) TAGS(t1 int, t2 binary(10), t3 double);')
+
+        tdSql.execute("create table tb1 using stb1 tags(1,'1',1.0);")
+
+        tdSql.execute("create table tb2 using stb1 tags(2,'2',2.0);")
+
+        tdSql.execute("create table tb3 using stb1 tags(3,'3',3.0);")
+
+        tdSql.execute("create table tb4 using stb1 tags(4,'4',4.0);")
+
+        tdSql.execute("create table tb5 using stb1 tags(5,'5',5.0);")
+
+        tdSql.execute("create table tb6 using stb1 tags(5,'5',5.0);")
+
+        tdSql.execute('insert into tb1 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb2 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb3 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb4 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb5 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.execute('insert into tb6 values (\'2021-11-11 09:00:00\',true,1,1,1,1,1,1,"123","1234",1,1,1,1);')
+
+        tdSql.query('select tags t1,t2 from stb1 order by t1,t2;')
+        tdSql.checkRows(6)
+        tdSql.checkData(0, 0, 1)
+        tdSql.checkData(0, 1, '1')
+        tdSql.checkData(1, 0, 2)
+        tdSql.checkData(1, 1, '2')
+        tdSql.checkData(2, 0, 3)
+        tdSql.checkData(2, 1, '3')
+        tdSql.checkData(3, 0, 4)
+        tdSql.checkData(3, 1, '4')
+        tdSql.checkData(4, 0, 5)
+        tdSql.checkData(4, 1, '5')
+        tdSql.checkData(5, 0, 5)
+        tdSql.checkData(5, 1, '5')
+
+        tdSql.query('select * from (select tags t1,t2 from stb1 group by t1,t2 slimit 2,3) order by t1,t2;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags tbname tn from stb1 group by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn from stb1 group by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn from stb1 group by tbname order by tbname limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+        tdSql.checkData(0, 0, 'tb3')
+
+        tdSql.query('select * from (select distinct tbname tn from stb1 limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select distinct tbname tn, t1,t2 from stb1 limit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags t1,t2 from stb1 order by t1, t2 limit 2,3) order by t1, t2;')
+        tdSql.checkRows(3)
+        tdSql.checkData(0, 0, 3)
+        tdSql.checkData(0, 1, '3')
+        tdSql.checkData(1, 0, 4)
+        tdSql.checkData(1, 1, '4')
+        tdSql.checkData(2, 0, 5)
+        tdSql.checkData(2, 1, '5')
+
+        tdSql.query('select * from (select tbname tn, t1,t2 from stb1 partition by tbname slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tbname tn, t1,t2 from stb1 group by tbname, t1,t2 slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+        tdSql.query('select * from (select tags tbname tn, t1,t2 from stb1 group by tbname, t1,t2 slimit 2,3) order by tn;')
+        tdSql.checkRows(3)
+
+
+        tdSql.execute('drop database tagscan')
+
+    def run(self):
+        self.runMultiVgroups()
+        self.runSingleVgroup()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
--- a/tests/parallel_test/cases.task
+++ b/tests/parallel_test/cases.task
@ -163,6 +163,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/dataFromTsdbNWal.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/dataFromTsdbNWal-multiCtb.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_taosx.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmq_replay.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/tmqSeekAndCommit.py
 ,,n,system-test,python3 ./test.py -f 7-tmq/tmq_offset.py
 ,,n,system-test,python3 ./test.py -f 7-tmq/tmqDataPrecisionUnit.py
@ -399,6 +400,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/smaTest.py -R
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/sma_index.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sml_TS-3724.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sml-TD19291.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/varbinary.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sml.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sml.py -R
@ -1270,7 +1272,9 @@

 #develop test
 ,,n,develop-test,python3 ./test.py -f 2-query/table_count_scan.py
+,,n,develop-test,python3 ./test.py -f 2-query/pseudo_column.py
 ,,n,develop-test,python3 ./test.py -f 2-query/ts-range.py
+,,n,develop-test,python3 ./test.py -f 2-query/tag_scan.py
 ,,n,develop-test,python3 ./test.py -f 2-query/show_create_db.py
 ,,n,develop-test,python3 ./test.py -f 5-taos-tools/taosbenchmark/auto_create_table_json.py
 ,,n,develop-test,python3 ./test.py -f 5-taos-tools/taosbenchmark/custom_col_tag.py
--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.py
@ -140,6 +140,7 @@ class TDCom:
        self.range_count = 5
        self.default_interval = 5
        self.stream_timeout = 12
+        self.create_stream_sleep = 0.5
        self.record_history_ts = str()
        self.precision = "ms"
        self.date_time = self.genTs(precision=self.precision)[0]
@ -881,6 +882,7 @@ class TDCom:
                stream_options += f" ignore update 0"
            if not use_except:
                tdSql.execute(f'create stream if not exists {stream_name} trigger at_once {stream_options} {fill_history} into {des_table} {subtable} as {source_sql} {fill};')
+                time.sleep(self.create_stream_sleep)
                return None
            else:
                return f'create stream if not exists {stream_name} {stream_options} {fill_history} into {des_table} {subtable} as {source_sql} {fill};'
@ -906,6 +908,7 @@ class TDCom:
                stream_options += f" ignore update 0"
            if not use_except:
                tdSql.execute(f'create stream if not exists {stream_name} {stream_options} {fill_history} into {des_table}{stb_field_name} {tags} {subtable} as {source_sql} {fill};')
+                time.sleep(self.create_stream_sleep)
                return None
            else:
                return f'create stream if not exists {stream_name} {stream_options} {fill_history} into {des_table}{stb_field_name} {tags} {subtable} as {source_sql} {fill};'
@ -1566,8 +1569,8 @@ class TDCom:
        res1 = tdSql.queryResult
        tdSql.query(sql2)
        res2 = self.cast_query_data(tdSql.queryResult) if tag_value_list or use_exist_stb else tdSql.queryResult
+        tdSql.sql = sql1
        new_list = list()
-
        if tag_value_list:
            res1 = self.float_handle(res1)
            res2 = self.float_handle(res2)
@ -1602,6 +1605,7 @@ class TDCom:
                tdSql.query(sql2)
                # res2 = tdSql.queryResult
                res2 = self.cast_query_data(tdSql.queryResult) if tag_value_list or use_exist_stb else tdSql.queryResult
+                tdSql.sql = sql1

                if tag_value_list:
                    res1 = self.float_handle(res1)
@ -1643,6 +1647,7 @@ class TDCom:
                tdSql.query(sql2)
                # res2 = tdSql.queryResult
                res2 = self.cast_query_data(tdSql.queryResult) if tag_value_list or use_exist_stb else tdSql.queryResult
+                tdSql.sql = sql1

                if tag_value_list:
                    res1 = self.float_handle(res1)
--- a/tests/script/tsim/stream/checkpointSession1.sim
+++ b/tests/script/tsim/stream/checkpointSession1.sim
@ -57,6 +57,8 @@ system sh/stop_dnodes.sh

 system sh/exec.sh -n dnode1 -s start

+sleep 2000
+
 sql insert into t1 values(1648791213002,3,2,3,1.1);
 sql insert into t2 values(1648791233003,4,2,3,1.1);

--- a/tests/script/tsim/stream/ignoreCheckUpdate.sim
+++ b/tests/script/tsim/stream/ignoreCheckUpdate.sim
@ -206,6 +206,8 @@ print create stream streams3 trigger at_once ignore update 1 into streamt3 as se

 sql create stream streams3 trigger at_once ignore update 1 into streamt3 as select  _wstart c1, count(*) c2, max(b) c3 from st interval(10s);

+sleep 2000
+
 sql insert into t1 values(1648791213000,1,1,1);
 sql insert into t1 values(1648791213000,2,2,2);

--- a/tests/system-test/2-query/sml-TD19291.py
+++ b/tests/system-test/2-query/sml-TD19291.py
@ -0,0 +1,60 @@
+
+import taos
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+from util.common import *
+
+class TDTestCase:
+    updatecfgDict = {'clientCfg': {'smlChildTableName': 'dataModelName', 'smlAutoChildTableNameDelimiter': '-', 'fqdn': 'localhost', 'smlDot2Underline': 1}, 'fqdn': 'localhost'}
+    print("===================: ", updatecfgDict)
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor(), True)
+
+    def check(self):
+        conn = taos.connect()
+        dbname = "td19291"
+        conn.execute("drop database if exists %s" % dbname)
+        conn.execute("create database if not exists %s precision 'us'" % dbname)
+        conn.select_db(dbname)
+
+        lines = [
+            'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+            'st,t1=3i64,t2=4f64,dataModelName=ttt c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+            'st,t1=3i64,t2=4f.64 c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+            'st,t1=ioiooo3i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i64uuuuuuuuuuuuuuuuuuuuuuuuuu4 c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+            'st,t2=q,t1=iooo3i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i64uuuuuuuuuuuuuuuuuuuuuuuuuu4 c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+            'st,t2=a,t1=ooo3i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i64uuuuuuuuuuuuuuuuuuuuuuuuuu4 c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000',
+        ]
+        conn.schemaless_insert(lines, taos.SmlProtocol.LINE_PROTOCOL, taos.SmlPrecision.NOT_CONFIGURED)
+        print("inserted")
+
+        tdSql.query("select table_name from information_schema.ins_tables where type = 'CHILD_TABLE' order by table_name")
+        tdSql.checkRows(6)
+        tdSql.checkData(0, 0, "3i64-4f64-\"t3\"")
+        tdSql.checkData(1, 0, "3i64-4f64-ttt")
+        tdSql.checkData(2, 0, "3i64-4f_64")
+        tdSql.checkData(3, 0, "a-ooo3i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i643i64uuuuuuuuuuuuuuuuuuuuuuuuuu4")
+        tdSql.checkData(4, 0, "t_418c134a0f00c7f536886e132d5fbfff")
+        tdSql.checkData(5, 0, "t_cb0dbf4ee9c9052815c17fc6483b0139")
+        # tdSql.query(f"select * from td24559.stb order by _ts")
+        # tdSql.checkRows(4)
+        # tdSql.checkData(0, 2, "POINT (4.343000 89.342000)")
+        # tdSql.checkData(3, 2, "GEOMETRYCOLLECTION (MULTIPOINT ((0.000000 0.000000), (1.000000 1.000000)), POINT (3.000000 4.000000), LINESTRING (2.000000 3.000000, 3.000000 4.000000))")
+        return
+
+    def run(self):
+        tdSql.prepare()
+        self.check()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
--- a/tests/system-test/2-query/sml.py
+++ b/tests/system-test/2-query/sml.py
@ -9,7 +9,7 @@ from util.dnodes import *
 from util.common import *

 class TDTestCase:
-    updatecfgDict = {'clientCfg': {'smlChildTableName': 'dataModelName', 'fqdn': 'localhost', 'smlDot2Underline': 0}, 'fqdn': 'localhost'}
+    updatecfgDict = {'clientCfg': {'smlChildTableName': 'dataModelName', 'smlAutoChildTableNameDelimiter': '', 'fqdn': 'localhost', 'smlDot2Underline': 0}, 'fqdn': 'localhost'}
    print("===================: ", updatecfgDict)

    def init(self, conn, logSql, replicaVar=1):
--- a/tests/system-test/7-tmq/replay.py
+++ b/tests/system-test/7-tmq/replay.py
@ -0,0 +1,311 @@
+
+import taos
+import sys
+import time
+import socket
+import os
+import threading
+from enum import Enum
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+
+class actionType(Enum):
+    CREATE_DATABASE = 0
+    CREATE_STABLE   = 1
+    CREATE_CTABLE   = 2
+    INSERT_DATA     = 3
+
+class TDTestCase:
+    hostname = socket.gethostname()
+    #rpcDebugFlagVal = '143'
+    #clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
+    #clientCfgDict["rpcDebugFlag"]  = rpcDebugFlagVal
+    #updatecfgDict = {'clientCfg': {}, 'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
+    #updatecfgDict["rpcDebugFlag"] = rpcDebugFlagVal
+    #print ("===================: ", updatecfgDict)
+
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+        #tdSql.init(conn.cursor(), logSql)  # output sql.txt file
+
+    def getBuildPath(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files or "taosd.exe" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root) - len("/build/bin")]
+                    break
+        return buildPath
+
+    def newcur(self,cfg,host,port):
+        user = "root"
+        password = "taosdata"
+        con=taos.connect(host=host, user=user, password=password, config=cfg ,port=port)
+        cur=con.cursor()
+        print(cur)
+        return cur
+
+    def initConsumerTable(self,cdbName='cdb'):
+        tdLog.info("create consume database, and consume info table, and consume result table")
+        tdSql.query("create database if not exists %s vgroups 1 wal_retention_period 3600"%(cdbName))
+        tdSql.query("drop table if exists %s.consumeinfo "%(cdbName))
+        tdSql.query("drop table if exists %s.consumeresult "%(cdbName))
+
+        tdSql.query("create table %s.consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int, ifmanualcommit int)"%cdbName)
+        tdSql.query("create table %s.consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)"%cdbName)
+
+    def initConsumerInfoTable(self,cdbName='cdb'):
+        tdLog.info("drop consumeinfo table")
+        tdSql.query("drop table if exists %s.consumeinfo "%(cdbName))
+        tdSql.query("create table %s.consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int, ifmanualcommit int)"%cdbName)
+
+    def insertConsumerInfo(self,consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifmanualcommit,cdbName='cdb'):
+        sql = "insert into %s.consumeinfo values "%cdbName
+        sql += "(now, %d, '%s', '%s', %d, %d, %d)"%(consumerId, topicList, keyList, expectrowcnt, ifcheckdata, ifmanualcommit)
+        tdLog.info("consume info sql: %s"%sql)
+        tdSql.query(sql)
+
+    def selectConsumeResult(self,expectRows,cdbName='cdb'):
+        resultList=[]
+        while 1:
+            tdSql.query("select * from %s.consumeresult"%cdbName)
+            #tdLog.info("row: %d, %l64d, %l64d"%(tdSql.getData(0, 1),tdSql.getData(0, 2),tdSql.getData(0, 3))
+            if tdSql.getRows() == expectRows:
+                break
+            else:
+                time.sleep(5)
+
+        for i in range(expectRows):
+            tdLog.info ("consume id: %d, consume msgs: %d, consume rows: %d"%(tdSql.getData(i , 1), tdSql.getData(i , 2), tdSql.getData(i , 3)))
+            resultList.append(tdSql.getData(i , 3))
+
+        return resultList
+
+    def startTmqSimProcess(self,buildPath,cfgPath,pollDelay,dbName,showMsg=1,showRow=1,cdbName='cdb',valgrind=0):
+        if valgrind == 1:
+            logFile = cfgPath + '/../log/valgrind-tmq.log'
+            shellCmd = 'nohup valgrind --log-file=' + logFile
+            shellCmd += '--tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all --num-callers=20 -v --workaround-gcc296-bugs=yes '
+
+        if (platform.system().lower() == 'windows'):
+            shellCmd = 'mintty -h never -w hide ' + buildPath + '\\build\\bin\\tmq_sim.exe -c ' + cfgPath
+            shellCmd += " -y %d -d %s -g %d -r %d -w %s "%(pollDelay, dbName, showMsg, showRow, cdbName)
+            shellCmd += "> nul 2>&1 &"
+        else:
+            shellCmd = 'nohup ' + buildPath + '/build/bin/tmq_sim -c ' + cfgPath
+            shellCmd += " -y %d -d %s -g %d -r %d -w %s "%(pollDelay, dbName, showMsg, showRow, cdbName)
+            shellCmd += "> /dev/null 2>&1 &"
+        tdLog.info(shellCmd)
+        os.system(shellCmd)
+
+    def create_database(self,tsql, dbName,dropFlag=1,vgroups=1,replica=1):
+        if dropFlag == 1:
+            tsql.execute("drop database if exists %s"%(dbName))
+
+        tsql.execute("create database if not exists %s vgroups %d replica %d wal_retention_period 3600"%(dbName, vgroups, replica))
+        tdLog.debug("complete to create database %s"%(dbName))
+        return
+
+    def create_stable(self,tsql, dbName,stbName):
+        tsql.execute("create table if not exists %s.%s (ts timestamp, c1 bigint, c2 binary(16)) tags(t1 int)"%(dbName, stbName))
+        tdLog.debug("complete to create %s.%s" %(dbName, stbName))
+        return
+
+    def create_ctables(self,tsql, dbName,stbName,ctbNum):
+        tsql.execute("use %s" %dbName)
+        pre_create = "create table"
+        sql = pre_create
+        #tdLog.debug("doing create one  stable %s and %d  child table in %s  ..." %(stbname, count ,dbname))
+        for i in range(ctbNum):
+            sql += " %s_%d using %s tags(%d)"%(stbName,i,stbName,i+1)
+            if (i > 0) and (i%100 == 0):
+                tsql.execute(sql)
+                sql = pre_create
+        if sql != pre_create:
+            tsql.execute(sql)
+
+        tdLog.debug("complete to create %d child tables in %s.%s" %(ctbNum, dbName, stbName))
+        return
+
+    def insert_data(self,tsql,dbName,stbName,ctbNum,rowsPerTbl,batchNum,startTs=0):
+        tdLog.debug("start to insert data ............")
+        tsql.execute("use %s" %dbName)
+        pre_insert = "insert into "
+        sql = pre_insert
+
+        if startTs == 0:
+            t = time.time()
+            startTs = int(round(t * 1000))
+
+        for j in range(rowsPerTbl):
+            for i in range(ctbNum):
+                sql += " %s_%d values (%d, %d, 'tmqrow_%d') "%(stbName, i, startTs + j + i, j+i, j+i)
+            tsql.execute(sql)
+            time.sleep(1)
+            sql = "insert into "
+        #end sql
+        if sql != pre_insert:
+            #print("insert sql:%s"%sql)
+            tsql.execute(sql)
+        tdLog.debug("insert data ............ [OK]")
+        return
+
+    def prepareEnv(self, **parameterDict):
+        # create new connector for my thread
+        tsql=self.newcur(parameterDict['cfg'], 'localhost', 6030)
+
+        if parameterDict["actionType"] == actionType.CREATE_DATABASE:
+            self.create_database(tsql, parameterDict["dbName"])
+        elif parameterDict["actionType"] == actionType.CREATE_STABLE:
+            self.create_stable(tsql, parameterDict["dbName"], parameterDict["stbName"])
+        elif parameterDict["actionType"] == actionType.CREATE_CTABLE:
+            self.create_ctables(tsql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        elif parameterDict["actionType"] == actionType.INSERT_DATA:
+            self.insert_data(tsql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"], \
+                             parameterDict["rowsPerTbl"],parameterDict["batchNum"])
+        else:
+            tdLog.exit("not support's action: ", parameterDict["actionType"])
+
+        return
+
+    def tmqCase8(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 8: ")
+
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db8',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    1,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     2,       \
+                         'rowsPerTbl': 10,    \
+                         'batchNum':   1,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"] * 2
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest,\
+                        enable.replay:true'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume 0 processor")
+        pollDelay = 100
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume 0 result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        # tdLog.info("start consume 1 processor")
+        # self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+        # tdLog.sleep(2)
+        #
+        # tdLog.info("start one new thread to insert data")
+        # parameterDict['actionType'] = actionType.INSERT_DATA
+        # prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        # prepareEnvThread.start()
+        # prepareEnvThread.join()
+        #
+        # tdLog.info("start to check consume 0 and 1 result")
+        # expectRows = 2
+        # resultList = self.selectConsumeResult(expectRows)
+        # totalConsumeRows = 0
+        # for i in range(expectRows):
+        #     totalConsumeRows += resultList[i]
+        #
+        # if totalConsumeRows != expectrowcnt:
+        #     tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+        #     tdLog.exit("tmq consume rows error!")
+        #
+        # tdLog.info("start consume 2 processor")
+        # self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+        # tdLog.sleep(2)
+        #
+        # tdLog.info("start one new thread to insert data")
+        # parameterDict['actionType'] = actionType.INSERT_DATA
+        # prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        # prepareEnvThread.start()
+        # prepareEnvThread.join()
+        #
+        # tdLog.info("start to check consume 0 and 1 and 2 result")
+        # expectRows = 3
+        # resultList = self.selectConsumeResult(expectRows)
+        # totalConsumeRows = 0
+        # for i in range(expectRows):
+        #     totalConsumeRows += resultList[i]
+        #
+        # if totalConsumeRows != expectrowcnt*2:
+        #     tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt*2))
+        #     tdLog.exit("tmq consume rows error!")
+        #
+        # tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 8 end ...... ")
+
+    def run(self):
+        tdSql.prepare()
+
+        buildPath = self.getBuildPath()
+        if (buildPath == ""):
+            tdLog.exit("taosd not found!")
+        else:
+            tdLog.info("taosd found in %s" % buildPath)
+        cfgPath = buildPath + "/../sim/psim/cfg"
+        tdLog.info("cfgPath: %s" % cfgPath)
+
+        self.tmqCase8(cfgPath, buildPath)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+event = threading.Event()
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
--- a/tests/system-test/7-tmq/tmq_replay.py
+++ b/tests/system-test/7-tmq/tmq_replay.py
@ -0,0 +1,39 @@
+
+import taos
+import sys
+import time
+import socket
+import os
+import threading
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+from util.common import *
+sys.path.append("./7-tmq")
+from tmqCommon import *
+
+class TDTestCase:
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+
+    def run(self):
+        tdSql.prepare()
+        buildPath = tdCom.getBuildPath()
+
+        cmdStr1 = '%s/build/bin/replay_test'%(buildPath)
+        tdLog.info(cmdStr1)
+        result = os.system(cmdStr1)
+
+        if result != 0:
+            tdLog.exit("tmq_replay error!")
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
--- a/utils/test/c/CMakeLists.txt
+++ b/utils/test/c/CMakeLists.txt
@ -9,6 +9,7 @@ add_executable(get_db_name_test get_db_name_test.c)
 add_executable(tmq_offset tmqOffset.c)
 add_executable(tmq_offset_test tmq_offset_test.c)
 add_executable(varbinary_test varbinary_test.c)
+add_executable(replay_test replay_test.c)

 if(${TD_LINUX})
 add_executable(tsz_test tsz_test.c)
@ -57,6 +58,14 @@ target_link_libraries(
    PUBLIC os
 )

+target_link_libraries(
+        replay_test
+        PUBLIC taos
+        PUBLIC util
+        PUBLIC common
+        PUBLIC os
+)
+
 target_link_libraries(
    write_raw_block_test
    PUBLIC taos
--- a/utils/test/c/replay_test.c
+++ b/utils/test/c/replay_test.c
@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <time.h>
+#include "taos.h"
+#include "types.h"
+
+tmq_t* build_consumer() {
+  tmq_conf_t* conf = tmq_conf_new();
+  tmq_conf_set(conf, "group.id", "g1");
+  tmq_conf_set(conf, "client.id", "c1");
+  tmq_conf_set(conf, "td.connect.user", "root");
+  tmq_conf_set(conf, "td.connect.pass", "taosdata");
+  tmq_conf_set(conf, "msg.with.table.name", "true");
+  tmq_conf_set(conf, "enable.auto.commit", "true");
+  tmq_conf_set(conf, "enable.replay", "true");
+  tmq_conf_set(conf, "auto.offset.reset", "earliest");
+
+  tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
+  assert(tmq);
+  tmq_conf_destroy(conf);
+  return tmq;
+}
+
+void test_vgroup_error(TAOS* pConn){
+  TAOS_RES* pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists d1 vgroups 2 wal_retention_period 3600");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "CREATE STABLE d1.s1 (ts TIMESTAMP, c1 INT) TAGS (t1 INT)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create topic t1 as select * from d1.s1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  tmq_list_t* topic_list = tmq_list_new();
+
+  tmq_list_append(topic_list, "t1");
+  tmq_t*      tmq = build_consumer();
+  ASSERT(tmq_subscribe(tmq, topic_list) != 0);
+  tmq_list_destroy(topic_list);
+  tmq_consumer_close(tmq);
+}
+
+void test_stable_db_error(TAOS* pConn){
+  TAOS_RES* pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists d1 vgroups 1 wal_retention_period 3600");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "CREATE STABLE d1.s1 (ts TIMESTAMP, c1 INT) TAGS (t1 INT)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create topic t1 as stable d1.s1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  tmq_list_t* topic_list = tmq_list_new();
+
+  tmq_list_append(topic_list, "t1");
+  tmq_t*      tmq = build_consumer();
+  ASSERT(tmq_subscribe(tmq, topic_list) != 0);
+  tmq_list_destroy(topic_list);
+  tmq_consumer_close(tmq);
+
+  pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create topic t1 as database d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  topic_list = tmq_list_new();
+  tmq_list_append(topic_list, "t1");
+  tmq = build_consumer();
+  ASSERT(tmq_subscribe(tmq, topic_list) != 0);
+  tmq_list_destroy(topic_list);
+  tmq_consumer_close(tmq);
+}
+
+void insert_with_sleep(TAOS* pConn, int32_t* interval, int32_t len){
+  for(int i = 0; i < len; i++){
+    TAOS_RES* pRes = taos_query(pConn, "insert into d1.table1 (ts, c1) values (now, 1)");
+    ASSERT(taos_errno(pRes) == 0);
+    taos_free_result(pRes);
+
+    taosMsleep(interval[i]);
+  }
+}
+
+void insert_with_sleep_multi(TAOS* pConn, int32_t* interval, int32_t len){
+  for(int i = 0; i < len; i++){
+    TAOS_RES* pRes = taos_query(pConn, "insert into d1.table1 (ts, c1) values (now, 1) (now+1s, 2) d1.table2 (ts, c1) values (now, 1) (now+1s, 2)");
+    ASSERT(taos_errno(pRes) == 0);
+    taos_free_result(pRes);
+
+    taosMsleep(interval[i]);
+  }
+}
+
+void test_case1(TAOS* pConn, int32_t* interval, int32_t len){
+  TAOS_RES* pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists d1 vgroups 2 wal_retention_period 3600");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "CREATE STABLE d1.s1 (ts TIMESTAMP, c1 INT) TAGS (t1 INT)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table d1.table1 using d1.s1 tags(1)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  insert_with_sleep(pConn, interval, len);
+
+  pRes = taos_query(pConn, "create topic t1 as select * from d1.table1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  tmq_list_t* topic_list = tmq_list_new();
+
+  tmq_list_append(topic_list, "t1");
+  tmq_t*      tmq = build_consumer();
+  // 启动订阅
+  tmq_subscribe(tmq, topic_list);
+  tmq_list_destroy(topic_list);
+
+  int32_t     timeout = 5000;
+
+  int64_t t = 0;
+  int32_t totalRows = 0;
+  char    buf[1024] = {0};
+  while (1) {
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, timeout);
+    if (tmqmessage) {
+      if(t != 0){
+        ASSERT(taosGetTimestampMs() - t >= interval[totalRows - 1]);
+      }
+      t = taosGetTimestampMs();
+
+      TAOS_ROW row = taos_fetch_row(tmqmessage);
+      if (row == NULL) {
+        break;
+      }
+
+      TAOS_FIELD* fields = taos_fetch_fields(tmqmessage);
+      int32_t     numOfFields = taos_field_count(tmqmessage);
+      taos_print_row(buf, row, fields, numOfFields);
+
+      printf("time:%" PRId64 " rows[%d]: %s\n", t, totalRows, buf);
+      totalRows++;
+      taos_free_result(tmqmessage);
+    } else {
+      break;
+    }
+  }
+
+  ASSERT(totalRows == len);
+  tmq_consumer_close(tmq);
+}
+
+void test_case2(TAOS* pConn, int32_t* interval, int32_t len, tsem_t* sem){
+  TAOS_RES* pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists d1 vgroups 1 wal_retention_period 3600");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "CREATE STABLE d1.s1 (ts TIMESTAMP, c1 INT) TAGS (t1 INT)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table d1.table1 using d1.s1 tags(1)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table d1.table2 using d1.s1 tags(2)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  insert_with_sleep_multi(pConn, interval, len);
+
+  pRes = taos_query(pConn, "create topic t1 as select * from d1.s1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  tmq_list_t* topic_list = tmq_list_new();
+
+  tmq_list_append(topic_list, "t1");
+  tmq_t*      tmq = build_consumer();
+  // 启动订阅
+  tmq_subscribe(tmq, topic_list);
+  tmq_list_destroy(topic_list);
+
+  int32_t     timeout = 5000;
+
+  int64_t t = 0;
+  int32_t totalRows = 0;
+  char    buf[1024] = {0};
+  while (1) {
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, timeout);
+    if (tmqmessage) {
+      if(t != 0 && totalRows % 4 == 0){
+        ASSERT(taosGetTimestampMs() - t >= interval[totalRows/4 - 1]);
+      }
+      t = taosGetTimestampMs();
+
+      while(1){
+        TAOS_ROW row = taos_fetch_row(tmqmessage);
+        if (row == NULL) {
+          break;
+        }
+
+        TAOS_FIELD* fields = taos_fetch_fields(tmqmessage);
+        int32_t     numOfFields = taos_field_count(tmqmessage);
+        taos_print_row(buf, row, fields, numOfFields);
+
+        printf("time:%" PRId64 " rows[%d]: %s\n", t, totalRows, buf);
+        totalRows++;
+      }
+
+      taos_free_result(tmqmessage);
+
+      if(totalRows == len * 4){
+        taosSsleep(1);
+        tsem_post(sem);
+      }
+    } else {
+      break;
+    }
+  }
+
+  ASSERT(totalRows == len * 4 + 1);
+  tmq_consumer_close(tmq);
+}
+
+void test_case3(TAOS* pConn, int32_t* interval, int32_t len){
+  TAOS_RES* pRes = taos_query(pConn, "drop topic if exists t1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists d1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists d1 vgroups 1 wal_retention_period 3600");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "CREATE STABLE d1.s1 (ts TIMESTAMP, c1 INT) TAGS (t1 INT)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table d1.table1 using d1.s1 tags(1)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table d1.table2 using d1.s1 tags(2)");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  insert_with_sleep_multi(pConn, interval, len);
+
+  pRes = taos_query(pConn, "create topic t1 as select * from d1.s1");
+  ASSERT(taos_errno(pRes) == 0);
+  taos_free_result(pRes);
+
+  tmq_list_t* topic_list = tmq_list_new();
+
+  tmq_list_append(topic_list, "t1");
+  tmq_t*      tmq = build_consumer();
+  // 启动订阅
+  tmq_subscribe(tmq, topic_list);
+
+  int32_t     timeout = 5000;
+
+  TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, timeout);
+  taos_free_result(tmqmessage);
+
+  tmq_consumer_close(tmq);
+
+  tmq = build_consumer();
+  // 启动订阅
+  tmq_subscribe(tmq, topic_list);
+
+  int64_t t = 0;
+  int32_t totalRows = 0;
+  char    buf[1024] = {0};
+  while (1) {
+    tmqmessage = tmq_consumer_poll(tmq, timeout);
+    if (tmqmessage) {
+      if(t != 0 && totalRows % 4 == 0){
+        ASSERT(taosGetTimestampMs() - t >= interval[totalRows/4 - 1]);
+      }
+      t = taosGetTimestampMs();
+
+      while(1){
+        TAOS_ROW row = taos_fetch_row(tmqmessage);
+        if (row == NULL) {
+          break;
+        }
+
+        TAOS_FIELD* fields = taos_fetch_fields(tmqmessage);
+        int32_t     numOfFields = taos_field_count(tmqmessage);
+        taos_print_row(buf, row, fields, numOfFields);
+
+        printf("time:%" PRId64 " rows[%d]: %s\n", t, totalRows, buf);
+        totalRows++;
+      }
+
+      taos_free_result(tmqmessage);
+    } else {
+      break;
+    }
+  }
+
+  ASSERT(totalRows == len * 4);
+
+  tmq_consumer_close(tmq);
+  tmq_list_destroy(topic_list);
+}
+
+void* insertThreadFunc(void* param) {
+  tsem_t* sem = (tsem_t*)param;
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+
+  tsem_wait(sem);
+
+  TAOS_RES* pRes = taos_query(pConn, "insert into d1.table1 (ts, c1) values (now, 11)");
+  ASSERT(taos_errno(pRes) == 0);
+  printf("insert data again\n");
+  taos_free_result(pRes);
+  taos_close(pConn);
+  return NULL;
+}
+
+int main(int argc, char* argv[]) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  test_vgroup_error(pConn);
+  test_stable_db_error(pConn);
+
+  tsem_t sem;
+  tsem_init(&sem, 0, 0);
+  TdThread thread;
+  TdThreadAttr thattr;
+  taosThreadAttrInit(&thattr);
+  taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
+
+  // pthread_create one thread to consume
+  taosThreadCreate(&thread, &thattr, insertThreadFunc, (void*)(&sem));
+
+  int32_t interval[5] = {1000, 200, 3000, 40, 500};
+  test_case1(pConn, interval, sizeof(interval)/sizeof(int32_t));
+  printf("test_case1 success\n");
+  test_case2(pConn, interval, sizeof(interval)/sizeof(int32_t), &sem);
+  printf("test_case2 success\n");
+  test_case3(pConn, interval, sizeof(interval)/sizeof(int32_t));
+  taos_close(pConn);
+
+  taosThreadJoin(thread, NULL);
+  taosThreadClear(&thread);
+  tsem_destroy(&sem);
+  return 0;
+}
--- a/utils/test/c/sml_test.c
+++ b/utils/test/c/sml_test.c
@ -1678,8 +1678,8 @@ int main(int argc, char *argv[]) {
  ASSERT(!ret);
  ret = sml_td18789_Test();
  ASSERT(!ret);
-  ret = sml_td24070_Test();
-  ASSERT(!ret);
+//  ret = sml_td24070_Test();
+//  ASSERT(!ret);
  ret = sml_td23881_Test();
  ASSERT(ret);
  ret = sml_escape_Test();
--- a/utils/test/c/tmqOffset.c
+++ b/utils/test/c/tmqOffset.c
@ -7,18 +7,14 @@
 #include "tlog.h"
 #include "tmsg.h"

-typedef struct {
-  int32_t size;
-} STqOffsetHead;
-
 int32_t tqOffsetRestoreFromFile(const char* fname) {
  TdFilePtr pFile = taosOpenFile(fname, TD_FILE_READ);
  if (pFile != NULL) {
-    STqOffsetHead head = {0};
    int32_t       code;

    while (1) {
-      if ((code = taosReadFile(pFile, &head, sizeof(STqOffsetHead))) != sizeof(STqOffsetHead)) {
+      int32_t size = 0;
+      if ((code = taosReadFile(pFile, &size, INT_BYTES)) != INT_BYTES) {
        if (code == 0) {
          break;
        } else {
@ -26,7 +22,6 @@ int32_t tqOffsetRestoreFromFile(const char* fname) {
          return -1;
        }
      }
-      int32_t size = htonl(head.size);
      void*   memBuf = taosMemoryCalloc(1, size);
      if (memBuf == NULL) {
        printf("memBuf == NULL\n");
--- a/utils/test/c/tmqSim.c
+++ b/utils/test/c/tmqSim.c
@ -621,10 +621,11 @@ static int32_t data_msg_process(TAOS_RES* msg, SThreadInfo* pInfo, int32_t msgIn
    taos_print_row(buf, row, fields, numOfFields);

    if (0 != g_stConfInfo.showRowFlag) {
-      taosFprintfFile(g_fp, "tbname:%s, rows[%d]: %s\n", (tbName != NULL ? tbName : "null table"), totalRows, buf);
+      taosFprintfFile(g_fp, "time:%" PRId64 " tbname:%s, rows[%d]: %s\n", taosGetTimestampMs(), (tbName != NULL ? tbName : "null table"), totalRows, buf);
      // if (0 != g_stConfInfo.saveRowFlag) {
      //   saveConsumeContentToTbl(pInfo, buf);
      // }
+//      taosFsyncFile(g_fp);
    }

    totalRows++;