diff --git a/docs/en/25-application/03-immigrate.md b/docs/en/25-application/03-immigrate.md
index 4d47aec1d76014ba63f6be91004abcc3934769f7..fe67f973894d460fb017de0e1a2099b8441a4abe 100644
--- a/docs/en/25-application/03-immigrate.md
+++ b/docs/en/25-application/03-immigrate.md
@@ -379,11 +379,11 @@ We still use the hypothetical environment from Chapter 4. There are three measur
 
 ### Storage resource estimation
 
-Assuming that the number of sensor devices that generate data and need to be stored is `n`, the frequency of data generation is `t` per second, and the length of each record is `L` bytes, the scale of data generated per day is `n * t * L` bytes. Assuming the compression ratio is `C`, the daily data size is `(n * t * L)/C` bytes. The storage resources are estimated to accommodate the data scale for 1.5 years. In the production environment, the compression ratio C of TDengine is generally between 5 and 7.
+Assuming that the number of sensor devices that generate data and need to be stored is `n`, the frequency of data generation is `t` per second, and the length of each record is `L` bytes, the scale of data generated per day is `86400 * n * t * L` bytes. Assuming the compression ratio is `C`, the daily data size is `(86400 * n * t * L)/C` bytes. The storage resources are estimated to accommodate the data scale for 1.5 years. In the production environment, the compression ratio C of TDengine is generally between 5 and 7.
 With additional 20% redundancy, you can calculate the required storage resources:
 
 ```matlab
-(n * t * L) * (365 * 1.5) * (1+20%)/C
+(86400 * n * t * L) * (365 * 1.5) * (1+20%)/C
 ````
 Substituting in the above formula, the raw data generated every year is 11.8TB without considering the label information. Note that tag information is associated with each timeline in TDengine, not every record. The amount of data to be recorded is somewhat reduced relative to the generated data, and label data can be ignored as a whole. Assuming a compression ratio of 5, the size of the retained data ends up being 2.56 TB.
 
diff --git a/docs/zh/25-application/03-immigrate.md b/docs/zh/25-application/03-immigrate.md
index 9d8946bc4a69639c5327ac1ffb6c0539ddbd0e63..d1c9caea099b79494784aa1122e89d7b4d412464 100644
--- a/docs/zh/25-application/03-immigrate.md
+++ b/docs/zh/25-application/03-immigrate.md
@@ -367,10 +367,10 @@ WHERE ts>=1510560000 AND ts<=1515000009
 
 ### 存储资源估算
 
-假设产生数据并需要存储的传感器设备数量为 `n`，数据生成的频率为`t`条/秒，每条记录的长度为 `L` bytes，则每天产生的数据规模为 `n×t×L` bytes。假设压缩比为 C，则每日产生数据规模为 `(n×t×L)/C` bytes。存储资源预估为能够容纳 1.5 年的数据规模，生产环境下 TDengine 的压缩比 C 一般在 5 ~ 7 之间，同时为最后结果增加 20% 的冗余，可计算得到需要存储资源：
+假设产生数据并需要存储的传感器设备数量为 `n`，数据生成的频率为`t`条/秒，每条记录的长度为 `L` bytes，则每天产生的数据规模为 `86400×n×t×L` bytes。假设压缩比为 C，则每日产生数据规模为 `(86400×n×t×L)/C` bytes。存储资源预估为能够容纳 1.5 年的数据规模，生产环境下 TDengine 的压缩比 C 一般在 5 ~ 7 之间，同时为最后结果增加 20% 的冗余，可计算得到需要存储资源：
 
 ```matlab
-(n×t×L)×(365×1.5)×(1+20%)/C
+(86400×n×t×L)×(365×1.5)×(1+20%)/C
 ```
 
 结合以上的计算公式，将参数带入计算公式，在不考虑标签信息的情况下，每年产生的原始数据规模是 11.8TB。需要注意的是，由于标签信息在 TDengine 中关联到每个时间线，并不是每条记录。所以需要记录的数据量规模相对于产生的数据有一定的降低，而这部分标签数据整体上可以忽略不记。假设压缩比为 5，则保留的数据规模最终为 2.56 TB。
diff --git a/include/common/tcommon.h b/include/common/tcommon.h
index fd4ed6b1800439550c7f3bf618ac99252f26e01e..779453f714b6ce835b61909f59aad3a510628a00 100644
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -88,8 +88,6 @@ typedef struct {
 #pragma pack(push, 1)
 typedef struct SColumnDataAgg {
   int16_t colId;
-  int16_t minIndex;
-  int16_t maxIndex;
   int16_t numOfNull;
   int64_t sum;
   int64_t max;
@@ -117,6 +115,20 @@ typedef struct SSDataBlock {
   SDataBlockInfo   info;
 } SSDataBlock;
 
+enum {
+  FETCH_TYPE__DATA = 1,
+  FETCH_TYPE__META,
+  FETCH_TYPE__NONE,
+};
+
+typedef struct {
+  int8_t fetchType;
+  union {
+    SSDataBlock data;
+    void*       meta;
+  };
+} SFetchRet;
+
 typedef struct SVarColAttr {
   int32_t* offset;    // start position for each entry in the list
   uint32_t length;    // used buffer size that contain the valid data
diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 7b4565a99fa2557eacb4983616b0db0c5fea9ff3..0094afef123fa140bcb6184868b33de97d0fd16d 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -30,7 +30,7 @@ struct SRpcMsg;
 struct SSubplan;
 
 typedef struct SReadHandle {
-  void*   streamReader;
+  void*   tqReader;
   void*   meta;
   void*   config;
   void*   vnode;
@@ -38,7 +38,7 @@ typedef struct SReadHandle {
   SMsgCb* pMsgCb;
   bool    initMetaReader;
   bool    initTableReader;
-  bool    initStreamReader;
+  bool    initTqReader;
 } SReadHandle;
 
 typedef enum {
@@ -52,7 +52,7 @@ typedef enum {
  * @param streamReadHandle
  * @return
  */
-qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle);
+qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
 
 /**
  * Switch the stream scan to snapshot mode
@@ -176,6 +176,9 @@ int32_t qGetStreamScanStatus(qTaskInfo_t tinfo, uint64_t* uid, int64_t* ts);
 
 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts);
 
+void*   qExtractReaderFromStreamScanner(void* scanner);
+int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index 52f671e176c94536d2ae10dd61c74b7b07bcfdb1..d6cb2c27b02b132b4ab87fdefb545dc6d6cc2fd3 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -235,11 +235,6 @@ typedef struct SStreamTask {
   int8_t taskStatus;
   int8_t execStatus;
 
-  // exec info
-  int64_t enqueueVer;
-  int64_t processedVer;
-  int64_t checkpointVer;
-
   // node info
   int32_t selfChildId;
   int32_t nodeId;
diff --git a/include/libs/sync/sync.h b/include/libs/sync/sync.h
index 8a6d6b7722807a004a3e46ec4ed24aa9b6875cbf..bef26cb3102173b6353afd83fa4ae05b3de97803 100644
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@@ -163,9 +163,6 @@ typedef struct SSyncLogStore {
   // return commit index of log
   SyncIndex (*getCommitIndex)(struct SSyncLogStore* pLogStore);
 
-  // refactor, log[0 .. n] ==> log[m .. n]
-  // int32_t (*syncLogSetBeginIndex)(struct SSyncLogStore* pLogStore, SyncIndex beginIndex);
-
   SyncIndex (*syncLogBeginIndex)(struct SSyncLogStore* pLogStore);
   SyncIndex (*syncLogEndIndex)(struct SSyncLogStore* pLogStore);
   bool (*syncLogIsEmpty)(struct SSyncLogStore* pLogStore);
diff --git a/source/client/src/TMQConnector.c b/source/client/src/TMQConnector.c
index c3d1e60782b26995341ab822beeaee320d28036c..1d84dcf7a2be09516b15a095a6013af53f68c60c 100644
--- a/source/client/src/TMQConnector.c
+++ b/source/client/src/TMQConnector.c
@@ -324,9 +324,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfRowsFp, (jint)numOfRows);
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfColsFp, (jint)numOfFields);
 
-  char   *chars = (char *)data;
-  int32_t len = chars[0] + (chars[1] << 8) + (chars[2] << 16) + (chars[3] << 24);
-  (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, len, jniFromNCharToByteArray(env, (char *)data, len));
-
+  int32_t len = *(int32_t *)data;
+  (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, jniFromNCharToByteArray(env, (char *)data, len));
   return JNI_SUCCESS;
 }
diff --git a/source/client/src/TSDBJNIConnector.c b/source/client/src/TSDBJNIConnector.c
index 246785b5701cf05dc734b3e14d2a4819ef502478..227c2fff1860170f47074f7f3a7a73d1de569510 100644
--- a/source/client/src/TSDBJNIConnector.c
+++ b/source/client/src/TSDBJNIConnector.c
@@ -592,8 +592,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNI
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfRowsFp, (jint)numOfRows);
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfColsFp, (jint)numOfFields);
 
-  char   *chars = (char *)data;
-  int32_t len = chars[0] + (chars[1] << 8) + (chars[2] << 16) + (chars[3] << 24);
+  int32_t len = *(int32_t *)data;
   (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, jniFromNCharToByteArray(env, (char *)data, len));
 
   return JNI_SUCCESS;
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index e8e3237b67af1b857708ee88ba949808452acbea..7927c1e008c66c4fc54156be1d3509574555d01b 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -750,7 +750,6 @@ TEST(testCase, projection_query_stables) {
   taos_close(pConn);
 }
 
-
 TEST(testCase, agg_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
@@ -763,7 +762,7 @@ TEST(testCase, agg_query_tables) {
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "show table distributed st1");
+  pRes = taos_query(pConn, "show table distributed tup");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
@@ -822,13 +821,29 @@ TEST(testCase, async_api_test) {
 }
 #endif
 
+
 TEST(testCase, update_test) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
-  taos_query(pConn, "use abc1");
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
+  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+    printf("failed to create database, code:%s", taos_errstr(pRes));
+    taos_free_result(pRes);
+    return;
+  }
+
+  taos_free_result(pRes);
 
-  TAOS_RES* pRes = taos_query(pConn, "create table tup (ts timestamp, k int);");
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+    printf("failed to use db, code:%s", taos_errstr(pRes));
+    taos_free_result(pRes);
+    return;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tup (ts timestamp, k int);");
   if (taos_errno(pRes) != 0) {
     printf("failed to create table, reason:%s", taos_errstr(pRes));
   }
@@ -836,11 +851,10 @@ TEST(testCase, update_test) {
   taos_free_result(pRes);
 
   char s[256]  = {0};
-  for(int32_t i = 0; i < 7000; ++i) {
-    sprintf(s, "insert into tup values('2020-1-1 1:1:1', %d)", i);
+  for(int32_t i = 0; i < 17000; ++i) {
+    sprintf(s, "insert into tup values(now+%da, %d)", i, i);
     pRes = taos_query(pConn, s);
     taos_free_result(pRes);
   }
 }
-
 #pragma GCC diagnostic pop
diff --git a/source/common/src/tdata.c b/source/common/src/tdata.c
deleted file mode 100644
index 6dea4a4e57392be988126c579648f39a8270b9bf..0000000000000000000000000000000000000000
--- a/source/common/src/tdata.c
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * 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/>.
- */
\ No newline at end of file
diff --git a/source/common/src/tmsgtype.c b/source/common/src/tmsgtype.c
deleted file mode 100644
index 3ca0f00fc20df54226eb026e2c92e19144de47b2..0000000000000000000000000000000000000000
--- a/source/common/src/tmsgtype.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * 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/>.
- */
-
-#define _DEFAULT_SOURCE
-#define TSDB_SQL_C
-#include "tmsgtype.h"
diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
index d60b69daba8170ff2a8c691819532e3361229cac..4e3449feb7bfe54a69ad97134cac42641b49a22c 100644
--- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
@@ -238,10 +238,12 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_PING, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_PING_REPLY, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST_BATCH, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST_REPLY, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_REQUEST_VOTE, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_REQUEST_VOTE_REPLY, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES_BATCH, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES_REPLY, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_SNAPSHOT_SEND, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_SNAPSHOT_RSP, mmPutMsgToSyncQueue, 1) == NULL) goto _OVER;
diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
index a3df32a08c86c583deb4bd51ab31f52c588678aa..993a604b510de8911e1a56046fca116194490c47 100644
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@@ -377,10 +377,12 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_PING, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_PING_REPLY, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST_BATCH, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_CLIENT_REQUEST_REPLY, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_REQUEST_VOTE, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_REQUEST_VOTE_REPLY, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES_BATCH, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_APPEND_ENTRIES_REPLY, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_SYNC_SET_VNODE_STANDBY, vmPutMsgToSyncQueue, 0) == NULL) goto _OVER;
 
diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt
index 24c4f2912c82ce001398340609f11d28d7111f15..897e4f26e2fce4fc9f1f280539e8a427845715e2 100644
--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@@ -9,7 +9,6 @@ target_sources(
     "src/vnd/vnodeCfg.c"
     "src/vnd/vnodeCommit.c"
     "src/vnd/vnodeQuery.c"
-    "src/vnd/vnodeStateMgr.c"
     "src/vnd/vnodeModule.c"
     "src/vnd/vnodeSvr.c"
     "src/vnd/vnodeSync.c"
@@ -32,7 +31,6 @@ target_sources(
     "src/sma/smaUtil.c"
     "src/sma/smaOpen.c"
     "src/sma/smaCommit.c"
-    "src/sma/smaSnapshot.c"
     "src/sma/smaRollup.c"
     "src/sma/smaTimeRange.c"
 
@@ -43,7 +41,6 @@ target_sources(
     "src/tsdb/tsdbOpen.c"
     "src/tsdb/tsdbMemTable.c"
     "src/tsdb/tsdbRead.c"
-    "src/tsdb/tsdbReadImpl.c"
     "src/tsdb/tsdbCache.c"
     "src/tsdb/tsdbWrite.c"
     "src/tsdb/tsdbReaderWriter.c"
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 722087ea45dd472324a07523d86605ae734e5ef1..11a20285c0e4cd5f7ac57d3ce909fd22ea01ba84 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -64,8 +64,8 @@ int32_t vnodeSnapshotRead(SVSnapshotReader *pReader, const void **ppData, uint32
 int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen);
 int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list);
 int32_t vnodeGetCtbIdList(SVnode *pVnode, int64_t suid, SArray *list);
-void *  vnodeGetIdx(SVnode *pVnode);
-void *  vnodeGetIvtIdx(SVnode *pVnode);
+void   *vnodeGetIdx(SVnode *pVnode);
+void   *vnodeGetIvtIdx(SVnode *pVnode);
 
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
 int32_t vnodeValidateTableHash(SVnode *pVnode, char *tableFName);
@@ -95,7 +95,7 @@ typedef struct SMetaFltParam {
   tb_uid_t suid;
   int16_t  cid;
   int16_t  type;
-  char *   val;
+  char    *val;
   bool     reverse;
   int (*filterFunc)(void *a, void *b, int16_t type);
 
@@ -131,13 +131,13 @@ int32_t tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, SArray *pTabl
 void    tsdbReaderClose(STsdbReader *pReader);
 bool    tsdbNextDataBlock(STsdbReader *pReader);
 void    tsdbRetrieveDataBlockInfo(STsdbReader *pReader, SDataBlockInfo *pDataBlockInfo);
-int32_t tsdbRetrieveDataBlockStatisInfo(STsdbReader *pReader, SColumnDataAgg ***pBlockStatis, bool *allHave);
+int32_t tsdbRetrieveDatablockSMA(STsdbReader *pReader, SColumnDataAgg ***pBlockStatis, bool *allHave);
 SArray *tsdbRetrieveDataBlock(STsdbReader *pTsdbReadHandle, SArray *pColumnIdList);
 int32_t tsdbReaderReset(STsdbReader *pReader, SQueryTableDataCond *pCond, int32_t tWinIdx);
 int32_t tsdbGetFileBlocksDistInfo(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo);
 int64_t tsdbGetNumOfRowsInMemTable(STsdbReader *pHandle);
-void *  tsdbGetIdx(SMeta *pMeta);
-void *  tsdbGetIvtIdx(SMeta *pMeta);
+void   *tsdbGetIdx(SMeta *pMeta);
+void   *tsdbGetIvtIdx(SMeta *pMeta);
 
 int32_t tsdbLastRowReaderOpen(void *pVnode, int32_t type, SArray *pTableIdList, int32_t *colId, int32_t numOfCols,
                               void **pReader);
@@ -146,19 +146,37 @@ int32_t tsdbLastrowReaderClose(void *pReader);
 
 // tq
 
-typedef struct STqReadHandle SStreamReader;
+typedef struct STqReader {
+  int64_t           ver;
+  const SSubmitReq *pMsg;
+  SSubmitBlk       *pBlock;
+  SSubmitMsgIter    msgIter;
+  SSubmitBlkIter    blkIter;
 
-SStreamReader *tqInitSubmitMsgScanner(SMeta *pMeta);
+  SWalReader *pWalReader;
 
-void    tqReadHandleSetColIdList(SStreamReader *pReadHandle, SArray *pColIdList);
-int32_t tqReadHandleSetTbUidList(SStreamReader *pHandle, const SArray *tbUidList);
-int32_t tqReadHandleAddTbUidList(SStreamReader *pHandle, const SArray *tbUidList);
-int32_t tqReadHandleRemoveTbUidList(SStreamReader *pHandle, const SArray *tbUidList);
+  SMeta    *pVnodeMeta;
+  SHashObj *tbIdHash;
+  SArray   *pColIdList;  // SArray<int16_t>
 
-int32_t tqReadHandleSetMsg(SStreamReader *pHandle, SSubmitReq *pMsg, int64_t ver);
-bool    tqNextDataBlock(SStreamReader *pHandle);
-bool    tqNextDataBlockFilterOut(SStreamReader *pHandle, SHashObj *filterOutUids);
-int32_t tqRetrieveDataBlock(SSDataBlock *pBlock, SStreamReader *pHandle);
+  int32_t         cachedSchemaVer;
+  int64_t         cachedSchemaSuid;
+  SSchemaWrapper *pSchemaWrapper;
+  STSchema       *pSchema;
+} STqReader;
+
+STqReader *tqOpenReader(SVnode *pVnode);
+void       tqCloseReader(STqReader *);
+
+void    tqReaderSetColIdList(STqReader *pReader, SArray *pColIdList);
+int32_t tqReaderSetTbUidList(STqReader *pReader, const SArray *tbUidList);
+int32_t tqReaderAddTbUidList(STqReader *pReader, const SArray *tbUidList);
+int32_t tqReaderRemoveTbUidList(STqReader *pReader, const SArray *tbUidList);
+
+int32_t tqReaderSetDataMsg(STqReader *pReader, SSubmitReq *pMsg, int64_t ver);
+bool    tqNextDataBlock(STqReader *pReader);
+bool    tqNextDataBlockFilterOut(STqReader *pReader, SHashObj *filterOutUids);
+int32_t tqRetrieveDataBlock(SSDataBlock *pBlock, STqReader *pReader);
 
 // sma
 int32_t smaGetTSmaDays(SVnodeCfg *pCfg, void *pCont, uint32_t contLen, int32_t *days);
@@ -214,7 +232,7 @@ struct SMetaEntry {
   int8_t   type;
   int8_t   flags;  // TODO: need refactor?
   tb_uid_t uid;
-  char *   name;
+  char    *name;
   union {
     struct {
       SSchemaWrapper schemaRow;
@@ -225,7 +243,7 @@ struct SMetaEntry {
       int64_t  ctime;
       int32_t  ttlDays;
       int32_t  commentLen;
-      char *   comment;
+      char    *comment;
       tb_uid_t suid;
       uint8_t *pTags;
     } ctbEntry;
@@ -233,7 +251,7 @@ struct SMetaEntry {
       int64_t        ctime;
       int32_t        ttlDays;
       int32_t        commentLen;
-      char *         comment;
+      char          *comment;
       int32_t        ncid;  // next column id
       SSchemaWrapper schemaRow;
     } ntbEntry;
@@ -247,17 +265,17 @@ struct SMetaEntry {
 
 struct SMetaReader {
   int32_t    flags;
-  SMeta *    pMeta;
+  SMeta     *pMeta;
   SDecoder   coder;
   SMetaEntry me;
-  void *     pBuf;
+  void      *pBuf;
   int32_t    szBuf;
 };
 
 struct SMTbCursor {
-  TBC *       pDbc;
-  void *      pKey;
-  void *      pVal;
+  TBC        *pDbc;
+  void       *pKey;
+  void       *pVal;
   int32_t     kLen;
   int32_t     vLen;
   SMetaReader mr;
diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h
index 12fb500ba3e4f368d38b251d6314350706f62274..9c3bd85c7165003b4989f0f9b797550d0dc271cd 100644
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@@ -44,25 +44,6 @@ extern "C" {
 
 typedef struct STqOffsetStore STqOffsetStore;
 
-// tqRead
-
-struct STqReadHandle {
-  int64_t           ver;
-  const SSubmitReq* pMsg;
-  SSubmitBlk*       pBlock;
-  SSubmitMsgIter    msgIter;
-  SSubmitBlkIter    blkIter;
-
-  SMeta*    pVnodeMeta;
-  SHashObj* tbIdHash;
-  SArray*   pColIdList;  // SArray<int16_t>
-
-  int32_t         cachedSchemaVer;
-  int64_t         cachedSchemaSuid;
-  SSchemaWrapper* pSchemaWrapper;
-  STSchema*       pSchema;
-};
-
 // tqPush
 
 typedef struct {
@@ -102,7 +83,7 @@ typedef struct {
 typedef struct {
   int8_t subType;
 
-  SStreamReader* pExecReader[5];
+  STqReader* pExecReader[5];
   union {
     STqExecCol execCol;
     STqExecTb  execTb;
@@ -118,7 +99,7 @@ typedef struct {
   int32_t epoch;
   int8_t  fetchMeta;
 
-  // reader
+  // TODO remove
   SWalReader* pWalReader;
 
   // push
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index 0f65a536e0538912637625bb8d9ee7de35a443f2..cd2dfd335106a0fd05466b87ee5eef8b4f3c9ba7 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -245,6 +245,8 @@ int32_t tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h);
 
 int32_t tsdbCacheDelete(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);
 
+int32_t tsdbCacheLastArray2Row(SArray *pLastArray, STSRow **ppRow, STSchema *pSchema);
+
 // structs =======================
 typedef struct {
   int   minFid;
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 74076d323c081c5f9d8a387cff88c467e4b32fe8..341173103c2aa2ce522a31ce7c80e27d62d60005 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -16,6 +16,7 @@
 #include "meta.h"
 
 static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
+static int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
 static int metaHandleEntry(SMeta *pMeta, const SMetaEntry *pME);
 static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME);
 static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME);
@@ -92,7 +93,65 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
     } else if (type == TSDB_DATA_TYPE_BOOL) {
       int val = *(int *)(&pTagVal->i64);
       int len = sizeof(val);
-      term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_INT, key, nKey, (const char *)&val, len);
+      term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len);
+    }
+    if (term != NULL) {
+      indexMultiTermAdd(terms, term);
+    }
+  }
+  indexJsonPut(pMeta->pTagIvtIdx, terms, tuid);
+  indexMultiTermDestroy(terms);
+#endif
+  return 0;
+}
+int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) {
+#ifdef USE_INVERTED_INDEX
+  if (pMeta->pTagIvtIdx == NULL || pCtbEntry == NULL) {
+    return -1;
+  }
+  void *      data = pCtbEntry->ctbEntry.pTags;
+  const char *tagName = pSchema->name;
+
+  tb_uid_t    suid = pCtbEntry->ctbEntry.suid;
+  tb_uid_t    tuid = pCtbEntry->uid;
+  const void *pTagData = pCtbEntry->ctbEntry.pTags;
+  int32_t     nTagData = 0;
+
+  SArray *pTagVals = NULL;
+  if (tTagToValArray((const STag *)data, &pTagVals) != 0) {
+    return -1;
+  }
+
+  SIndexMultiTerm *terms = indexMultiTermCreate();
+  int16_t          nCols = taosArrayGetSize(pTagVals);
+  for (int i = 0; i < nCols; i++) {
+    STagVal *pTagVal = (STagVal *)taosArrayGet(pTagVals, i);
+    char     type = pTagVal->type;
+
+    char *  key = pTagVal->pKey;
+    int32_t nKey = strlen(key);
+
+    SIndexTerm *term = NULL;
+    if (type == TSDB_DATA_TYPE_NULL) {
+      term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, NULL, 0);
+    } else if (type == TSDB_DATA_TYPE_NCHAR) {
+      if (pTagVal->nData > 0) {
+        char *  val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+        int32_t len = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, val + VARSTR_HEADER_SIZE);
+        memcpy(val, (uint16_t *)&len, VARSTR_HEADER_SIZE);
+        type = TSDB_DATA_TYPE_VARCHAR;
+        term = indexTermCreate(suid, DEL_VALUE, type, key, nKey, val, len);
+      } else if (pTagVal->nData == 0) {
+        term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, pTagVal->pData, 0);
+      }
+    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
+      double val = *(double *)(&pTagVal->i64);
+      int    len = sizeof(val);
+      term = indexTermCreate(suid, DEL_VALUE, type, key, nKey, (const char *)&val, len);
+    } else if (type == TSDB_DATA_TYPE_BOOL) {
+      int val = *(int *)(&pTagVal->i64);
+      int len = sizeof(val);
+      term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len);
     }
     if (term != NULL) {
       indexMultiTermAdd(terms, term);
@@ -434,9 +493,33 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
 
   if (type) *type = e.type;
 
+  if (e.type == TSDB_CHILD_TABLE) {
+    void *tData = NULL;
+    int   tLen = 0;
+
+    if (tdbTbGet(pMeta->pUidIdx, &e.ctbEntry.suid, sizeof(tb_uid_t), &tData, &tLen) == 0) {
+      version = *(int64_t *)tData;
+      STbDbKey tbDbKey = {.uid = e.ctbEntry.suid, .version = version};
+      if (tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &tData, &tLen) == 0) {
+        SDecoder   tdc = {0};
+        SMetaEntry stbEntry = {0};
+
+        tDecoderInit(&tdc, tData, tLen);
+        metaDecodeEntry(&tdc, &stbEntry);
+        const SSchema *pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0];
+        if (pTagColumn->type == TSDB_DATA_TYPE_JSON) {
+          metaDelJsonVarFromIdx(pMeta, &e, pTagColumn);
+        }
+        tDecoderClear(&tdc);
+      }
+      tdbFree(tData);
+    }
+  }
+
   tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pMeta->txn);
   tdbTbDelete(pMeta->pNameIdx, e.name, strlen(e.name) + 1, &pMeta->txn);
   tdbTbDelete(pMeta->pUidIdx, &uid, sizeof(uid), &pMeta->txn);
+
   if (e.type != TSDB_SUPER_TABLE) metaDeleteTtlIdx(pMeta, &e);
 
   if (e.type == TSDB_CHILD_TABLE) {
diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c
index 92168a9b92da9f0dff294ffed199f79fced0a553..4c2e606e0ee23325761ac9ce38c50a65311e4d8a 100644
--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@@ -277,6 +277,9 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaInfo
       pItem->maxDelay = TSDB_MAX_ROLLUP_MAX_DELAY;
     }
     pItem->level = (idx == 0 ? TSDB_RETENTION_L1 : TSDB_RETENTION_L2);
+    smaInfo("vgId:%d table:%" PRIi64 " level:%" PRIi8 " maxdelay:%" PRIi64 " watermark:%" PRIi64
+            ", finally maxdelay:%" PRIi32,
+            SMA_VID(pSma), pRSmaInfo->suid, idx + 1, param->maxdelay[idx], param->watermark[idx], pItem->maxDelay);
   }
   return TSDB_CODE_SUCCESS;
 _err:
@@ -325,14 +328,14 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
     return TSDB_CODE_FAILED;
   }
 
-  SStreamReader *pReadHandle = tqInitSubmitMsgScanner(pMeta);
-  if (!pReadHandle) {
+  STqReader *pReader = tqOpenReader(pVnode);
+  if (!pReader) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _err;
   }
 
   SReadHandle handle = {
-      .streamReader = pReadHandle,
+      .tqReader = pReader,
       .meta = pMeta,
       .pMsgCb = pMsgCb,
       .vnode = pVnode,
@@ -364,7 +367,7 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
   return TSDB_CODE_SUCCESS;
 _err:
   tdFreeRSmaInfo(pRSmaInfo);
-  taosMemoryFree(pReadHandle);
+  taosMemoryFree(pReader);
   return TSDB_CODE_FAILED;
 }
 
@@ -570,11 +573,15 @@ static int32_t tdFetchAndSubmitRSmaResult(SRSmaInfoItem *pItem, int8_t blkType)
     SSubmitReq *pReq = NULL;
     // TODO: the schema update should be handled
     if (buildSubmitReqFromDataBlock(&pReq, pResult, pRSmaInfo->pTSchema, SMA_VID(pSma), pRSmaInfo->suid) < 0) {
+      smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
+               pRSmaInfo->suid, pItem->level, terrstr());
       goto _err;
     }
 
     if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pRSmaInfo->pStat->submitVer, 1), pReq) < 0) {
       taosMemoryFreeClear(pReq);
+      smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma),
+               pRSmaInfo->suid, pItem->level, terrstr());
       goto _err;
     }
 
diff --git a/source/dnode/vnode/src/sma/smaSnapshot.c b/source/dnode/vnode/src/sma/smaSnapshot.c
deleted file mode 100644
index b2c85642b91aa4cb52e31fdccf713342b6123172..0000000000000000000000000000000000000000
--- a/source/dnode/vnode/src/sma/smaSnapshot.c
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * 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 "sma.h"
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 2dd80c5d52e90a514884fec38035b5259f347b01..e21b0fe9e8fc87eabc721b4c0a09394724625978 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -447,26 +447,38 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
     pHandle->fetchMeta = req.withMeta;
 
     pHandle->pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-    for (int32_t i = 0; i < 5; i++) {
-      pHandle->execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta);
-    }
+    /*for (int32_t i = 0; i < 5; i++) {*/
+    /*pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);*/
+    /*}*/
     if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
       pHandle->execHandle.execCol.qmsg = req.qmsg;
       req.qmsg = NULL;
       for (int32_t i = 0; i < 5; i++) {
         SReadHandle handle = {
-            .streamReader = pHandle->execHandle.pExecReader[i],
+            .tqReader = pHandle->execHandle.pExecReader[i],
             .meta = pTq->pVnode->pMeta,
             .vnode = pTq->pVnode,
             .initTableReader = true,
+            .initTqReader = true,
         };
         pHandle->execHandle.execCol.task[i] = qCreateStreamExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle);
         ASSERT(pHandle->execHandle.execCol.task[i]);
+        void* scanner = NULL;
+        qExtractStreamScanner(pHandle->execHandle.execCol.task[i], &scanner);
+        ASSERT(scanner);
+        pHandle->execHandle.pExecReader[i] = qExtractReaderFromStreamScanner(scanner);
+        ASSERT(pHandle->execHandle.pExecReader[i]);
       }
     } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
+      for (int32_t i = 0; i < 5; i++) {
+        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
+      }
       pHandle->execHandle.execDb.pFilterOutTbUid =
           taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
     } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
+      for (int32_t i = 0; i < 5; i++) {
+        pHandle->execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
+      }
       pHandle->execHandle.execTb.suid = req.suid;
       SArray* tbUidList = taosArrayInit(0, sizeof(int64_t));
       vnodeGetCtbIdList(pTq->pVnode, req.suid, tbUidList);
@@ -476,7 +488,7 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
         tqDebug("vg %d, idx %d, uid: %ld", TD_VID(pTq->pVnode), i, tbUid);
       }
       for (int32_t i = 0; i < 5; i++) {
-        tqReadHandleSetTbUidList(pHandle->execHandle.pExecReader[i], tbUidList);
+        tqReaderSetTbUidList(pHandle->execHandle.pExecReader[i], tbUidList);
       }
       taosArrayDestroy(tbUidList);
     }
@@ -532,7 +544,7 @@ int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen) {
       SReadHandle handle = {
           .meta = pTq->pVnode->pMeta,
           .vnode = pTq->pVnode,
-          .initStreamReader = 1,
+          .initTqReader = 1,
       };
       pTask->exec.executor = qCreateStreamExecTaskInfo(pTask->exec.qmsg, &handle);
     } else {
diff --git a/source/dnode/vnode/src/tq/tqExec.c b/source/dnode/vnode/src/tq/tqExec.c
index 9dd2a0258fd25a5a18c9f67a2b6ca7b1076af62a..16822e6003a12b450348a17c31538e4b46cef46c 100644
--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@@ -135,8 +135,8 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
     }
   } else if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
     pRsp->withSchema = 1;
-    SStreamReader* pReader = pExec->pExecReader[workerId];
-    tqReadHandleSetMsg(pReader, pReq, 0);
+    STqReader* pReader = pExec->pExecReader[workerId];
+    tqReaderSetDataMsg(pReader, pReq, 0);
     while (tqNextDataBlock(pReader)) {
       SSDataBlock block = {0};
       if (tqRetrieveDataBlock(&block, pReader) < 0) {
@@ -153,8 +153,8 @@ int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataR
     }
   } else if (pExec->subType == TOPIC_SUB_TYPE__DB) {
     pRsp->withSchema = 1;
-    SStreamReader* pReader = pExec->pExecReader[workerId];
-    tqReadHandleSetMsg(pReader, pReq, 0);
+    STqReader* pReader = pExec->pExecReader[workerId];
+    tqReaderSetDataMsg(pReader, pReq, 0);
     while (tqNextDataBlockFilterOut(pReader, pExec->execDb.pFilterOutTbUid)) {
       SSDataBlock block = {0};
       if (tqRetrieveDataBlock(&block, pReader) < 0) {
diff --git a/source/dnode/vnode/src/tq/tqMeta.c b/source/dnode/vnode/src/tq/tqMeta.c
index c7e9c8eed6fb703227f840b5c52ba1d10ceb1be3..67fa4ed1661752aebc151a11babe42c190364d99 100644
--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@@ -79,12 +79,12 @@ int32_t tqMetaOpen(STQ* pTq) {
     tDecodeSTqHandle(&decoder, &handle);
     handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
     for (int32_t i = 0; i < 5; i++) {
-      handle.execHandle.pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta);
+      handle.execHandle.pExecReader[i] = tqOpenReader(pTq->pVnode);
     }
     if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
       for (int32_t i = 0; i < 5; i++) {
         SReadHandle reader = {
-            .streamReader = handle.execHandle.pExecReader[i],
+            .tqReader = handle.execHandle.pExecReader[i],
             .meta = pTq->pVnode->pMeta,
             .pMsgCb = &pTq->pVnode->msgCb,
             .vnode = pTq->pVnode,
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index bc992b2211a62a25c672da55c6d954f987cb0468..53ef17a6baf1403704df388844d47ec6efd0965f 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -15,6 +15,11 @@
 
 #include "tq.h"
 
+int64_t tqScanLog(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal offset) {
+  /*if ()*/
+  return 0;
+}
+
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHead** ppCkHead) {
   int32_t code = 0;
   taosThreadMutexLock(&pHandle->pWalReader->mutex);
@@ -73,53 +78,107 @@ END:
   return code;
 }
 
-SStreamReader* tqInitSubmitMsgScanner(SMeta* pMeta) {
-  SStreamReader* pReadHandle = taosMemoryMalloc(sizeof(SStreamReader));
-  if (pReadHandle == NULL) {
+STqReader* tqOpenReader(SVnode* pVnode) {
+  STqReader* pReader = taosMemoryMalloc(sizeof(STqReader));
+  if (pReader == NULL) {
     return NULL;
   }
-  pReadHandle->pVnodeMeta = pMeta;
-  pReadHandle->pMsg = NULL;
-  pReadHandle->ver = -1;
-  pReadHandle->pColIdList = NULL;
-  pReadHandle->cachedSchemaVer = 0;
-  pReadHandle->cachedSchemaSuid = 0;
-  pReadHandle->pSchema = NULL;
-  pReadHandle->pSchemaWrapper = NULL;
-  pReadHandle->tbIdHash = NULL;
-  return pReadHandle;
+
+  // TODO open
+  /*pReader->pWalReader = walOpenReader(pVnode->pWal, NULL);*/
+
+  pReader->pVnodeMeta = pVnode->pMeta;
+  pReader->pMsg = NULL;
+  pReader->ver = -1;
+  pReader->pColIdList = NULL;
+  pReader->cachedSchemaVer = 0;
+  pReader->cachedSchemaSuid = 0;
+  pReader->pSchema = NULL;
+  pReader->pSchemaWrapper = NULL;
+  pReader->tbIdHash = NULL;
+  return pReader;
+}
+
+void tqCloseReader(STqReader* pReader) {
+  // close wal reader
+  // free cached schema
+  // free hash
+  taosMemoryFree(pReader);
+}
+
+int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
+  bool fromProcessedMsg = pReader->pMsg != NULL;
+
+  while (1) {
+    if (!fromProcessedMsg) {
+      if (walNextValidMsg(pReader->pWalReader) < 0) {
+        ret->fetchType = FETCH_TYPE__NONE;
+        return -1;
+      }
+      void* body = pReader->pWalReader->pHead->head.body;
+      if (pReader->pWalReader->pHead->head.msgType != TDMT_VND_SUBMIT) {
+        // TODO do filter
+        ret->fetchType = FETCH_TYPE__META;
+        ret->meta = pReader->pWalReader->pHead->head.body;
+        return 0;
+      } else {
+        tqReaderSetDataMsg(pReader, body, pReader->pWalReader->pHead->head.version);
+      }
+    }
+
+    while (tqNextDataBlock(pReader)) {
+      memset(&ret->data, 0, sizeof(SSDataBlock));
+      int32_t code = tqRetrieveDataBlock(&ret->data, pReader);
+      if (code != 0 || ret->data.info.rows == 0) {
+        if (fromProcessedMsg) {
+          ret->fetchType = FETCH_TYPE__NONE;
+          return 0;
+        } else {
+          break;
+        }
+      }
+
+      ret->fetchType = FETCH_TYPE__DATA;
+      return 0;
+    }
+
+    if (fromProcessedMsg) {
+      ret->fetchType = FETCH_TYPE__NONE;
+      return 0;
+    }
+  }
 }
 
-int32_t tqReadHandleSetMsg(SStreamReader* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
-  pReadHandle->pMsg = pMsg;
+int32_t tqReaderSetDataMsg(STqReader* pReader, SSubmitReq* pMsg, int64_t ver) {
+  pReader->pMsg = pMsg;
 
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIter(pMsg, &pReader->msgIter) < 0) return -1;
   while (true) {
-    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
-    if (pReadHandle->pBlock == NULL) break;
+    if (tGetSubmitMsgNext(&pReader->msgIter, &pReader->pBlock) < 0) return -1;
+    if (pReader->pBlock == NULL) break;
   }
 
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
-  pReadHandle->ver = ver;
-  memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
+  if (tInitSubmitMsgIter(pMsg, &pReader->msgIter) < 0) return -1;
+  pReader->ver = ver;
+  memset(&pReader->blkIter, 0, sizeof(SSubmitBlkIter));
   return 0;
 }
 
-bool tqNextDataBlock(SStreamReader* pHandle) {
-  if (pHandle->pMsg == NULL) return false;
+bool tqNextDataBlock(STqReader* pReader) {
+  if (pReader->pMsg == NULL) return false;
   while (1) {
-    if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
+    if (tGetSubmitMsgNext(&pReader->msgIter, &pReader->pBlock) < 0) {
       return false;
     }
-    if (pHandle->pBlock == NULL) {
-      pHandle->pMsg = NULL;
+    if (pReader->pBlock == NULL) {
+      pReader->pMsg = NULL;
       return false;
     }
 
-    if (pHandle->tbIdHash == NULL) {
+    if (pReader->tbIdHash == NULL) {
       return true;
     }
-    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->msgIter.uid, sizeof(int64_t));
+    void* ret = taosHashGet(pReader->tbIdHash, &pReader->msgIter.uid, sizeof(int64_t));
     /*tqDebug("search uid %ld", pHandle->msgIter.uid);*/
     if (ret != NULL) {
       /*tqDebug("find   uid %ld", pHandle->msgIter.uid);*/
@@ -129,7 +188,7 @@ bool tqNextDataBlock(SStreamReader* pHandle) {
   return false;
 }
 
-bool tqNextDataBlockFilterOut(SStreamReader* pHandle, SHashObj* filterOutUids) {
+bool tqNextDataBlockFilterOut(STqReader* pHandle, SHashObj* filterOutUids) {
   while (1) {
     if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
       return false;
@@ -145,38 +204,38 @@ bool tqNextDataBlockFilterOut(SStreamReader* pHandle, SHashObj* filterOutUids) {
   return false;
 }
 
-int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, SStreamReader* pHandle) {
+int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
   // TODO: cache multiple schema
-  int32_t sversion = htonl(pHandle->pBlock->sversion);
-  if (pHandle->cachedSchemaSuid == 0 || pHandle->cachedSchemaVer != sversion ||
-      pHandle->cachedSchemaSuid != pHandle->msgIter.suid) {
-    if (pHandle->pSchema) taosMemoryFree(pHandle->pSchema);
-    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion);
-    if (pHandle->pSchema == NULL) {
+  int32_t sversion = htonl(pReader->pBlock->sversion);
+  if (pReader->cachedSchemaSuid == 0 || pReader->cachedSchemaVer != sversion ||
+      pReader->cachedSchemaSuid != pReader->msgIter.suid) {
+    if (pReader->pSchema) taosMemoryFree(pReader->pSchema);
+    pReader->pSchema = metaGetTbTSchema(pReader->pVnodeMeta, pReader->msgIter.uid, sversion);
+    if (pReader->pSchema == NULL) {
       tqWarn("cannot found tsschema for table: uid: %ld (suid: %ld), version %d, possibly dropped table",
-             pHandle->msgIter.uid, pHandle->msgIter.suid, pHandle->cachedSchemaVer);
+             pReader->msgIter.uid, pReader->msgIter.suid, pReader->cachedSchemaVer);
       /*ASSERT(0);*/
       terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND;
       return -1;
     }
 
-    if (pHandle->pSchemaWrapper) tDeleteSSchemaWrapper(pHandle->pSchemaWrapper);
-    pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion, true);
-    if (pHandle->pSchemaWrapper == NULL) {
+    if (pReader->pSchemaWrapper) tDeleteSSchemaWrapper(pReader->pSchemaWrapper);
+    pReader->pSchemaWrapper = metaGetTableSchema(pReader->pVnodeMeta, pReader->msgIter.uid, sversion, true);
+    if (pReader->pSchemaWrapper == NULL) {
       tqWarn("cannot found schema wrapper for table: suid: %ld, version %d, possibly dropped table",
-             pHandle->msgIter.uid, pHandle->cachedSchemaVer);
+             pReader->msgIter.uid, pReader->cachedSchemaVer);
       /*ASSERT(0);*/
       terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND;
       return -1;
     }
-    pHandle->cachedSchemaVer = sversion;
-    pHandle->cachedSchemaSuid = pHandle->msgIter.suid;
+    pReader->cachedSchemaVer = sversion;
+    pReader->cachedSchemaSuid = pReader->msgIter.suid;
   }
 
-  STSchema*       pTschema = pHandle->pSchema;
-  SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
+  STSchema*       pTschema = pReader->pSchema;
+  SSchemaWrapper* pSchemaWrapper = pReader->pSchemaWrapper;
 
-  int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
+  int32_t colNumNeed = taosArrayGetSize(pReader->pColIdList);
 
   if (colNumNeed == 0) {
     int32_t colMeta = 0;
@@ -199,7 +258,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, SStreamReader* pHandle) {
     while (colMeta < pSchemaWrapper->nCols && colNeed < colNumNeed) {
       SSchema* pColSchema = &pSchemaWrapper->pSchema[colMeta];
       col_id_t colIdSchema = pColSchema->colId;
-      col_id_t colIdNeed = *(col_id_t*)taosArrayGet(pHandle->pColIdList, colNeed);
+      col_id_t colIdNeed = *(col_id_t*)taosArrayGet(pReader->pColIdList, colNeed);
       if (colIdSchema < colIdNeed) {
         colMeta++;
       } else if (colIdSchema > colIdNeed) {
@@ -216,7 +275,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, SStreamReader* pHandle) {
     }
   }
 
-  if (blockDataEnsureCapacity(pBlock, pHandle->msgIter.numOfRows) < 0) {
+  if (blockDataEnsureCapacity(pBlock, pReader->msgIter.numOfRows) < 0) {
     goto FAIL;
   }
 
@@ -227,13 +286,12 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, SStreamReader* pHandle) {
   STSRow* row;
   int32_t curRow = 0;
 
-  tInitSubmitBlkIter(&pHandle->msgIter, pHandle->pBlock, &pHandle->blkIter);
+  tInitSubmitBlkIter(&pReader->msgIter, pReader->pBlock, &pReader->blkIter);
 
-  pBlock->info.groupId = 0;
-  pBlock->info.uid = pHandle->msgIter.uid;
-  pBlock->info.rows = pHandle->msgIter.numOfRows;
+  pBlock->info.uid = pReader->msgIter.uid;
+  pBlock->info.rows = pReader->msgIter.numOfRows;
 
-  while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
+  while ((row = tGetSubmitBlkNext(&pReader->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);
     // get all wanted col of that block
     for (int32_t i = 0; i < colActual; i++) {
@@ -255,9 +313,9 @@ FAIL:
   return -1;
 }
 
-void tqReadHandleSetColIdList(SStreamReader* pReadHandle, SArray* pColIdList) { pReadHandle->pColIdList = pColIdList; }
+void tqReaderSetColIdList(STqReader* pReadHandle, SArray* pColIdList) { pReadHandle->pColIdList = pColIdList; }
 
-int tqReadHandleSetTbUidList(SStreamReader* pHandle, const SArray* tbUidList) {
+int tqReaderSetTbUidList(STqReader* pHandle, const SArray* tbUidList) {
   if (pHandle->tbIdHash) {
     taosHashClear(pHandle->tbIdHash);
   }
@@ -276,7 +334,7 @@ int tqReadHandleSetTbUidList(SStreamReader* pHandle, const SArray* tbUidList) {
   return 0;
 }
 
-int tqReadHandleAddTbUidList(SStreamReader* pHandle, const SArray* tbUidList) {
+int tqReaderAddTbUidList(STqReader* pHandle, const SArray* tbUidList) {
   if (pHandle->tbIdHash == NULL) {
     pHandle->tbIdHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
     if (pHandle->tbIdHash == NULL) {
@@ -293,7 +351,7 @@ int tqReadHandleAddTbUidList(SStreamReader* pHandle, const SArray* tbUidList) {
   return 0;
 }
 
-int tqReadHandleRemoveTbUidList(SStreamReader* pHandle, const SArray* tbUidList) {
+int tqReaderRemoveTbUidList(STqReader* pHandle, const SArray* tbUidList) {
   ASSERT(pHandle->tbIdHash != NULL);
 
   for (int32_t i = 0; i < taosArrayGetSize(tbUidList); i++) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c
index 2086d94099c222e7374912c6862171fc89500185..ea1dfc057f28ea81402f0bd25aac52edc83480fe 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@@ -59,6 +59,8 @@ static void getTableCacheKey(tb_uid_t uid, int cacheType, char *key, int *len) {
 
 static void deleteTableCacheLastrow(const void *key, size_t keyLen, void *value) { taosMemoryFree(value); }
 
+static void deleteTableCacheLast(const void *key, size_t keyLen, void *value) { taosArrayDestroy(value); }
+
 static int32_t tsdbCacheDeleteLastrow(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey) {
   int32_t code = 0;
   char    key[32] = {0};
@@ -761,7 +763,6 @@ static int32_t mergeLastRow(tb_uid_t uid, STsdb *pTsdb, bool *dup, STSRow **ppRo
     for (int i = 0; i < nMax; ++i) {
       TSDBKEY maxKey = TSDBROW_KEY(max[i]);
 
-      // bool deleted = false;
       bool deleted = tsdbKeyDeleted(&maxKey, pSkyline, &iSkyline);
       if (!deleted) {
         // iMerge[nMerge] = i;
@@ -818,12 +819,22 @@ _err:
   return code;
 }
 
-static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
-  int32_t code = 0;
+typedef struct {
+  TSKEY   ts;
+  SColVal colVal;
+} SLastCol;
+
+// static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
+static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray) {
+  int32_t  code = 0;
+  SArray  *pSkyline = NULL;
+  STSRow  *pRow = NULL;
+  STSRow **ppRow = &pRow;
 
   STSchema *pTSchema = metaGetTbTSchema(pTsdb->pVnode->pMeta, uid, -1);
   int16_t   nCol = pTSchema->numOfCols;
-  SArray   *pColArray = taosArrayInit(nCol, sizeof(SColVal));
+  //  SArray   *pColArray = taosArrayInit(nCol, sizeof(SColVal));
+  SArray *pColArray = taosArrayInit(nCol, sizeof(SLastCol));
 
   tb_uid_t suid = getTableSuidByUid(uid, pTsdb);
 
@@ -837,9 +848,9 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
     tsdbGetTbDataFromMemTable(pTsdb->imem, suid, uid, &pIMem);
   }
 
-  *ppRow = NULL;
+  *ppLastArray = NULL;
 
-  SArray *pSkyline = taosArrayInit(32, sizeof(TSDBKEY));
+  pSkyline = taosArrayInit(32, sizeof(TSDBKEY));
 
   SDelIdx delIdx;
 
@@ -943,7 +954,6 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
     for (int i = 0; i < nMax; ++i) {
       TSDBKEY maxKey = TSDBROW_KEY(max[i]);
 
-      // bool deleted = false;
       bool deleted = tsdbKeyDeleted(&maxKey, pSkyline, &iSkyline);
       if (!deleted) {
         iMerge[nMerge] = iMax[i];
@@ -970,8 +980,9 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
         tRowMergerClear(&merger);
       }
     } else {
-      *ppRow = NULL;
-      return code;
+      /* *ppRow = NULL; */
+      /* return code; */
+      continue;
     }
 
     if (iCol == 0) {
@@ -980,7 +991,8 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
 
       *pColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.ts = maxKey});
 
-      if (taosArrayPush(pColArray, pColVal) == NULL) {
+      // if (taosArrayPush(pColArray, pColVal) == NULL) {
+      if (taosArrayPush(pColArray, &(SLastCol){.ts = TSKEY_MAX, .colVal = *pColVal}) == NULL) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         goto _err;
       }
@@ -991,7 +1003,8 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
       for (int16_t i = iCol; i < nCol; ++i) {
         // tsdbRowGetColVal(*ppRow, pTSchema, i, pColVal);
         tTSRowGetVal(*ppRow, pTSchema, i, pColVal);
-        if (taosArrayPush(pColArray, pColVal) == NULL) {
+        // if (taosArrayPush(pColArray, pColVal) == NULL) {
+        if (taosArrayPush(pColArray, &(SLastCol){.ts = maxKey, .colVal = *pColVal}) == NULL) {
           code = TSDB_CODE_OUT_OF_MEMORY;
           goto _err;
         }
@@ -1012,11 +1025,11 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
           --nilColCount;
         }
       }
-      /*
+
       if (*ppRow) {
         taosMemoryFreeClear(*ppRow);
       }
-      */
+
       continue;
     }
 
@@ -1024,12 +1037,16 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
     for (int16_t i = iCol; i < nCol; ++i) {
       SColVal colVal = {0};
       tTSRowGetVal(*ppRow, pTSchema, i, &colVal);
+      TSKEY rowTs = (*ppRow)->ts;
 
-      SColVal *tColVal = (SColVal *)taosArrayGet(pColArray, i);
+      // SColVal *tColVal = (SColVal *)taosArrayGet(pColArray, i);
+      SLastCol *tTsVal = (SLastCol *)taosArrayGet(pColArray, i);
+      SColVal  *tColVal = &tTsVal->colVal;
 
       if (!colVal.isNone && !colVal.isNull) {
         if (tColVal->isNull || tColVal->isNone) {
-          taosArraySet(pColArray, i, &colVal);
+          // taosArraySet(pColArray, i, &colVal);
+          taosArraySet(pColArray, i, &(SLastCol){.ts = rowTs, .colVal = colVal});
           --nilColCount;
         }
       } else {
@@ -1054,16 +1071,45 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, STSRow **ppRow) {
   } while (nilColCount > 0);
 
   // if () new ts row from pColArray if non empty
-  if (taosArrayGetSize(pColArray) == nCol) {
-    code = tdSTSRowNew(pColArray, pTSchema, ppRow);
-    if (code) goto _err;
+  /* if (taosArrayGetSize(pColArray) == nCol) { */
+  /*   code = tdSTSRowNew(pColArray, pTSchema, ppRow); */
+  /*   if (code) goto _err; */
+  /* } */
+  /* taosArrayDestroy(pColArray); */
+  if (taosArrayGetSize(pColArray) <= 0) {
+    *ppLastArray = NULL;
+    taosArrayDestroy(pColArray);
+  } else {
+    *ppLastArray = pColArray;
+  }
+  if (*ppRow) {
+    taosMemoryFreeClear(*ppRow);
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    if (input[i].nextRowClearFn) {
+      input[i].nextRowClearFn(input[i].iter);
+    }
+  }
+  if (pSkyline) {
+    taosArrayDestroy(pSkyline);
   }
-  taosArrayDestroy(pColArray);
   taosMemoryFreeClear(pTSchema);
 
   return code;
 _err:
   taosArrayDestroy(pColArray);
+  if (*ppRow) {
+    taosMemoryFreeClear(*ppRow);
+  }
+  for (int i = 0; i < 3; ++i) {
+    if (input[i].nextRowClearFn) {
+      input[i].nextRowClearFn(input[i].iter);
+    }
+  }
+  if (pSkyline) {
+    taosArrayDestroy(pSkyline);
+  }
   taosMemoryFreeClear(pTSchema);
   tsdbError("vgId:%d merge last_row failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
   return code;
@@ -1103,6 +1149,30 @@ int32_t tsdbCacheGetLastrowH(SLRUCache *pCache, tb_uid_t uid, STsdb *pTsdb, LRUH
   return code;
 }
 
+int32_t tsdbCacheLastArray2Row(SArray *pLastArray, STSRow **ppRow, STSchema *pTSchema) {
+  int32_t code = 0;
+  int16_t nCol = taosArrayGetSize(pLastArray);
+  SArray *pColArray = taosArrayInit(nCol, sizeof(SColVal));
+
+  for (int16_t iCol = 0; iCol < nCol; ++iCol) {
+    SLastCol *tTsVal = (SLastCol *)taosArrayGet(pLastArray, iCol);
+    SColVal  *tColVal = &tTsVal->colVal;
+    taosArrayPush(pColArray, tColVal);
+  }
+
+  code = tdSTSRowNew(pColArray, pTSchema, ppRow);
+  if (code) goto _err;
+
+  taosArrayDestroy(pColArray);
+
+  return code;
+
+_err:
+  taosArrayDestroy(pColArray);
+
+  return code;
+}
+
 int32_t tsdbCacheGetLastH(SLRUCache *pCache, tb_uid_t uid, STsdb *pTsdb, LRUHandle **handle) {
   int32_t code = 0;
   char    key[32] = {0};
@@ -1115,17 +1185,20 @@ int32_t tsdbCacheGetLastH(SLRUCache *pCache, tb_uid_t uid, STsdb *pTsdb, LRUHand
     //*ppRow = (STSRow *)taosLRUCacheValue(pCache, h);
 
   } else {
-    STSRow *pRow = NULL;
-    code = mergeLast(uid, pTsdb, &pRow);
+    // STSRow *pRow = NULL;
+    // code = mergeLast(uid, pTsdb, &pRow);
+    SArray *pLastArray = NULL;
+    code = mergeLast(uid, pTsdb, &pLastArray);
     // if table's empty or error, return code of -1
-    if (code < 0 || pRow == NULL) {
+    // if (code < 0 || pRow == NULL) {
+    if (code < 0 || pLastArray == NULL) {
       *handle = NULL;
       return 0;
     }
 
-    _taos_lru_deleter_t deleter = deleteTableCacheLastrow;
+    _taos_lru_deleter_t deleter = deleteTableCacheLast;
     LRUStatus           status =
-        taosLRUCacheInsert(pCache, key, keyLen, pRow, TD_ROW_LEN(pRow), deleter, NULL, TAOS_LRU_PRIORITY_LOW);
+        taosLRUCacheInsert(pCache, key, keyLen, pLastArray, pLastArray->capacity, deleter, NULL, TAOS_LRU_PRIORITY_LOW);
     if (status != TAOS_LRU_STATUS_OK) {
       code = -1;
     }
diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index 30bc603b309190cc11c7486e2faec998b5c5afab..150ed620bfe7a41c1ad26a9d3a882d6a8eacf3d8 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -128,6 +128,8 @@ int32_t tsdbRetrieveLastRow(void* pReader, SSDataBlock* pResBlock, const int32_t
       }
 
       pRow = (STSRow*)taosLRUCacheValue(lruCache, h);
+      // SArray* pLast = (SArray*)taosLRUCacheValue(lruCache, h);
+      // tsdbCacheLastArray2Row(pLast, &pRow, pr->pSchema);
       if (pRow->ts > lastKey) {
         // Set result row into the same rowIndex repeatly, so we need to check if the internal result row has already
         // appended or not.
@@ -140,6 +142,7 @@ int32_t tsdbRetrieveLastRow(void* pReader, SSDataBlock* pResBlock, const int32_t
         lastKey = pRow->ts;
       }
 
+      // taosMemoryFree(pRow);
       tsdbCacheRelease(lruCache, h);
     }
   } else if (pr->type == LASTROW_RETRIEVE_TYPE_ALL) {
@@ -158,8 +161,12 @@ int32_t tsdbRetrieveLastRow(void* pReader, SSDataBlock* pResBlock, const int32_t
       }
 
       pRow = (STSRow*)taosLRUCacheValue(lruCache, h);
+      // SArray* pLast = (SArray*)taosLRUCacheValue(lruCache, h);
+      // tsdbCacheLastArray2Row(pLast, &pRow, pr->pSchema);
+
       saveOneRow(pRow, pResBlock, pr, slotIds);
 
+      // taosMemoryFree(pRow);
       tsdbCacheRelease(lruCache, h);
 
       pr->tableIndex += 1;
diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit.c b/source/dnode/vnode/src/tsdb/tsdbCommit.c
index b60a4697fadc4b32ddf999753d756c404858ad3e..8a189d98b33da4363b1ae3b192834fa913c3ae7e 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCommit.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit.c
@@ -602,7 +602,7 @@ static int32_t tsdbGetOvlpNRow(STbDataIter *pIter, SBlock *pBlock) {
 
   iter.pRow = NULL;
   while (true) {
-    pRow = tsdbTbDataIterGet(pIter);
+    pRow = tsdbTbDataIterGet(&iter);
 
     if (pRow == NULL) break;
     key = TSDBROW_KEY(pRow);
@@ -610,7 +610,7 @@ static int32_t tsdbGetOvlpNRow(STbDataIter *pIter, SBlock *pBlock) {
     c = tBlockCmprFn(&(SBlock){.maxKey = key, .minKey = key}, pBlock);
     if (c == 0) {
       nRow++;
-      tsdbTbDataIterNext(pIter);
+      tsdbTbDataIterNext(&iter);
     } else if (c > 0) {
       break;
     } else {
@@ -635,7 +635,7 @@ static int32_t tsdbMergeAsSubBlock(SCommitter *pCommitter, STbDataIter *pIter, S
   code = tsdbCommitterUpdateRowSchema(pCommitter, pBlockIdx->suid, pBlockIdx->uid, TSDBROW_SVERSION(pRow));
   if (code) goto _err;
   while (true) {
-    if (pRow) break;
+    if (pRow == NULL) break;
     code = tBlockDataAppendRow(pBlockData, pRow, pCommitter->skmRow.pTSchema);
     if (code) goto _err;
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 8e5b135858f97573decc7bfd86f0e07f3c9dec04..47aec548a14920a4364220382b916e62c6ba6658 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -48,14 +48,15 @@ typedef struct SBlockOrderSupporter {
 
 typedef struct SIOCostSummary {
   int64_t blockLoadTime;
-  int64_t statisInfoLoadTime;
+  int64_t smaLoadTime;
   int64_t checkForNextTime;
   int64_t headFileLoad;
   int64_t headFileLoadTime;
 } SIOCostSummary;
 
 typedef struct SBlockLoadSuppInfo {
-  SColumnDataAgg*  pstatis;
+  SArray*          pColAgg;
+  SColumnDataAgg   tsColAgg;
   SColumnDataAgg** plist;
   int16_t*         colIds;    // column ids for loading file block data
   int32_t*         slotIds;   // colId to slotId
@@ -63,10 +64,10 @@ typedef struct SBlockLoadSuppInfo {
 } SBlockLoadSuppInfo;
 
 typedef struct SFilesetIter {
-  int32_t numOfFiles;  // number of total files
-  int32_t index;       // current accessed index in the list
-  SArray* pFileList;   // data file list
-  int32_t order;
+  int32_t          numOfFiles;  // number of total files
+  int32_t          index;       // current accessed index in the list
+  SArray*          pFileList;   // data file list
+  int32_t          order;
 } SFilesetIter;
 
 typedef struct SFileDataBlockInfo {
@@ -119,24 +120,10 @@ struct STsdbReader {
   int32_t            type;   // query type: 1. retrieve all data blocks, 2. retrieve direct prev|next rows
   SBlockLoadSuppInfo suppInfo;
 
-  SIOCostSummary cost;
-  STSchema*      pSchema;
-  SDataFReader*  pFileReader;
-  SVersionRange  verRange;
-#if 0
-  SArray*            prev;  // previous row which is before than time window
-  SArray*            next;  // next row which is after the query time window
-  SFileBlockInfo*   pDataBlockInfo;
-  SDataCols*         pDataCols;         // in order to hold current file data block
-  int32_t            allocSize;         // allocated data block size
-  SDataBlockLoadInfo dataBlockLoadInfo; /* record current block load information */
-  SLoadCompBlockInfo compBlockLoadInfo; /* record current compblock information in SQueryAttr */
-  //  SDFileSet* pFileGroup;
-  // SFSIter            fileIter;
-  // SReadH             rhelper;
-  //  SColumnDataAgg* statis;  // query level statistics, only one table block statistics info exists at any time
-  //  SColumnDataAgg** pstatis;// the ptr array list to return to caller
-#endif
+  SIOCostSummary     cost;
+  STSchema*          pSchema;
+  SDataFReader*      pFileReader;
+  SVersionRange      verRange;
 };
 
 static SFileDataBlockInfo* getCurrentBlockInfo(SDataBlockIter* pBlockIter);
@@ -150,7 +137,7 @@ static int32_t  doMergeRowsInBuf(SIterInfo* pIter, int64_t ts, SArray* pDelList,
 static int32_t  doAppendOneRow(SSDataBlock* pBlock, STsdbReader* pReader, STSRow* pTSRow);
 static void     setComposedBlockFlag(STsdbReader* pReader, bool composed);
 static void     updateSchema(TSDBROW* pRow, uint64_t uid, STsdbReader* pReader);
-static bool     hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey);
+static bool     hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order);
 
 static void doMergeMultiRows(TSDBROW* pRow, uint64_t uid, SIterInfo* pIter, SArray* pDelList, STSRow** pTSRow,
                              STsdbReader* pReader);
@@ -252,33 +239,6 @@ static STimeWindow updateQueryTimeWindow(STsdb* pTsdb, STimeWindow* pWindow) {
   return win;
 }
 
-// todo remove this
-static void setQueryTimewindow(STsdbReader* pReader, SQueryTableDataCond* pCond, int32_t tWinIdx) {
-  // pReader->window = pCond->twindows[tWinIdx];
-
-  // bool    updateTs = false;
-  // int64_t startTs = updateQueryTimeWindow(pReader->pTsdb);
-  // if (ASCENDING_TRAVERSE(pReader->order)) {
-  //   if (startTs > pReader->window.skey) {
-  //     pReader->window.skey = startTs;
-  //     pCond->twindows[tWinIdx].skey = startTs;
-  //     updateTs = true;
-  //   }
-  // } else {
-  //   if (startTs > pReader->window.ekey) {
-  //     pReader->window.ekey = startTs;
-  //     pCond->twindows[tWinIdx].ekey = startTs;
-  //     updateTs = true;
-  //   }
-  // }
-
-  // if (updateTs) {
-  //   tsdbDebug("%p update the query time window, old:%" PRId64 " - %" PRId64 ", new:%" PRId64 " - %" PRId64 ", %s",
-  //             pReader, pCond->twindows[tWinIdx].skey, pCond->twindows[tWinIdx].ekey, pReader->window.skey,
-  //             pReader->window.ekey, pReader->idStr);
-  // }
-}
-
 static void limitOutputBufferSize(const SQueryTableDataCond* pCond, int32_t* capacity) {
   int32_t rowLen = 0;
   for (int32_t i = 0; i < pCond->numOfCols; ++i) {
@@ -405,21 +365,21 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, STsd
   pReader->type = pCond->type;
   pReader->window = updateQueryTimeWindow(pVnode->pTsdb, pCond->twindows);
 
-  // todo remove this
-  setQueryTimewindow(pReader, pCond, 0);
   ASSERT(pCond->numOfCols > 0);
 
   limitOutputBufferSize(pCond, &pReader->capacity);
 
   // allocate buffer in order to load data blocks from file
   SBlockLoadSuppInfo* pSup = &pReader->suppInfo;
-  pSup->pstatis = taosMemoryCalloc(pCond->numOfCols, sizeof(SColumnDataAgg));
+  pSup->pColAgg = taosArrayInit(4, sizeof(SColumnDataAgg));
   pSup->plist = taosMemoryCalloc(pCond->numOfCols, POINTER_BYTES);
-  if (pSup->pstatis == NULL || pSup->plist == NULL) {
+  if (pSup->pColAgg == NULL || pSup->plist == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
     goto _end;
   }
 
+  pSup->tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;
+
   pReader->pResBlock = createResBlock(pCond, pReader->capacity);
   if (pReader->pResBlock == NULL) {
     code = terrno;
@@ -920,200 +880,6 @@ _error:
 
 //   return midPos;
 // }
-// static int32_t mergeTwoRowFromMem(STsdbReader* pTsdbReadHandle, int32_t capacity, int32_t* curRow, STSRow* row1,
-//                                   STSRow* row2, int32_t numOfCols, uint64_t uid, STSchema* pSchema1, STSchema*
-//                                   pSchema2, bool update, TSKEY* lastRowKey) {
-// #if 1
-//   STSchema* pSchema;
-//   STSRow*   row;
-//   int16_t   colId;
-//   int16_t   offset;
-
-//   bool     isRow1DataRow = TD_IS_TP_ROW(row1);
-//   bool     isRow2DataRow;
-//   bool     isChosenRowDataRow;
-//   int32_t  chosen_itr;
-//   SCellVal sVal = {0};
-//   TSKEY    rowKey = TSKEY_INITIAL_VAL;
-//   int32_t  nResult = 0;
-//   int32_t  mergeOption = 0;  // 0 discard 1 overwrite 2 merge
-
-//   // the schema version info is embeded in STSRow
-//   int32_t numOfColsOfRow1 = 0;
-
-//   if (pSchema1 == NULL) {
-//     pSchema1 = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), uid, TD_ROW_SVER(row1));
-//   }
-
-// #ifdef TD_DEBUG_PRINT_ROW
-//   char   flags[70] = {0};
-//   STsdb* pTsdb = pTsdbReadHandle->rhelper.pRepo;
-//   snprintf(flags, 70, "%s:%d vgId:%d dir:%s row1%s=NULL,row2%s=NULL", __func__, __LINE__, TD_VID(pTsdb->pVnode),
-//            pTsdb->dir, row1 ? "!" : "", row2 ? "!" : "");
-//   tdSRowPrint(row1, pSchema1, flags);
-// #endif
-
-//   if (isRow1DataRow) {
-//     numOfColsOfRow1 = schemaNCols(pSchema1);
-//   } else {
-//     numOfColsOfRow1 = tdRowGetNCols(row1);
-//   }
-
-//   int32_t numOfColsOfRow2 = 0;
-//   if (row2) {
-//     isRow2DataRow = TD_IS_TP_ROW(row2);
-//     if (pSchema2 == NULL) {
-//       pSchema2 = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), uid, TD_ROW_SVER(row2));
-//     }
-//     if (isRow2DataRow) {
-//       numOfColsOfRow2 = schemaNCols(pSchema2);
-//     } else {
-//       numOfColsOfRow2 = tdRowGetNCols(row2);
-//     }
-//   }
-
-//   int32_t i = 0, j = 0, k = 0;
-//   while (i < numOfCols && (j < numOfColsOfRow1 || k < numOfColsOfRow2)) {
-//     SColumnInfoData* pColInfo = taosArrayGet(pTsdbReadHandle->pColumns, i);
-
-//     int32_t colIdOfRow1;
-//     if (j >= numOfColsOfRow1) {
-//       colIdOfRow1 = INT32_MAX;
-//     } else if (isRow1DataRow) {
-//       colIdOfRow1 = pSchema1->columns[j].colId;
-//     } else {
-//       colIdOfRow1 = tdKvRowColIdAt(row1, j);
-//     }
-
-//     int32_t colIdOfRow2;
-//     if (k >= numOfColsOfRow2) {
-//       colIdOfRow2 = INT32_MAX;
-//     } else if (isRow2DataRow) {
-//       colIdOfRow2 = pSchema2->columns[k].colId;
-//     } else {
-//       colIdOfRow2 = tdKvRowColIdAt(row2, k);
-//     }
-
-//     if (colIdOfRow1 < colIdOfRow2) {  // the most probability
-//       if (colIdOfRow1 < pColInfo->info.colId) {
-//         ++j;
-//         continue;
-//       }
-//       row = row1;
-//       pSchema = pSchema1;
-//       isChosenRowDataRow = isRow1DataRow;
-//       chosen_itr = j;
-//     } else if (colIdOfRow1 == colIdOfRow2) {
-//       if (colIdOfRow1 < pColInfo->info.colId) {
-//         ++j;
-//         ++k;
-//         continue;
-//       }
-//       row = row1;
-//       pSchema = pSchema1;
-//       isChosenRowDataRow = isRow1DataRow;
-//       chosen_itr = j;
-//     } else {
-//       if (colIdOfRow2 < pColInfo->info.colId) {
-//         ++k;
-//         continue;
-//       }
-//       row = row2;
-//       pSchema = pSchema2;
-//       chosen_itr = k;
-//       isChosenRowDataRow = isRow2DataRow;
-//     }
-
-//     if (isChosenRowDataRow) {
-//       colId = pSchema->columns[chosen_itr].colId;
-//       offset = pSchema->columns[chosen_itr].offset;
-//       // TODO: use STSRowIter
-//       tdSTpRowGetVal(row, colId, pSchema->columns[chosen_itr].type, pSchema->flen, offset, chosen_itr - 1, &sVal);
-//       if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
-//         rowKey = *(TSKEY*)sVal.val;
-//         if (rowKey != *lastRowKey) {
-//           mergeOption = 1;
-//           if (*lastRowKey != TSKEY_INITIAL_VAL) {
-//             ++(*curRow);
-//           }
-//           *lastRowKey = rowKey;
-//           ++nResult;
-//         } else if (update) {
-//           mergeOption = 2;
-//         } else {
-//           mergeOption = 0;
-//           break;
-//         }
-//       }
-//     } else {
-//       // TODO: use STSRowIter
-//       if (chosen_itr == 0) {
-//         colId = PRIMARYKEY_TIMESTAMP_COL_ID;
-//         tdSKvRowGetVal(row, PRIMARYKEY_TIMESTAMP_COL_ID, -1, -1, &sVal);
-//         rowKey = *(TSKEY*)sVal.val;
-//         if (rowKey != *lastRowKey) {
-//           mergeOption = 1;
-//           if (*lastRowKey != TSKEY_INITIAL_VAL) {
-//             ++(*curRow);
-//           }
-//           *lastRowKey = rowKey;
-//           ++nResult;
-//         } else if (update) {
-//           mergeOption = 2;
-//         } else {
-//           mergeOption = 0;
-//           break;
-//         }
-//       } else {
-//         SKvRowIdx* pColIdx = tdKvRowColIdxAt(row, chosen_itr - 1);
-//         colId = pColIdx->colId;
-//         offset = pColIdx->offset;
-//         tdSKvRowGetVal(row, colId, offset, chosen_itr - 1, &sVal);
-//       }
-//     }
-
-//     ASSERT(rowKey != TSKEY_INITIAL_VAL);
-
-//     if (colId == pColInfo->info.colId) {
-//       if (tdValTypeIsNorm(sVal.valType)) {
-//         colDataAppend(pColInfo, *curRow, sVal.val, false);
-//       } else if (tdValTypeIsNull(sVal.valType)) {
-//         colDataAppend(pColInfo, *curRow, NULL, true);
-//       } else if (tdValTypeIsNone(sVal.valType)) {
-//         // TODO: Set null if nothing append for this row
-//         if (mergeOption == 1) {
-//           colDataAppend(pColInfo, *curRow, NULL, true);
-//         }
-//       } else {
-//         ASSERT(0);
-//       }
-
-//       ++i;
-
-//       if (row == row1) {
-//         ++j;
-//       } else {
-//         ++k;
-//       }
-//     } else {
-//       if (mergeOption == 1) {
-//         colDataAppend(pColInfo, *curRow, NULL, true);
-//       }
-//       ++i;
-//     }
-//   }
-
-//   if (mergeOption == 1) {
-//     while (i < numOfCols) {  // the remain columns are all null data
-//       SColumnInfoData* pColInfo = taosArrayGet(pTsdbReadHandle->pColumns, i);
-//       colDataAppend(pColInfo, *curRow, NULL, true);
-//       ++i;
-//     }
-//   }
-
-//   return nResult;
-// #endif
-// }
 
 // static void doCheckGeneratedBlockRange(STsdbReader* pTsdbReadHandle) {
 //   SQueryFilePos* cur = &pTsdbReadHandle->cur;
@@ -1393,66 +1159,6 @@ _error:
 //             pTsdbReadHandle->idStr);
 // }
 
-// int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) {
-//   int    firstPos, lastPos, midPos = -1;
-//   int    numOfRows;
-//   TSKEY* keyList;
-
-//   if (num <= 0) return -1;
-
-//   keyList = (TSKEY*)pValue;
-//   firstPos = 0;
-//   lastPos = num - 1;
-
-//   if (order == TSDB_ORDER_DESC) {
-//     // find the first position which is smaller than the key
-//     while (1) {
-//       if (key >= keyList[lastPos]) return lastPos;
-//       if (key == keyList[firstPos]) return firstPos;
-//       if (key < keyList[firstPos]) return firstPos - 1;
-
-//       numOfRows = lastPos - firstPos + 1;
-//       midPos = (numOfRows >> 1) + firstPos;
-
-//       if (key < keyList[midPos]) {
-//         lastPos = midPos - 1;
-//       } else if (key > keyList[midPos]) {
-//         firstPos = midPos + 1;
-//       } else {
-//         break;
-//       }
-//     }
-
-//   } else {
-//     // find the first position which is bigger than the key
-//     while (1) {
-//       if (key <= keyList[firstPos]) return firstPos;
-//       if (key == keyList[lastPos]) return lastPos;
-
-//       if (key > keyList[lastPos]) {
-//         lastPos = lastPos + 1;
-//         if (lastPos >= num)
-//           return -1;
-//         else
-//           return lastPos;
-//       }
-
-//       numOfRows = lastPos - firstPos + 1;
-//       midPos = (numOfRows >> 1) + firstPos;
-
-//       if (key < keyList[midPos]) {
-//         lastPos = midPos - 1;
-//       } else if (key > keyList[midPos]) {
-//         firstPos = midPos + 1;
-//       } else {
-//         break;
-//       }
-//     }
-//   }
-
-//   return midPos;
-// }
-
 static void cleanupBlockOrderSupporter(SBlockOrderSupporter* pSup) {
   taosMemoryFreeClear(pSup->numOfBlocksPerTable);
   taosMemoryFreeClear(pSup->indexPerTable);
@@ -1710,29 +1416,60 @@ static bool keyOverlapFileBlock(TSDBKEY key, SBlock* pBlock, SVersionRange* pVer
          (pBlock->minVersion <= pVerRange->maxVer);
 }
 
+static bool overlapWithDelSkyline(STableBlockScanInfo* pBlockScanInfo, const SBlock* pBlock, int32_t order) {
+  if (pBlockScanInfo->delSkyline == NULL) {
+    return false;
+  }
+
+  TSDBKEY* pFirst = taosArrayGet(pBlockScanInfo->delSkyline, 0);
+  TSDBKEY* pLast  = taosArrayGetLast(pBlockScanInfo->delSkyline);
+
+  // ts is not overlap
+  if (pBlock->minKey.ts > pLast->ts || pBlock->maxKey.ts < pFirst->ts) {
+    return false;
+  }
+
+  int32_t step = ASCENDING_TRAVERSE(order)? 1:-1;
+
+  // version is not overlap
+  size_t num = taosArrayGetSize(pBlockScanInfo->delSkyline);
+  for(int32_t i = pBlockScanInfo->fileDelIndex; i < num; i += step) {
+    TSDBKEY* p = taosArrayGet(pBlockScanInfo->delSkyline, i);
+    if (p->ts >= pBlock->minKey.ts && p->ts <= pBlock->maxKey.ts) {
+      if (p->version >= pBlock->minVersion) {
+        return true;
+      }
+    } else if (p->ts > pBlock->maxKey.ts) {
+      return false;
+    }
+  }
+
+  ASSERT(0);
+  return false;
+}
+
 // 1. the version of all rows should be less than the endVersion
 // 2. current block should not overlap with next neighbor block
 // 3. current timestamp should not be overlap with each other
 // 4. output buffer should be large enough to hold all rows in current block
+// 5. delete info should not overlap with current block data
 static bool fileBlockShouldLoad(STsdbReader* pReader, SFileDataBlockInfo* pFBlock, SBlock* pBlock,
                                 STableBlockScanInfo* pScanInfo, TSDBKEY key) {
   int32_t neighborIndex = 0;
   SBlock* pNeighbor = getNeighborBlockOfSameTable(pFBlock, pScanInfo, &neighborIndex, pReader->order);
 
+  // overlap with neighbor
   bool overlapWithNeighbor = false;
   if (pNeighbor) {
     overlapWithNeighbor = overlapWithNeighborBlock(pBlock, pNeighbor, pReader->order);
   }
 
-  bool hasDup = false;
-  if (pBlock->nSubBlock == 1) {
-    hasDup = pBlock->hasDup;
-  } else {
-    hasDup = true;
-  }
+  // has duplicated ts of different version in this block
+  bool hasDup = (pBlock->nSubBlock == 1)? pBlock->hasDup:true;
+  bool overlapWithDel= overlapWithDelSkyline(pScanInfo, pBlock, pReader->order);
 
   return (overlapWithNeighbor || hasDup || dataBlockPartiallyRequired(&pReader->window, &pReader->verRange, pBlock) ||
-          keyOverlapFileBlock(key, pBlock, &pReader->verRange) || (pBlock->nRow > pReader->capacity));
+          keyOverlapFileBlock(key, pBlock, &pReader->verRange) || (pBlock->nRow > pReader->capacity) || overlapWithDel);
 }
 
 static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, int64_t endKey) {
@@ -1957,7 +1694,7 @@ static bool isValidFileBlockRow(SBlockData* pBlockData, SFileBlockDumpInfo* pDum
   }
 
   TSDBKEY k = {.ts = ts, .version = ver};
-  if (hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, &k)) {
+  if (hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, &k, pReader->order)) {
     return false;
   }
 
@@ -2486,41 +2223,104 @@ static SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond
 //   taosArrayPush(pTsdbReadHandle->pTableCheckInfo, &info);
 // }
 
-bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey) {
+bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32_t order) {
   ASSERT(pKey != NULL);
   if (pDelList == NULL) {
     return false;
   }
+  size_t num = taosArrayGetSize(pDelList);
+  bool asc = ASCENDING_TRAVERSE(order);
+  int32_t step = asc? 1:-1;
 
-  if (*index >= taosArrayGetSize(pDelList) - 1) {
-    TSDBKEY* last = taosArrayGetLast(pDelList);
-    if (pKey->ts > last->ts) {
-      return false;
-    } else if (pKey->ts == last->ts) {
-      size_t   size = taosArrayGetSize(pDelList);
-      TSDBKEY* prev = taosArrayGet(pDelList, size - 2);
-      if (prev->version >= pKey->version) {
-        return true;
-      } else {
+  if (asc) {
+    if (*index >= num - 1) {
+      TSDBKEY* last = taosArrayGetLast(pDelList);
+      ASSERT(pKey->ts >= last->ts);
+
+      if (pKey->ts > last->ts) {
         return false;
+      } else if (pKey->ts == last->ts) {
+        TSDBKEY* prev = taosArrayGet(pDelList, num - 2);
+        return (prev->version >= pKey->version);
       }
     } else {
-      ASSERT(0);
+      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);
+      TSDBKEY* pNext = taosArrayGet(pDelList, (*index) + 1);
+
+      if (pKey->ts < pCurrent->ts) {
+        return false;
+      }
+
+      if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version) {
+        return true;
+      }
+
+      while (pNext->ts <= pKey->ts && (*index) < num - 1) {
+        (*index) += 1;
+
+        if ((*index) < num - 1) {
+          pCurrent = taosArrayGet(pDelList, *index);
+          pNext = taosArrayGet(pDelList, (*index) + 1);
+
+          // it is not a consecutive deletion range, ignore it
+          if (pCurrent->version == 0 && pNext->version > 0) {
+            continue;
+          }
+
+          if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version) {
+            return true;
+          }
+        }
+      }
+
+      return false;
     }
   } else {
-    TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);
-    TSDBKEY* pNext = taosArrayGet(pDelList, (*index) + 1);
+    if (*index <= 0) {
+      TSDBKEY* pFirst = taosArrayGet(pDelList, 0);
 
-    if (pCurrent->ts <= pKey->ts && pNext->ts >= pKey->ts && pCurrent->version >= pKey->version) {
-      return true;
+      if (pKey->ts < pFirst->ts) {
+        return false;
+      } else if (pKey->ts == pFirst->ts) {
+        return pFirst->version >= pKey->version;
+      } else {
+        ASSERT(0);
+      }
     } else {
-      while (pNext->ts < pKey->ts && (*index) < taosArrayGetSize(pDelList) - 1) {
-        (*index) += 1;
+      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);
+      TSDBKEY* pPrev = taosArrayGet(pDelList, (*index) - 1);
+
+      if (pKey->ts > pCurrent->ts) {
+        return false;
+      }
+
+      if (pPrev->ts <= pKey->ts && pCurrent->ts >= pKey->ts && pPrev->version >= pKey->version) {
+        return true;
+      }
+
+      while (pPrev->ts >= pKey->ts && (*index) > 1) {
+        (*index) += step;
+
+        if ((*index) >= 1) {
+          pCurrent = taosArrayGet(pDelList, *index);
+          pPrev = taosArrayGet(pDelList, (*index) - 1);
+
+          // it is not a consecutive deletion range, ignore it
+          if (pCurrent->version > 0 && pPrev->version == 0) {
+            continue;
+          }
+
+          if (pPrev->ts <= pKey->ts && pCurrent->ts >= pKey->ts && pPrev->version >= pKey->version) {
+            return true;
+          }
+        }
       }
 
       return false;
     }
   }
+
+  return false;
 }
 
 TSDBROW* getValidRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader) {
@@ -2537,7 +2337,7 @@ TSDBROW* getValidRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pRea
 
   // it is a valid data version
   if ((key.version <= pReader->verRange.maxVer && key.version >= pReader->verRange.minVer) &&
-      (!hasBeenDropped(pDelList, &pIter->index, &key))) {
+      (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order))) {
     return pRow;
   }
 
@@ -2556,7 +2356,7 @@ TSDBROW* getValidRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pRea
     }
 
     if (key.version <= pReader->verRange.maxVer && key.version >= pReader->verRange.minVer &&
-        (!hasBeenDropped(pDelList, &pIter->index, &key))) {
+        (!hasBeenDropped(pDelList, &pIter->index, &key, pReader->order))) {
       return pRow;
     }
   }
@@ -2908,162 +2708,6 @@ int32_t tsdbGetStbIdList(SMeta* pMeta, int64_t suid, SArray* list) {
   return TSDB_CODE_SUCCESS;
 }
 
-// static void destroyHelper(void* param) {
-//   if (param == NULL) {
-//     return;
-//   }
-
-//   //  tQueryInfo* pInfo = (tQueryInfo*)param;
-//   //  if (pInfo->optr != TSDB_RELATION_IN) {
-//   //    taosMemoryFreeClear(pInfo->q);
-//   //  } else {
-//   //    taosHashCleanup((SHashObj *)(pInfo->q));
-//   //  }
-
-//   taosMemoryFree(param);
-// }
-
-// #define TSDB_PREV_ROW 0x1
-// #define TSDB_NEXT_ROW 0x2
-
-// static bool loadBlockOfActiveTable(STsdbReader* pTsdbReadHandle) {
-//   if (pTsdbReadHandle->checkFiles) {
-//     // check if the query range overlaps with the file data block
-//     bool exists = true;
-
-//     int32_t code = buildBlockFromFiles(pTsdbReadHandle, &exists);
-//     if (code != TSDB_CODE_SUCCESS) {
-//       pTsdbReadHandle->checkFiles = false;
-//       return false;
-//     }
-
-//     if (exists) {
-//       tsdbRetrieveDataBlock((STsdbReader**)pTsdbReadHandle, NULL);
-//       if (pTsdbReadHandle->currentLoadExternalRows && pTsdbReadHandle->window.skey == pTsdbReadHandle->window.ekey) {
-//         SColumnInfoData* pColInfo = taosArrayGet(pTsdbReadHandle->pColumns, 0);
-//         assert(*(int64_t*)pColInfo->pData == pTsdbReadHandle->window.skey);
-//       }
-
-//       pTsdbReadHandle->currentLoadExternalRows = false;  // clear the flag, since the exact matched row is found.
-//       return exists;
-//     }
-
-//     pTsdbReadHandle->checkFiles = false;
-//   }
-
-//   if (hasMoreDataInCache(pTsdbReadHandle)) {
-//     pTsdbReadHandle->currentLoadExternalRows = false;
-//     return true;
-//   }
-
-//   // current result is empty
-//   if (pTsdbReadHandle->currentLoadExternalRows && pTsdbReadHandle->window.skey == pTsdbReadHandle->window.ekey &&
-//       pTsdbReadHandle->cur.rows == 0) {
-//     //    SMemTable* pMemRef = pTsdbReadHandle->pMemTable;
-
-//     //    doGetExternalRow(pTsdbReadHandle, TSDB_PREV_ROW, pMemRef);
-//     //    doGetExternalRow(pTsdbReadHandle, TSDB_NEXT_ROW, pMemRef);
-
-//     bool result = tsdbGetExternalRow(pTsdbReadHandle);
-
-//     //    pTsdbReadHandle->prev = doFreeColumnInfoData(pTsdbReadHandle->prev);
-//     //    pTsdbReadHandle->next = doFreeColumnInfoData(pTsdbReadHandle->next);
-//     pTsdbReadHandle->currentLoadExternalRows = false;
-
-//     return result;
-//   }
-
-//   return false;
-// }
-
-// static bool loadDataBlockFromTableSeq(STsdbReader* pTsdbReadHandle) {
-//   size_t numOfTables = taosArrayGetSize(pTsdbReadHandle->pTableCheckInfo);
-//   assert(numOfTables > 0);
-
-//   int64_t stime = taosGetTimestampUs();
-
-//   while (pTsdbReadHandle->activeIndex < numOfTables) {
-//     if (loadBlockOfActiveTable(pTsdbReadHandle)) {
-//       return true;
-//     }
-
-//     STableBlockScanInfo* pCheckInfo = taosArrayGet(pTsdbReadHandle->pTableCheckInfo, pTsdbReadHandle->activeIndex);
-//     pCheckInfo->numOfBlocks = 0;
-
-//     pTsdbReadHandle->activeIndex += 1;
-//     pTsdbReadHandle->locateStart = false;
-//     pTsdbReadHandle->checkFiles = true;
-//     pTsdbReadHandle->cur.rows = 0;
-//     pTsdbReadHandle->currentLoadExternalRows = pTsdbReadHandle->loadExternalRow;
-
-//     terrno = TSDB_CODE_SUCCESS;
-
-//     int64_t elapsedTime = taosGetTimestampUs() - stime;
-//     pTsdbReadHandle->cost.checkForNextTime += elapsedTime;
-//   }
-
-//   return false;
-// }
-
-// bool tsdbGetExternalRow(STsdbReader* pHandle) {
-//   STsdbReader*   pTsdbReadHandle = (STsdbReader*)pHandle;
-//   SQueryFilePos* cur = &pTsdbReadHandle->cur;
-
-//   cur->fid = INT32_MIN;
-//   cur->mixBlock = true;
-//   if (pTsdbReadHandle->prev == NULL || pTsdbReadHandle->next == NULL) {
-//     cur->rows = 0;
-//     return false;
-//   }
-
-//   int32_t numOfCols = (int32_t)QH_GET_NUM_OF_COLS(pTsdbReadHandle);
-//   for (int32_t i = 0; i < numOfCols; ++i) {
-//     SColumnInfoData* pColInfoData = taosArrayGet(pTsdbReadHandle->pColumns, i);
-//     SColumnInfoData* first = taosArrayGet(pTsdbReadHandle->prev, i);
-
-//     memcpy(pColInfoData->pData, first->pData, pColInfoData->info.bytes);
-
-//     SColumnInfoData* sec = taosArrayGet(pTsdbReadHandle->next, i);
-//     memcpy(((char*)pColInfoData->pData) + pColInfoData->info.bytes, sec->pData, pColInfoData->info.bytes);
-
-//     if (i == 0 && pColInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
-//       cur->win.skey = *(TSKEY*)pColInfoData->pData;
-//       cur->win.ekey = *(TSKEY*)(((char*)pColInfoData->pData) + TSDB_KEYSIZE);
-//     }
-//   }
-
-//   cur->rows = 2;
-//   return true;
-// }
-
-// static void* doFreeColumnInfoData(SArray* pColumnInfoData) {
-//   if (pColumnInfoData == NULL) {
-//     return NULL;
-//   }
-
-//   size_t cols = taosArrayGetSize(pColumnInfoData);
-//   for (int32_t i = 0; i < cols; ++i) {
-//     SColumnInfoData* pColInfo = taosArrayGet(pColumnInfoData, i);
-//     colDataDestroy(pColInfo);
-//   }
-
-//   taosArrayDestroy(pColumnInfoData);
-//   return NULL;
-// }
-
-// static void* destroyTableCheckInfo(SArray* pTableCheckInfo) {
-//   size_t size = taosArrayGetSize(pTableCheckInfo);
-//   for (int32_t i = 0; i < size; ++i) {
-//     STableBlockScanInfo* p = taosArrayGet(pTableCheckInfo, i);
-//     destroyTableMemIterator(p);
-
-//     taosMemoryFreeClear(p->pCompInfo);
-//   }
-
-//   taosArrayDestroy(pTableCheckInfo);
-//   return NULL;
-// }
-
 // ====================================== EXPOSED APIs ======================================
 int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTableList, STsdbReader** ppReader,
                        const char* idstr) {
@@ -3126,16 +2770,11 @@ void tsdbReaderClose(STsdbReader* pReader) {
   }
 
   blockDataDestroy(pReader->pResBlock);
-
-  taosMemoryFreeClear(pReader->suppInfo.pstatis);
   taosMemoryFreeClear(pReader->suppInfo.plist);
+
+  taosArrayDestroy(pReader->suppInfo.pColAgg);
   taosMemoryFree(pReader->suppInfo.slotIds);
 
-  if (!isEmptyQueryTimeWindow(&pReader->window)) {
-    //    tsdbMayUnTakeMemSnapshot(pTsdbReadHandle);
-  } else {
-    ASSERT(pReader->status.pTableMap == NULL);
-  }
 #if 0
 //   if (pReader->status.pTableScanInfo != NULL) {
 //     pReader->status.pTableScanInfo = destroyTableCheckInfo(pReader->status.pTableScanInfo);
@@ -3154,7 +2793,7 @@ void tsdbReaderClose(STsdbReader* pReader) {
 
   tsdbDebug("%p :io-cost summary: head-file read cnt:%" PRIu64 ", head-file time:%" PRIu64 " us, statis-info:%" PRId64
             " us, datablock:%" PRId64 " us, check data:%" PRId64 " us, %s",
-            pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->statisInfoLoadTime, pCost->blockLoadTime,
+            pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->smaLoadTime, pCost->blockLoadTime,
             pCost->checkForNextTime, pReader->idStr);
 
   taosMemoryFree(pReader->idStr);
@@ -3207,77 +2846,76 @@ void tsdbRetrieveDataBlockInfo(STsdbReader* pReader, SDataBlockInfo* pDataBlockI
   pDataBlockInfo->window = pReader->pResBlock->info.window;
 }
 
-int32_t tsdbRetrieveDataBlockStatisInfo(STsdbReader* pReader, SColumnDataAgg*** pBlockStatis, bool* allHave) {
+int32_t tsdbRetrieveDatablockSMA(STsdbReader* pReader, SColumnDataAgg*** pBlockStatis, bool* allHave) {
   int32_t code = 0;
   *allHave = false;
 
+  // there is no statistics data for composed block
   if (pReader->status.composedDataBlock) {
     *pBlockStatis = NULL;
     return TSDB_CODE_SUCCESS;
   }
 
-  // SFileBlockInfo* pBlockInfo = &pReader->pDataBlockInfo[c->slot];
-  // assert((c->slot >= 0 && c->slot < pReader->numOfBlocks) || ((c->slot == pReader->numOfBlocks) && (c->slot == 0)));
-
-  // // file block with sub-blocks has no statistics data
-  // if (pBlockInfo->compBlock->numOfSubBlocks > 1) {
-  //   *pBlockStatis = NULL;
-  //   return TSDB_CODE_SUCCESS;
-  // }
-
-  // int64_t stime = taosGetTimestampUs();
-  // int     statisStatus = tsdbLoadBlockStatis(&pReader->rhelper, pBlockInfo->compBlock);
-  // if (statisStatus < TSDB_STATIS_OK) {
-  //   return terrno;
-  // } else if (statisStatus > TSDB_STATIS_OK) {
-  //   *pBlockStatis = NULL;
-  //   return TSDB_CODE_SUCCESS;
-  // }
-
-  // tsdbDebug("vgId:%d, succeed to load block statis part for uid %" PRIu64, REPO_ID(pReader->pTsdb),
-  //           TSDB_READ_TABLE_UID(&pReader->rhelper));
-
-  // int16_t* colIds = pReader->suppInfo.defaultLoadColumn->pData;
-
-  // size_t numOfCols = QH_GET_NUM_OF_COLS(pReader);
-  // memset(pReader->suppInfo.plist, 0, numOfCols * POINTER_BYTES);
-  // memset(pReader->suppInfo.pstatis, 0, numOfCols * sizeof(SColumnDataAgg));
-
-  // for (int32_t i = 0; i < numOfCols; ++i) {
-  //   pReader->suppInfo.pstatis[i].colId = colIds[i];
-  // }
-
-  // *allHave = true;
-  // tsdbGetBlockStatis(&pReader->rhelper, pReader->suppInfo.pstatis, (int)numOfCols, pBlockInfo->compBlock);
-
-  // // always load the first primary timestamp column data
-  // SColumnDataAgg* pPrimaryColStatis = &pReader->suppInfo.pstatis[0];
-  // assert(pPrimaryColStatis->colId == PRIMARYKEY_TIMESTAMP_COL_ID);
-
-  // pPrimaryColStatis->numOfNull = 0;
-  // pPrimaryColStatis->min = pBlockInfo->compBlock->minKey.ts;
-  // pPrimaryColStatis->max = pBlockInfo->compBlock->maxKey.ts;
-  // pReader->suppInfo.plist[0] = &pReader->suppInfo.pstatis[0];
-
-  // // update the number of NULL data rows
-  // int32_t* slotIds = pReader->suppInfo.slotIds;
-  // for (int32_t i = 1; i < numOfCols; ++i) {
-  //   ASSERT(colIds[i] == pReader->pSchema->columns[slotIds[i]].colId);
-  //   if (IS_BSMA_ON(&(pReader->pSchema->columns[slotIds[i]]))) {
-  //     if (pReader->suppInfo.pstatis[i].numOfNull == -1) {  // set the column data are all NULL
-  //       pReader->suppInfo.pstatis[i].numOfNull = pBlockInfo->compBlock->numOfRows;
-  //     }
-
-  //     pReader->suppInfo.plist[i] = &pReader->suppInfo.pstatis[i];
-  //   } else {
-  //     *allHave = false;
-  //   }
-  // }
-
-  // int64_t elapsed = taosGetTimestampUs() - stime;
-  // pReader->cost.statisInfoLoadTime += elapsed;
-
-  // *pBlockStatis = pReader->suppInfo.plist;
+  SFileDataBlockInfo*  pFBlock = getCurrentBlockInfo(&pReader->status.blockIter);
+  STableBlockScanInfo* pBlockScanInfo = taosHashGet(pReader->status.pTableMap, &pFBlock->uid, sizeof(pFBlock->uid));
+  SBlock*              pBlock = taosArrayGet(pBlockScanInfo->pBlockList, pFBlock->tbBlockIdx);
+
+  int64_t stime = taosGetTimestampUs();
+
+  SBlockLoadSuppInfo* pSup = &pReader->suppInfo;
+
+  if (tBlockHasSma(pBlock)) {
+    code = tsdbReadBlockSma(pReader->pFileReader, pBlock, pSup->pColAgg, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      tsdbDebug("vgId:%d, failed to load block SMA for uid %" PRIu64 ", code:%s, %s", 0, pFBlock->uid, tstrerror(code),
+                pReader->idStr);
+      return code;
+    }
+  } else {
+    *pBlockStatis = NULL;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  *allHave = true;
+
+  // always load the first primary timestamp column data
+  SColumnDataAgg* pTsAgg = &pSup->tsColAgg;
+
+  pTsAgg->numOfNull = 0;
+  pTsAgg->colId = PRIMARYKEY_TIMESTAMP_COL_ID;
+  pTsAgg->min = pReader->pResBlock->info.window.skey;
+  pTsAgg->max = pReader->pResBlock->info.window.ekey;
+  pSup->plist[0] = pTsAgg;
+
+  // update the number of NULL data rows
+  size_t numOfCols = blockDataGetNumOfCols(pReader->pResBlock);
+
+  int32_t i = 0, j = 0;
+  while (j < numOfCols && i < taosArrayGetSize(pSup->pColAgg)) {
+    SColumnDataAgg* pAgg = taosArrayGet(pSup->pColAgg, i);
+    if (pAgg->colId == pSup->colIds[j]) {
+      if (IS_BSMA_ON(&(pReader->pSchema->columns[i]))) {
+        pSup->plist[j] = pAgg;
+      } else {
+        *allHave = false;
+      }
+      i += 1;
+      j += 1;
+    } else if (pAgg->colId < pSup->colIds[j]) {
+      i += 1;
+    } else if (pSup->colIds[j] < pAgg->colId) {
+      j += 1;
+    }
+  }
+
+  int64_t elapsed = taosGetTimestampUs() - stime;
+  pReader->cost.smaLoadTime += elapsed;
+
+  *pBlockStatis = pSup->plist;
+
+  tsdbDebug("vgId:%d, succeed to load block SMA for uid %" PRIu64 ", elapsed time:%" PRId64 "us, %s", 0, pFBlock->uid,
+            elapsed, pReader->idStr);
+
   return code;
 }
 
@@ -3312,19 +2950,19 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond, int32_
     return TSDB_CODE_SUCCESS;
   }
 
-  setQueryTimewindow(pReader, pCond, tWinIdx);
-
-  pReader->order = pCond->order;
-  pReader->type = BLOCK_LOAD_OFFSET_ORDER;
+  pReader->order               = pCond->order;
+  pReader->type                = BLOCK_LOAD_OFFSET_ORDER;
   pReader->status.loadFromFile = true;
   pReader->status.pTableIter = NULL;
 
   pReader->window = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows[tWinIdx]);
 
   // allocate buffer in order to load data blocks from file
-  memset(pReader->suppInfo.pstatis, 0, sizeof(SColumnDataAgg));
+  memset(&pReader->suppInfo.tsColAgg, 0, sizeof(SColumnDataAgg));
   memset(pReader->suppInfo.plist, 0, POINTER_BYTES);
 
+  pReader->suppInfo.tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;
+
   // todo set the correct numOfTables
   int32_t         numOfTables = 1;
   SDataBlockIter* pBlockIter = &pReader->status.blockIter;
@@ -3350,114 +2988,80 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond, int32_
   return code;
 }
 
-int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTableBlockInfo) {
-  int32_t code = 0;
-  // pTableBlockInfo->totalSize = 0;
-  // pTableBlockInfo->totalRows = 0;
-
-  // STsdbFS* pFileHandle = REPO_FS(pReader->pTsdb);
-
-  // // find the start data block in file
-  // pReader->locateStart = true;
-  // STsdbKeepCfg* pCfg = REPO_KEEP_CFG(pReader->pTsdb);
-  // int32_t       fid = getFileIdFromKey(pReader->window.skey, pCfg->days, pCfg->precision);
-
-  // tsdbRLockFS(pFileHandle);
-  // tsdbFSIterInit(&pReader->fileIter, pFileHandle, pReader->order);
-  // tsdbFSIterSeek(&pReader->fileIter, fid);
-  // tsdbUnLockFS(pFileHandle);
-
-  // STsdbCfg* pc = REPO_CFG(pReader->pTsdb);
-  // pTableBlockInfo->defMinRows = pc->minRows;
-  // pTableBlockInfo->defMaxRows = pc->maxRows;
-
-  // int32_t bucketRange = ceil((pc->maxRows - pc->minRows) / 20.0);
-
-  // pTableBlockInfo->numOfFiles += 1;
+static int32_t getBucketIndex(int32_t startRow, int32_t bucketRange, int32_t numOfRows) {
+  return (numOfRows - startRow) / bucketRange;
+}
 
-  // int32_t     code = TSDB_CODE_SUCCESS;
-  // int32_t     numOfBlocks = 0;
-  // int32_t     numOfTables = (int32_t)taosArrayGetSize(pReader->pTableCheckInfo);
-  // int         defaultRows = 4096;
-  // STimeWindow win = TSWINDOW_INITIALIZER;
+int32_t tsdbGetFileBlocksDistInfo(STsdbReader* pReader, STableBlockDistInfo* pTableBlockInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  pTableBlockInfo->totalSize = 0;
+  pTableBlockInfo->totalRows = 0;
 
-  // while (true) {
-  //   numOfBlocks = 0;
-  //   tsdbRLockFS(REPO_FS(pReader->pTsdb));
+  // find the start data block in file
+  SReaderStatus* pStatus = &pReader->status;
 
-  //   if ((pReader->pFileGroup = tsdbFSIterNext(&pReader->fileIter)) == NULL) {
-  //     tsdbUnLockFS(REPO_FS(pReader->pTsdb));
-  //     break;
-  //   }
+  STsdbCfg* pc = &pReader->pTsdb->pVnode->config.tsdbCfg;
+  pTableBlockInfo->defMinRows = pc->minRows;
+  pTableBlockInfo->defMaxRows = pc->maxRows;
 
-  //   tsdbGetFidKeyRange(pCfg->days, pCfg->precision, pReader->pFileGroup->fid, &win.skey, &win.ekey);
+  int32_t bucketRange = ceil((pc->maxRows - pc->minRows) / 20.0);
 
-  //   // current file are not overlapped with query time window, ignore remain files
-  //   if ((win.skey > pReader->window.ekey) /* || (!ascTraverse && win.ekey < pTsdbReadHandle->window.ekey)*/) {
-  //     tsdbUnLockFS(REPO_FS(pReader->pTsdb));
-  //     tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, %s", pReader,
-  //               pReader->window.skey, pReader->window.ekey, pReader->idStr);
-  //     pReader->pFileGroup = NULL;
-  //     break;
-  //   }
+  pTableBlockInfo->numOfFiles += 1;
 
-  //   pTableBlockInfo->numOfFiles += 1;
-  //   if (tsdbSetAndOpenReadFSet(&pReader->rhelper, pReader->pFileGroup) < 0) {
-  //     tsdbUnLockFS(REPO_FS(pReader->pTsdb));
-  //     code = terrno;
-  //     break;
-  //   }
+  int32_t numOfTables = (int32_t)taosHashGetSize(pStatus->pTableMap);
+  int     defaultRows = 4096;
 
-  //   tsdbUnLockFS(REPO_FS(pReader->pTsdb));
+  SDataBlockIter* pBlockIter = &pStatus->blockIter;
+  pTableBlockInfo->numOfFiles += pStatus->fileIter.numOfFiles;
+  pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;
 
-  //   if (tsdbLoadBlockIdx(&pReader->rhelper) < 0) {
-  //     code = terrno;
-  //     break;
-  //   }
+  pTableBlockInfo->numOfTables = numOfTables;
+  bool hasNext = true;
 
-  //   if ((code = getFileCompInfo(pReader, &numOfBlocks)) != TSDB_CODE_SUCCESS) {
-  //     break;
-  //   }
+  while (true) {
+    if (hasNext) {
+      SFileDataBlockInfo*  pFBlock = getCurrentBlockInfo(pBlockIter);
+      STableBlockScanInfo* pScanInfo = taosHashGet(pStatus->pTableMap, &pFBlock->uid, sizeof(pFBlock->uid));
+      SBlock*              pBlock = taosArrayGet(pScanInfo->pBlockList, pFBlock->tbBlockIdx);
 
-  //   tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %s", pReader, numOfBlocks, numOfTables,
-  //             pReader->pFileGroup->fid, pReader->idStr);
+      int32_t numOfRows = pBlock->nRow;
+      pTableBlockInfo->totalRows += numOfRows;
 
-  //   if (numOfBlocks == 0) {
-  //     continue;
-  //   }
+      if (numOfRows > pTableBlockInfo->maxRows) {
+        pTableBlockInfo->maxRows = numOfRows;
+      }
 
-  //   pTableBlockInfo->numOfBlocks += numOfBlocks;
+      if (numOfRows < pTableBlockInfo->minRows) {
+        pTableBlockInfo->minRows = numOfRows;
+      }
 
-  //   for (int32_t i = 0; i < numOfTables; ++i) {
-  //     STableBlockScanInfo* pCheckInfo = taosArrayGet(pReader->pTableCheckInfo, i);
+      if (numOfRows < defaultRows) {
+        pTableBlockInfo->numOfSmallBlocks += 1;
+      }
 
-  //     SBlock* pBlock = pCheckInfo->pCompInfo->blocks;
+      int32_t bucketIndex = getBucketIndex(pTableBlockInfo->defMinRows, bucketRange, numOfRows);
+      pTableBlockInfo->blockRowsHisto[bucketIndex]++;
 
-  //     for (int32_t j = 0; j < pCheckInfo->numOfBlocks; ++j) {
-  //       pTableBlockInfo->totalSize += pBlock[j].len;
+      hasNext = blockIteratorNext(&pStatus->blockIter);
 
-  //       int32_t numOfRows = pBlock[j].numOfRows;
-  //       pTableBlockInfo->totalRows += numOfRows;
+    } else {
+      code = initForFirstBlockInFile(pReader, pBlockIter);
+      if ((code != TSDB_CODE_SUCCESS) || (pReader->status.loadFromFile == false)) {
+        break;
+      }
 
-  //       if (numOfRows > pTableBlockInfo->maxRows) {
-  //         pTableBlockInfo->maxRows = numOfRows;
-  //       }
+      pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;
+    }
 
-  //       if (numOfRows < pTableBlockInfo->minRows) {
-  //         pTableBlockInfo->minRows = numOfRows;
-  //       }
+/*
+    hasNext = blockIteratorNext(&pStatus->blockIter);
+*/
 
-  //       if (numOfRows < defaultRows) {
-  //         pTableBlockInfo->numOfSmallBlocks += 1;
-  //       }
 
-  //       int32_t bucketIndex = getBucketIndex(pTableBlockInfo->defMinRows, bucketRange, numOfRows);
-  //       pTableBlockInfo->blockRowsHisto[bucketIndex]++;
-  //     }
-  //   }
-  // }
+//         tsdbDebug("%p %d blocks found in file for %d table(s), fid:%d, %s", pReader, numOfBlocks, numOfTables,
+//                   pReader->pFileGroup->fid, pReader->idStr);
+  }
 
-  // pTableBlockInfo->numOfTables = numOfTables;
   return code;
 }
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbReadImpl.c b/source/dnode/vnode/src/tsdb/tsdbReadImpl.c
deleted file mode 100644
index fe0d3a1b6f093a64e595c85f6ba97fecee3a5200..0000000000000000000000000000000000000000
--- a/source/dnode/vnode/src/tsdb/tsdbReadImpl.c
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * 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 "tsdb.h"
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index 2bd62348c9b4f69637001e446fd9d66a0e7e9a9f..a331f88e61523003187850c47c593b28f94b817a 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -969,6 +969,8 @@ int32_t tsdbReadColData(SDataFReader *pReader, SBlockIdx *pBlockIdx, SBlock *pBl
     SBlockData *pBlockData1 = &(SBlockData){0};
     SBlockData *pBlockData2 = &(SBlockData){0};
 
+    tBlockDataInit(pBlockData1);
+    tBlockDataInit(pBlockData2);
     for (int32_t iSubBlock = 1; iSubBlock < pBlock->nSubBlock; iSubBlock++) {
       code = tsdbReadSubColData(pReader, pBlockIdx, pBlock, iSubBlock, aColId, nCol, pBlockData1, ppBuf1, ppBuf2);
       if (code) goto _err;
@@ -1106,6 +1108,8 @@ int32_t tsdbReadBlockData(SDataFReader *pReader, SBlockIdx *pBlockIdx, SBlock *p
     SBlockData *pBlockData1 = &(SBlockData){0};
     SBlockData *pBlockData2 = &(SBlockData){0};
 
+    tBlockDataInit(pBlockData1);
+    tBlockDataInit(pBlockData2);
     for (iSubBlock = 1; iSubBlock < pBlock->nSubBlock; iSubBlock++) {
       code = tsdbReadSubBlockData(pReader, pBlockIdx, pBlock, iSubBlock, pBlockData1, ppBuf1, ppBuf2);
       if (code) {
@@ -1152,7 +1156,7 @@ _err:
 int32_t tsdbReadBlockSma(SDataFReader *pReader, SBlock *pBlock, SArray *aColumnDataAgg, uint8_t **ppBuf) {
   int32_t   code = 0;
   TdFilePtr pFD = pReader->pSmaFD;
-  int64_t   offset = pBlock->aSubBlock[0].offset;
+  int64_t   offset = pBlock->aSubBlock[0].sOffset;
   int64_t   size = pBlock->aSubBlock[0].nSma * sizeof(SColumnDataAgg) + sizeof(TSCKSUM);
   uint8_t  *pBuf = NULL;
   int64_t   n;
@@ -1175,10 +1179,13 @@ int32_t tsdbReadBlockSma(SDataFReader *pReader, SBlock *pBlock, SArray *aColumnD
   if (n < 0) {
     code = TAOS_SYSTEM_ERROR(errno);
     goto _err;
+  } else if (n < size) {
+    code = TSDB_CODE_FILE_CORRUPTED;
+    goto _err;
   }
 
   // check
-  if (!taosCheckChecksumWhole(NULL, size)) {
+  if (!taosCheckChecksumWhole(*ppBuf, size)) {
     code = TSDB_CODE_FILE_CORRUPTED;
     goto _err;
   }
diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c
index f906ef1b54e72e5b0a229bcce3f6842e120c31ce..ed8bdc17a50d9f132a0b9651cc4143369e632b57 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c
@@ -821,16 +821,20 @@ int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) {
   int32_t code = 0;
   int32_t size;
 
+  ASSERT(pColDataSrc->nVal > 0);
+
   pColDataDest->cid = pColDataSrc->cid;
   pColDataDest->type = pColDataSrc->type;
   pColDataDest->smaOn = pColDataSrc->smaOn;
   pColDataDest->nVal = pColDataSrc->nVal;
   pColDataDest->flag = pColDataSrc->flag;
 
-  size = BIT2_SIZE(pColDataSrc->nVal);
-  code = tRealloc(&pColDataDest->pBitMap, size);
-  if (code) goto _exit;
-  memcpy(pColDataDest->pBitMap, pColDataSrc->pBitMap, size);
+  if (pColDataSrc->flag != HAS_NONE && pColDataSrc->flag != HAS_NULL && pColDataSrc->flag != HAS_VALUE) {
+    size = BIT2_SIZE(pColDataSrc->nVal);
+    code = tRealloc(&pColDataDest->pBitMap, size);
+    if (code) goto _exit;
+    memcpy(pColDataDest->pBitMap, pColDataSrc->pBitMap, size);
+  }
 
   if (IS_VAR_DATA_TYPE(pColDataDest->type)) {
     size = sizeof(int32_t) * pColDataSrc->nVal;
@@ -1230,10 +1234,26 @@ void tsdbCalcColDataSMA(SColData *pColData, SColumnDataAgg *pColAgg) {
           break;
         case TSDB_DATA_TYPE_SMALLINT:
           break;
-        case TSDB_DATA_TYPE_INT:
+        case TSDB_DATA_TYPE_INT: {
+          pColAgg->sum += colVal.value.i32;
+          if (pColAgg->min > colVal.value.i32) {
+            pColAgg->min = colVal.value.i32;
+          }
+          if (pColAgg->max < colVal.value.i32) {
+            pColAgg->max = colVal.value.i32;
+          }
           break;
-        case TSDB_DATA_TYPE_BIGINT:
+        }
+        case TSDB_DATA_TYPE_BIGINT: {
+          pColAgg->sum += colVal.value.i64;
+          if (pColAgg->min > colVal.value.i64) {
+            pColAgg->min = colVal.value.i64;
+          }
+          if (pColAgg->max < colVal.value.i64) {
+            pColAgg->max = colVal.value.i64;
+          }
           break;
+        }
         case TSDB_DATA_TYPE_FLOAT:
           break;
         case TSDB_DATA_TYPE_DOUBLE:
diff --git a/source/dnode/vnode/src/vnd/vnodeStateMgr.c b/source/dnode/vnode/src/vnd/vnodeStateMgr.c
deleted file mode 100644
index 6dea4a4e57392be988126c579648f39a8270b9bf..0000000000000000000000000000000000000000
--- a/source/dnode/vnode/src/vnd/vnodeStateMgr.c
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * 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/>.
- */
\ No newline at end of file
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 105bf1476dc4663415b9e575f6d7361ee1b7923d..348806992551343edc76d60b2fd5d766c52f2f39 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -365,7 +365,7 @@ typedef struct SStreamScanInfo {
   int32_t         blockType;        // current block type
   int32_t         validBlockIndex;  // Is current data has returned?
   uint64_t        numOfExec;        // execution times
-  void*           streamReader;// stream block reader handle
+  STqReader*           tqReader;
 
   int32_t         tsArrayIndex;
   SArray*         tsArray;
@@ -383,6 +383,11 @@ typedef struct SStreamScanInfo {
   SSDataBlock*    pPullDataRes;             // pull data SSDataBlock
   SSDataBlock*    pDeleteDataRes;             // delete data SSDataBlock
   int32_t         deleteDataIndex;
+
+  // status for tmq
+  //SSchemaWrapper schema;
+  STqOffset offset;
+
 } SStreamScanInfo;
 
 typedef struct SSysTableScanInfo {
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 0155cdd416f29f310c7a1d99ef6beb2bf14d3c66..a83565cbe0553d823f79e6787d2f9ee05cd598f9 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -45,7 +45,7 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
     pInfo->blockType = type;
 
     if (type == STREAM_INPUT__DATA_SUBMIT) {
-      if (tqReadHandleSetMsg(pInfo->streamReader, input, 0) < 0) {
+      if (tqReaderSetDataMsg(pInfo->tqReader, input, 0) < 0) {
         qError("submit msg messed up when initing stream block, %s" PRIx64, id);
         return TSDB_CODE_QRY_APP_ERROR;
       }
@@ -105,7 +105,7 @@ int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numO
   return code;
 }
 
-qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle) {
+qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers) {
   if (msg == NULL) {
     return NULL;
   }
@@ -120,7 +120,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle) {
   }
 
   qTaskInfo_t pTaskInfo = NULL;
-  code = qCreateExecTask(streamReadHandle, 0, 0, plan, &pTaskInfo, NULL, NULL, OPTR_EXEC_MODEL_STREAM);
+  code = qCreateExecTask(readers, 0, 0, plan, &pTaskInfo, NULL, NULL, OPTR_EXEC_MODEL_STREAM);
   if (code != TSDB_CODE_SUCCESS) {
     // TODO: destroy SSubplan & pTaskInfo
     terrno = code;
@@ -174,11 +174,11 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, const SArray* tableIdList, bo
     SArray* qa = filterQualifiedChildTables(pScanInfo, tableIdList);
 
     qDebug(" %d qualified child tables added into stream scanner", (int32_t)taosArrayGetSize(qa));
-    code = tqReadHandleAddTbUidList(pScanInfo->streamReader, qa);
+    code = tqReaderAddTbUidList(pScanInfo->tqReader, qa);
     taosArrayDestroy(qa);
   } else {  // remove the table id in current list
     qDebug(" %d remove child tables from the stream scanner", (int32_t)taosArrayGetSize(tableIdList));
-    code = tqReadHandleRemoveTbUidList(pScanInfo->streamReader, tableIdList);
+    code = tqReaderRemoveTbUidList(pScanInfo->tqReader, tableIdList);
   }
 
   return code;
diff --git a/source/libs/executor/src/executorMain.c b/source/libs/executor/src/executorMain.c
index 7f84b4c1743e49c8cd6c42d452c970bc5ecb49a7..d5e546f466b868fc8373d245c1888f2ebcb0f730 100644
--- a/source/libs/executor/src/executorMain.c
+++ b/source/libs/executor/src/executorMain.c
@@ -236,6 +236,37 @@ int32_t qDeserializeTaskStatus(qTaskInfo_t tinfo, const char* pInput, int32_t le
   return decodeOperator(pTaskInfo->pRoot, pInput, len);
 }
 
+int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner) {
+  SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
+  SOperatorInfo* pOperator = pTaskInfo->pRoot;
+
+  while (1) {
+    uint8_t type = pOperator->operatorType;
+    if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
+      *scanner = pOperator->info;
+      return 0;
+    } else {
+      ASSERT(pOperator->numOfDownstream == 1);
+      pOperator = pOperator->pDownstream[0];
+    }
+  }
+}
+
+void* qExtractReaderFromStreamScanner(void* scanner) {
+  SStreamScanInfo* pInfo = scanner;
+  return (void*)pInfo->tqReader;
+}
+
+const SSchemaWrapper* qExtractSchemaFromStreamScanner(void* scanner) {
+  SStreamScanInfo* pInfo = scanner;
+  return pInfo->tqReader->pSchemaWrapper;
+}
+
+const STqOffset* qExtractStatusFromStreamScanner(void* scanner) {
+  SStreamScanInfo* pInfo = scanner;
+  return &pInfo->offset;
+}
+
 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
 
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 4c7b2c910217e2cdd18ccdf8dd13f8c372ac6b41..581c3f179b2c4ee010657c06547a342f9e30f26f 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -741,10 +741,10 @@ static int32_t doCreateConstantValColumnAggInfo(SInputColumnInfoData* pInput, SF
 
   if (type == TSDB_DATA_TYPE_BIGINT) {
     int64_t v = pFuncParam->param.i;
-    *da = (SColumnDataAgg){.numOfNull = 0, .min = v, .max = v, .maxIndex = 0, .minIndex = 0, .sum = v * numOfRows};
+    *da = (SColumnDataAgg){.numOfNull = 0, .min = v, .max = v, .sum = v * numOfRows};
   } else if (type == TSDB_DATA_TYPE_DOUBLE) {
     double v = pFuncParam->param.d;
-    *da = (SColumnDataAgg){.numOfNull = 0, .maxIndex = 0, .minIndex = 0};
+    *da = (SColumnDataAgg){.numOfNull = 0};
 
     *(double*)&da->min = v;
     *(double*)&da->max = v;
@@ -752,7 +752,7 @@ static int32_t doCreateConstantValColumnAggInfo(SInputColumnInfoData* pInput, SF
   } else if (type == TSDB_DATA_TYPE_BOOL) {  // todo validate this data type
     bool v = pFuncParam->param.i;
 
-    *da = (SColumnDataAgg){.numOfNull = 0, .maxIndex = 0, .minIndex = 0};
+    *da = (SColumnDataAgg){.numOfNull = 0};
     *(bool*)&da->min = 0;
     *(bool*)&da->max = v;
     *(bool*)&da->sum = v * numOfRows;
@@ -1130,7 +1130,7 @@ int32_t loadDataBlockOnDemand(SExecTaskInfo* pTaskInfo, STableScanInfo* pTableSc
   } else if ((*status) == BLK_DATA_SMA_LOAD) {
     // this function never returns error?
     pCost->loadBlockStatis += 1;
-//    tsdbRetrieveDataBlockStatisInfo(pTableScanInfo->pTsdbReadHandle, &pBlock->pBlockAgg);
+//    tsdbRetrieveDatablockSMA(pTableScanInfo->pTsdbReadHandle, &pBlock->pBlockAgg);
 
     if (pBlock->pBlockAgg == NULL) {  // data block statistics does not exist, load data block
 //      pBlock->pDataBlock = tsdbRetrieveDataBlock(pTableScanInfo->pTsdbReadHandle, NULL);
@@ -1141,7 +1141,7 @@ int32_t loadDataBlockOnDemand(SExecTaskInfo* pTaskInfo, STableScanInfo* pTableSc
 
     // load the data block statistics to perform further filter
     pCost->loadBlockStatis += 1;
-//    tsdbRetrieveDataBlockStatisInfo(pTableScanInfo->pTsdbReadHandle, &pBlock->pBlockAgg);
+//    tsdbRetrieveDatablockSMA(pTableScanInfo->pTsdbReadHandle, &pBlock->pBlockAgg);
 
     if (pQueryAttr->topBotQuery && pBlock->pBlockAgg != NULL) {
       { // set previous window
@@ -2844,7 +2844,7 @@ int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scan
 }
 
 int32_t doPrepareScan(SOperatorInfo* pOperator, uint64_t uid, int64_t ts) {
-  int32_t type = pOperator->operatorType;
+  uint8_t type = pOperator->operatorType;
 
   pOperator->status = OP_OPENED;
 
@@ -4346,11 +4346,11 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     } else if (QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN == type) {
       SLastRowScanPhysiNode* pScanNode = (SLastRowScanPhysiNode*)pPhyNode;
 
-//      int32_t code = createScanTableListInfo(pTableScanNode, pHandle, pTableListInfo, queryId, taskId);
-//      if (code) {
-//        pTaskInfo->code = code;
-//        return NULL;
-//      }
+      //      int32_t code = createScanTableListInfo(pTableScanNode, pHandle, pTableListInfo, queryId, taskId);
+      //      if (code) {
+      //        pTaskInfo->code = code;
+      //        return NULL;
+      //      }
 
       int32_t code = extractTableSchemaVersion(pHandle, pScanNode->uid, pTaskInfo);
       if (code != TSDB_CODE_SUCCESS) {
@@ -4407,8 +4407,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       pOptr = createGroupOperatorInfo(ops[0], pExprInfo, num, pResBlock, pColList, pAggNode->node.pConditions,
                                       pScalarExprInfo, numOfScalarExpr, pTaskInfo);
     } else {
-      pOptr =
-          createAggregateOperatorInfo(ops[0], pExprInfo, num, pResBlock, pAggNode->node.pConditions, pScalarExprInfo, numOfScalarExpr, pTaskInfo);
+      pOptr = createAggregateOperatorInfo(ops[0], pExprInfo, num, pResBlock, pAggNode->node.pConditions,
+                                          pScalarExprInfo, numOfScalarExpr, pTaskInfo);
     }
   } else if (QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL == type || QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL == type) {
     SIntervalPhysiNode* pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode;
@@ -4575,7 +4575,8 @@ SArray* extractColumnInfo(SNodeList* pNodeList) {
   return pList;
 }
 
-STsdbReader* doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, STableListInfo* pTableListInfo, const char* idstr) {
+STsdbReader* doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle,
+                                STableListInfo* pTableListInfo, const char* idstr) {
   int32_t code = getTableList(pHandle->meta, pHandle->vnode, &pTableScanNode->scan, pTableListInfo);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -4819,7 +4820,6 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead
   (*pTaskInfo)->pRoot = createOperatorTree(pPlan->pNode, *pTaskInfo, pHandle, queryId, taskId,
                                            &(*pTaskInfo)->tableqinfoList, pPlan->user);
 
-
   if (NULL == (*pTaskInfo)->pRoot) {
     code = (*pTaskInfo)->code;
     goto _complete;
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index aae85bbbc18c9b5e080b85e21178a587f9599a7d..e016344f2bb5575e0a7ef3ef547e56b2960c6cc9 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -210,7 +210,10 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
 
     bool             allColumnsHaveAgg = true;
     SColumnDataAgg** pColAgg = NULL;
-    tsdbRetrieveDataBlockStatisInfo(pTableScanInfo->dataReader, &pColAgg, &allColumnsHaveAgg);
+    int32_t code = tsdbRetrieveDatablockSMA(pTableScanInfo->dataReader, &pColAgg, &allColumnsHaveAgg);
+    if (code != TSDB_CODE_SUCCESS) {
+      longjmp(pTaskInfo->env, code);
+    }
 
     if (allColumnsHaveAgg == true) {
       int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
@@ -1232,38 +1235,35 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
     SDataBlockInfo* pBlockInfo = &pInfo->pRes->info;
     blockDataCleanup(pInfo->pRes);
 
-    while (tqNextDataBlock(pInfo->streamReader)) {
+    while (tqNextDataBlock(pInfo->tqReader)) {
       SSDataBlock block = {0};
 
       // todo refactor
-      int32_t code = tqRetrieveDataBlock(&block, pInfo->streamReader);
+      int32_t code = tqRetrieveDataBlock(&block, pInfo->tqReader);
 
-      uint64_t groupId = block.info.groupId;
-      uint64_t uid = block.info.uid;
-      int32_t  numOfRows = block.info.rows;
-
-      if (code != TSDB_CODE_SUCCESS || numOfRows == 0) {
+      if (code != TSDB_CODE_SUCCESS || block.info.rows == 0) {
         pTaskInfo->code = code;
         return NULL;
       }
 
-      pInfo->pRes->info.groupId = groupId;
-      pInfo->pRes->info.rows = numOfRows;
-      pInfo->pRes->info.uid = uid;
+      pInfo->pRes->info.rows = block.info.rows;
+      pInfo->pRes->info.uid = block.info.uid;
       pInfo->pRes->info.type = STREAM_NORMAL;
-      pInfo->pRes->info.capacity = numOfRows;
+      pInfo->pRes->info.capacity = block.info.rows;
+
 
-      // for generating rollup SMA result, each time is an independent time serie.
-      // TODO temporarily used, when the statement of "partition by tbname" is ready, remove this
-      if (pInfo->assignBlockUid) {
-        pInfo->pRes->info.groupId = uid;
-      } else {
-        pInfo->pRes->info.groupId = groupId;
-      }
 
-      uint64_t* groupIdPre = taosHashGet(pOperator->pTaskInfo->tableqinfoList.map, &uid, sizeof(int64_t));
+      uint64_t* groupIdPre = taosHashGet(pOperator->pTaskInfo->tableqinfoList.map, &block.info.uid, sizeof(int64_t));
       if (groupIdPre) {
         pInfo->pRes->info.groupId = *groupIdPre;
+      } else {
+        pInfo->pRes->info.groupId = 0;
+      }
+
+      // for generating rollup SMA result, each time is an independent time serie.
+      // TODO temporarily used, when the statement of "partition by tbname" is ready, remove this
+      if (pInfo->assignBlockUid) {
+        pInfo->pRes->info.groupId = block.info.uid;
       }
 
       // todo extract method
@@ -1413,13 +1413,13 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
       }
     }
 
-    if (pHandle->initStreamReader) {
-      ASSERT(pHandle->streamReader == NULL);
-      pInfo->streamReader = tqInitSubmitMsgScanner(pHandle->meta);
-      ASSERT(pInfo->streamReader);
+    if (pHandle->initTqReader) {
+      ASSERT(pHandle->tqReader == NULL);
+      pInfo->tqReader = tqOpenReader(pHandle->vnode);
+      ASSERT(pInfo->tqReader);
     } else {
-      ASSERT(pHandle->streamReader);
-      pInfo->streamReader = pHandle->streamReader;
+      ASSERT(pHandle->tqReader);
+      pInfo->tqReader = pHandle->tqReader;
     }
 
     if (pSTInfo->interval.interval > 0) {
@@ -1435,9 +1435,9 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     pInfo->tableUid = pScanPhyNode->uid;
 
     // set the extract column id to streamHandle
-    tqReadHandleSetColIdList(pInfo->streamReader, pColIds);
+    tqReaderSetColIdList(pInfo->tqReader, pColIds);
     SArray* tableIdList = extractTableIdList(&pTaskInfo->tableqinfoList);
-    int32_t code = tqReadHandleSetTbUidList(pInfo->streamReader, tableIdList);
+    int32_t code = tqReaderSetTbUidList(pInfo->tqReader, tableIdList);
     if (code != 0) {
       taosArrayDestroy(tableIdList);
       goto _error;
@@ -2352,7 +2352,7 @@ static int32_t loadDataBlockFromOneTable(SOperatorInfo* pOperator, STableMergeSc
     bool             allColumnsHaveAgg = true;
     SColumnDataAgg** pColAgg = NULL;
     STsdbReader*     reader = taosArrayGetP(pTableScanInfo->dataReaders, readerIdx);
-    tsdbRetrieveDataBlockStatisInfo(reader, &pColAgg, &allColumnsHaveAgg);
+    tsdbRetrieveDatablockSMA(reader, &pColAgg, &allColumnsHaveAgg);
 
     if (allColumnsHaveAgg == true) {
       int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index a89e166e8a5e1413813c7c0d822289e87d7c8470..f2a9a13c52c6d2dd31731e77f7983fb1fe7da244 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -1316,7 +1316,7 @@ bool doDeleteIntervalWindow(SAggSupporter* pAggSup, TSKEY ts, uint64_t groupId)
     // window has been closed
     return false;
   }
-  SFilePage* bufPage = getBufPage(pAggSup->pResultBuf, p1->pageId);
+  // SFilePage* bufPage = getBufPage(pAggSup->pResultBuf, p1->pageId);
   // dBufSetBufPageRecycled(pAggSup->pResultBuf, bufPage);
   taosHashRemove(pAggSup->pResultRowHashTable, pAggSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
   return true;
@@ -1419,7 +1419,7 @@ static int32_t closeIntervalWindow(SHashObj* pHashMap, STimeWindowAggSupp* pSup,
         ASSERT(pRecyPages != NULL);
         taosArrayPush(pRecyPages, &pPos->pageId);
       } else {
-        SFilePage* bufPage = getBufPage(pDiscBuf, pPos->pageId);
+        // SFilePage* bufPage = getBufPage(pDiscBuf, pPos->pageId);
         // dBufSetBufPageRecycled(pDiscBuf, bufPage);
       }
       char keyBuf[GET_RES_WINDOW_KEY_LEN(sizeof(TSKEY))];
@@ -1446,7 +1446,7 @@ static void freeAllPages(SArray* pageIds, SDiskbasedBuf* pDiskBuf) {
   int32_t size = taosArrayGetSize(pageIds);
   for (int32_t i = 0; i < size; i++) {
     int32_t pageId = *(int32_t*)taosArrayGet(pageIds, i);
-    SFilePage* bufPage = getBufPage(pDiskBuf, pageId);
+    // SFilePage* bufPage = getBufPage(pDiskBuf, pageId);
     // dBufSetBufPageRecycled(pDiskBuf, bufPage);
   }
   taosArrayClear(pageIds);
@@ -3189,7 +3189,7 @@ SResultWindowInfo* getCurSessionWindow(SStreamAggSupporter* pAggSup, TSKEY start
       *pIndex = index + 1;
       return pWin;
     } else if (endTs != INT64_MIN && isInWindow(pWin, endTs, gap)) {
-      *pIndex = index;
+      *pIndex = index + 1;
       return pWin;
     }
   }
@@ -3442,7 +3442,7 @@ void deleteWindow(SArray* pWinInfos, int32_t index) {
   taosArrayRemove(pWinInfos, index);
 }
 
-static void doDeleteSessionWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, int64_t gap, SArray* result) {
+static void doDeleteTimeWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, int64_t gap, SArray* result) {
   SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
   TSKEY* startDatas = (TSKEY*)pStartTsCol->pData;
   SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
@@ -3700,13 +3700,13 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) {
     } else if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT) {
       SArray* pWins = taosArrayInit(16, sizeof(SResultWindowInfo));
       // gap must be 0
-      doDeleteSessionWindows(&pInfo->streamAggSup, pBlock, 0, pWins);
+      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, 0, pWins);
       if (IS_FINAL_OP(pInfo)) {
         int32_t                        childIndex = getChildIndex(pBlock);
         SOperatorInfo*                 pChildOp = taosArrayGetP(pInfo->pChildren, childIndex);
         SStreamSessionAggOperatorInfo* pChildInfo = pChildOp->info;
         // gap must be 0
-        doDeleteSessionWindows(&pChildInfo->streamAggSup, pBlock, 0, NULL);
+        doDeleteTimeWindows(&pChildInfo->streamAggSup, pBlock, 0, NULL);
         rebuildTimeWindow(pInfo, pWins, pBlock->info.groupId, pOperator->exprSupp.numOfExprs, pOperator);
       }
       copyDeleteWindowInfo(pWins, pInfo->pStDeleted);
@@ -3840,7 +3840,7 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) {
       break;
     } else if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT) {
       // gap must be 0
-      doDeleteSessionWindows(&pInfo->streamAggSup, pBlock, 0, NULL); 
+      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, 0, NULL); 
       copyDataBlock(pInfo->pDelRes, pBlock);
       pInfo->pDelRes->info.type = STREAM_DELETE_RESULT;
       break;
@@ -4232,6 +4232,12 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) {
       doClearStateWindows(&pInfo->streamAggSup, pBlock, pInfo->primaryTsIndex, &pInfo->stateCol, pInfo->stateCol.slotId,
                           pSeUpdated, pInfo->pSeDeleted);
       continue;
+    } else if (pBlock->info.type == STREAM_DELETE_DATA) {
+      SArray* pWins = taosArrayInit(16, sizeof(SResultWindowInfo));
+      doDeleteTimeWindows(&pInfo->streamAggSup, pBlock, 0, pWins);
+      copyDeleteWindowInfo(pWins, pInfo->pSeDeleted);
+      taosArrayDestroy(pWins);
+      continue;
     } else if (pBlock->info.type == STREAM_GET_ALL) {
       getAllSessionWindow(pInfo->streamAggSup.pResultRows, pUpdated, getResWinForState);
       continue;
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index f94522f0d8bde5df192d6481f2c2a9ae4cc57291..d8fcca30c0eb17bd6082dd0af2a2b88a65fef72d 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -1080,6 +1080,19 @@ bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
 static void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
 static void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
 
+static int32_t findRowIndex(int32_t start, int32_t num, SColumnInfoData* pCol, const char* tval) {
+  // the data is loaded, not only the block SMA value
+  for(int32_t i = start; i < num + start; ++i) {
+    char* p = colDataGetData(pCol, i);
+    if (memcpy((void*)tval, p, pCol->info.bytes) == 0)  {
+      return i;
+    }
+  }
+
+  ASSERT(0);
+}
+
+
 int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
   int32_t numOfElems = 0;
 
@@ -1111,15 +1124,14 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
 
     if (isMinFunc) {
       tval = &pInput->pColumnDataAgg[0]->min;
-      index = pInput->pColumnDataAgg[0]->minIndex;
     } else {
       tval = &pInput->pColumnDataAgg[0]->max;
-      index = pInput->pColumnDataAgg[0]->maxIndex;
     }
 
     if (!pBuf->assign) {
       pBuf->v = *(int64_t*)tval;
       if (pCtx->subsidiaries.num > 0) {
+        index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval);
         saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
       }
     } else {
@@ -1131,6 +1143,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
         if ((prev < val) ^ isMinFunc) {
           pBuf->v = val;
           if (pCtx->subsidiaries.num > 0) {
+            index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval);
             saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
           }
         }
@@ -1143,6 +1156,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
         if ((prev < val) ^ isMinFunc) {
           pBuf->v = val;
           if (pCtx->subsidiaries.num > 0) {
+            index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval);
             saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
           }
         }
@@ -1154,6 +1168,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
         if ((prev < val) ^ isMinFunc) {
           pBuf->v = val;
           if (pCtx->subsidiaries.num > 0) {
+            index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval);
             saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
           }
         }
@@ -1167,6 +1182,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
         }
 
         if (pCtx->subsidiaries.num > 0) {
+          index = findRowIndex(pInput->startRowIndex, pInput->numOfRows, pCol, tval);
           saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
         }
       }
@@ -5547,30 +5563,18 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
     }
   }
 
-  int32_t delta = maxVal - minVal;
-  int32_t step = delta / 50;
-  if (step == 0) {
-    step = 1;
-  }
+  // maximum number of step is 80
+  double factor = pData->numOfBlocks / 80.0;
 
   int32_t numOfBuckets = sizeof(pData->blockRowsHisto) / sizeof(pData->blockRowsHisto[0]);
-  int32_t bucketRange = (pData->maxRows - pData->minRows) / numOfBuckets;
-
-  bool singleModel = false;
-  if (bucketRange == 0) {
-    singleModel = true;
-    step = 20;
-    bucketRange = (pData->defMaxRows - pData->defMinRows) / numOfBuckets;
-  }
+  int32_t bucketRange = (pData->defMaxRows - pData->defMinRows) / numOfBuckets;
 
   for (int32_t i = 0; i < tListLen(pData->blockRowsHisto); ++i) {
-    len = sprintf(st + VARSTR_HEADER_SIZE, "%04d |", pData->defMinRows + bucketRange * (i + 1));
+    len = sprintf(st + VARSTR_HEADER_SIZE, "%04d |", pData->defMinRows + bucketRange * i);
 
     int32_t num = 0;
-    if (singleModel && pData->blockRowsHisto[i] > 0) {
-      num = 20;
-    } else {
-      num = (pData->blockRowsHisto[i] + step - 1) / step;
+    if (pData->blockRowsHisto[i] > 0) {
+      num = (pData->blockRowsHisto[i]) / factor;
     }
 
     for (int32_t j = 0; j < num; ++j) {
@@ -5578,9 +5582,10 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
       len += x;
     }
 
-    double v = pData->blockRowsHisto[i] * 100.0 / pData->numOfBlocks;
-    len += sprintf(st + VARSTR_HEADER_SIZE + len, "  %d (%.2f%c)", pData->blockRowsHisto[i], v, '%');
-    printf("%s\n", st);
+    if (num > 0) {
+      double v = pData->blockRowsHisto[i] * 100.0 / pData->numOfBlocks;
+      len += sprintf(st + VARSTR_HEADER_SIZE + len, "  %d (%.2f%c)", pData->blockRowsHisto[i], v, '%');
+    }
 
     varDataSetLen(st, len);
     colDataAppend(pColInfo, row++, st, false);
diff --git a/source/libs/sync/inc/syncInt.h b/source/libs/sync/inc/syncInt.h
index 8936cd6ed9bfc6ee33d19d5dcca8ea527b71c837..9742f93824120f4f6ca21401c695de7f2524d240 100644
--- a/source/libs/sync/inc/syncInt.h
+++ b/source/libs/sync/inc/syncInt.h
@@ -67,7 +67,6 @@ typedef struct SSyncNode {
   char        path[TSDB_FILENAME_LEN];
   char        raftStorePath[TSDB_FILENAME_LEN * 2];
   char        configPath[TSDB_FILENAME_LEN * 2];
-  int32_t     batchSize;
 
   // sync io
   SWal*         pWal;
diff --git a/source/libs/sync/inc/syncOnMessage.h b/source/libs/sync/inc/syncOnMessage.h
deleted file mode 100644
index 2f8856e652a84332a9455fb1f6bc26bf8a975e89..0000000000000000000000000000000000000000
--- a/source/libs/sync/inc/syncOnMessage.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_LIBS_SYNC_ON_MESSAGE_H
-#define _TD_LIBS_SYNC_ON_MESSAGE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "taosdef.h"
-
-// TLA+ Spec
-// Receive(m) ==
-//     LET i == m.mdest
-//         j == m.msource
-//     IN \* Any RPC with a newer term causes the recipient to advance
-//        \* its term first. Responses with stale terms are ignored.
-//        \/ UpdateTerm(i, j, m)
-//        \/ /\ m.mtype = RequestVoteRequest
-//           /\ HandleRequestVoteRequest(i, j, m)
-//        \/ /\ m.mtype = RequestVoteResponse
-//           /\ \/ DropStaleResponse(i, j, m)
-//              \/ HandleRequestVoteResponse(i, j, m)
-//        \/ /\ m.mtype = AppendEntriesRequest
-//           /\ HandleAppendEntriesRequest(i, j, m)
-//        \/ /\ m.mtype = AppendEntriesResponse
-//           /\ \/ DropStaleResponse(i, j, m)
-//              \/ HandleAppendEntriesResponse(i, j, m)
-
-// DuplicateMessage(m) ==
-//     /\ Send(m)
-//     /\ UNCHANGED <<serverVars, candidateVars, leaderVars, logVars>>
-
-// DropMessage(m) ==
-//     /\ Discard(m)
-//     /\ UNCHANGED <<serverVars, candidateVars, leaderVars, logVars>>
-
-// Next == /\ \/ \E i \in Server : Restart(i)
-//            \/ \E i \in Server : Timeout(i)
-//            \/ \E i,j \in Server : RequestVote(i, j)
-//            \/ \E i \in Server : BecomeLeader(i)
-//            \/ \E i \in Server, v \in Value : ClientRequest(i, v)
-//            \/ \E i \in Server : AdvanceCommitIndex(i)
-//            \/ \E i,j \in Server : AppendEntries(i, j)
-//            \/ \E m \in DOMAIN messages : Receive(m)
-//            \/ \E m \in DOMAIN messages : DuplicateMessage(m)
-//            \/ \E m \in DOMAIN messages : DropMessage(m)
-//            \* History variable that tracks every log ever:
-//         /\ allLogs' = allLogs \cup {log[i] : i \in Server}
-//
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_LIBS_SYNC_ON_MESSAGE_H*/
diff --git a/source/libs/sync/src/syncAppendEntries.c b/source/libs/sync/src/syncAppendEntries.c
index 885ab1acae068d8d8f98fdde20be2eea2cc3d0c9..e43c1e4b33d73b05501f2d567056a9a20f781446 100644
--- a/source/libs/sync/src/syncAppendEntries.c
+++ b/source/libs/sync/src/syncAppendEntries.c
@@ -162,6 +162,17 @@ int32_t syncNodeOnAppendEntriesCb(SSyncNode* ths, SyncAppendEntries* pMsg) {
     pReply->success = false;
     pReply->matchIndex = SYNC_INDEX_INVALID;
 
+    // msg event log
+    do {
+      char     host[128];
+      uint16_t port;
+      syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+      sDebug(
+          "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+          "match-index:%ld}",
+          ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+    } while (0);
+
     SRpcMsg rpcMsg;
     syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
     syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg);
@@ -334,270 +345,16 @@ int32_t syncNodeOnAppendEntriesCb(SSyncNode* ths, SyncAppendEntries* pMsg) {
       pReply->matchIndex = pMsg->prevLogIndex;
     }
 
-    SRpcMsg rpcMsg;
-    syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
-    syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg);
-    syncAppendEntriesReplyDestroy(pReply);
-
-    // maybe update commit index from leader
-    if (pMsg->commitIndex > ths->commitIndex) {
-      // has commit entry in local
-      if (pMsg->commitIndex <= ths->pLogStore->getLastIndex(ths->pLogStore)) {
-        SyncIndex beginIndex = ths->commitIndex + 1;
-        SyncIndex endIndex = pMsg->commitIndex;
-
-        // update commit index
-        ths->commitIndex = pMsg->commitIndex;
-
-        // call back Wal
-        ths->pLogStore->updateCommitIndex(ths->pLogStore, ths->commitIndex);
-
-        int32_t code = syncNodeCommit(ths, beginIndex, endIndex, ths->state);
-        ASSERT(code == 0);
-      }
-    }
-  }
-
-  return ret;
-}
-
-#if 0
-
-int32_t syncNodeOnAppendEntriesCb(SSyncNode* ths, SyncAppendEntries* pMsg) {
-  int32_t ret = 0;
-
-  char logBuf[128] = {0};
-  snprintf(logBuf, sizeof(logBuf), "==syncNodeOnAppendEntriesCb== term:%lu", ths->pRaftStore->currentTerm);
-  syncAppendEntriesLog2(logBuf, pMsg);
-
-  if (pMsg->term > ths->pRaftStore->currentTerm) {
-    syncNodeUpdateTerm(ths, pMsg->term);
-  }
-  ASSERT(pMsg->term <= ths->pRaftStore->currentTerm);
-
-  // reset elect timer
-  if (pMsg->term == ths->pRaftStore->currentTerm) {
-    ths->leaderCache = pMsg->srcId;
-    syncNodeResetElectTimer(ths);
-  }
-  ASSERT(pMsg->dataLen >= 0);
-
-  SyncTerm localPreLogTerm = 0;
-  if (pMsg->prevLogIndex >= SYNC_INDEX_BEGIN && pMsg->prevLogIndex <= ths->pLogStore->getLastIndex(ths->pLogStore)) {
-    SSyncRaftEntry* pEntry = ths->pLogStore->getEntry(ths->pLogStore, pMsg->prevLogIndex);
-    if (pEntry == NULL) {
-      char logBuf[128];
-      snprintf(logBuf, sizeof(logBuf), "getEntry error, index:%ld, since %s", pMsg->prevLogIndex, terrstr());
-      syncNodeErrorLog(ths, logBuf);
-      return -1;
-    }
-
-    localPreLogTerm = pEntry->term;
-    syncEntryDestory(pEntry);
-  }
-
-  bool logOK =
-      (pMsg->prevLogIndex == SYNC_INDEX_INVALID) ||
-      ((pMsg->prevLogIndex >= SYNC_INDEX_BEGIN) &&
-       (pMsg->prevLogIndex <= ths->pLogStore->getLastIndex(ths->pLogStore)) && (pMsg->prevLogTerm == localPreLogTerm));
-
-  // reject request
-  if ((pMsg->term < ths->pRaftStore->currentTerm) ||
-      ((pMsg->term == ths->pRaftStore->currentTerm) && (ths->state == TAOS_SYNC_STATE_FOLLOWER) && !logOK)) {
-    sTrace(
-        "syncNodeOnAppendEntriesCb --> reject, pMsg->term:%lu, ths->pRaftStore->currentTerm:%lu, ths->state:%d, "
-        "logOK:%d",
-        pMsg->term, ths->pRaftStore->currentTerm, ths->state, logOK);
-
-    SyncAppendEntriesReply* pReply = syncAppendEntriesReplyBuild(ths->vgId);
-    pReply->srcId = ths->myRaftId;
-    pReply->destId = pMsg->srcId;
-    pReply->term = ths->pRaftStore->currentTerm;
-    pReply->success = false;
-    pReply->matchIndex = SYNC_INDEX_INVALID;
-
-    SRpcMsg rpcMsg;
-    syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
-    syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg);
-    syncAppendEntriesReplyDestroy(pReply);
-
-    return ret;
-  }
-
-  // return to follower state
-  if (pMsg->term == ths->pRaftStore->currentTerm && ths->state == TAOS_SYNC_STATE_CANDIDATE) {
-    sTrace(
-        "syncNodeOnAppendEntriesCb --> return to follower, pMsg->term:%lu, ths->pRaftStore->currentTerm:%lu, "
-        "ths->state:%d, logOK:%d",
-        pMsg->term, ths->pRaftStore->currentTerm, ths->state, logOK);
-
-    syncNodeBecomeFollower(ths, "from candidate by append entries");
-
-    // ret or reply?
-    return ret;
-  }
-
-  // accept request
-  if (pMsg->term == ths->pRaftStore->currentTerm && ths->state == TAOS_SYNC_STATE_FOLLOWER && logOK) {
-    // preIndex = -1, or has preIndex entry in local log
-    ASSERT(pMsg->prevLogIndex <= ths->pLogStore->getLastIndex(ths->pLogStore));
-
-    // has extra entries (> preIndex) in local log
-    bool hasExtraEntries = pMsg->prevLogIndex < ths->pLogStore->getLastIndex(ths->pLogStore);
-
-    // has entries in SyncAppendEntries msg
-    bool hasAppendEntries = pMsg->dataLen > 0;
-
-    sTrace(
-        "syncNodeOnAppendEntriesCb --> accept, pMsg->term:%lu, ths->pRaftStore->currentTerm:%lu, ths->state:%d, "
-        "logOK:%d, hasExtraEntries:%d, hasAppendEntries:%d",
-        pMsg->term, ths->pRaftStore->currentTerm, ths->state, logOK, hasExtraEntries, hasAppendEntries);
-
-    if (hasExtraEntries && hasAppendEntries) {
-      // not conflict by default
-      bool conflict = false;
-
-      SyncIndex       extraIndex = pMsg->prevLogIndex + 1;
-      SSyncRaftEntry* pExtraEntry = ths->pLogStore->getEntry(ths->pLogStore, extraIndex);
-      if (pExtraEntry == NULL) {
-        char logBuf[128];
-        snprintf(logBuf, sizeof(logBuf), "getEntry error2, index:%ld, since %s", extraIndex, terrstr());
-        syncNodeErrorLog(ths, logBuf);
-        return -1;
-      }
-
-      SSyncRaftEntry* pAppendEntry = syncEntryDeserialize(pMsg->data, pMsg->dataLen);
-      if (pAppendEntry == NULL) {
-        syncNodeErrorLog(ths, "syncEntryDeserialize pAppendEntry error");
-        return -1;
-      }
-
-      // log not match, conflict
-      ASSERT(extraIndex == pAppendEntry->index);
-      if (pExtraEntry->term != pAppendEntry->term) {
-        conflict = true;
-      }
-
-      if (conflict) {
-        // roll back
-        SyncIndex delBegin = ths->pLogStore->getLastIndex(ths->pLogStore);
-        SyncIndex delEnd = extraIndex;
-
-        sTrace("syncNodeOnAppendEntriesCb --> conflict:%d, delBegin:%ld, delEnd:%ld", conflict, delBegin, delEnd);
-
-        // notice! reverse roll back!
-        for (SyncIndex index = delEnd; index >= delBegin; --index) {
-          if (ths->pFsm->FpRollBackCb != NULL) {
-            SSyncRaftEntry* pRollBackEntry = ths->pLogStore->getEntry(ths->pLogStore, index);
-            if (pRollBackEntry == NULL) {
-              char logBuf[128];
-              snprintf(logBuf, sizeof(logBuf), "getEntry error3, index:%ld, since %s", index, terrstr());
-              syncNodeErrorLog(ths, logBuf);
-              return -1;
-            }
-
-            // if (pRollBackEntry->msgType != TDMT_SYNC_NOOP) {
-            if (syncUtilUserRollback(pRollBackEntry->msgType)) {
-              SRpcMsg rpcMsg;
-              syncEntry2OriginalRpc(pRollBackEntry, &rpcMsg);
-
-              SFsmCbMeta cbMeta = {0};
-              cbMeta.index = pRollBackEntry->index;
-              cbMeta.lastConfigIndex = syncNodeGetSnapshotConfigIndex(ths, cbMeta.index);
-              cbMeta.isWeak = pRollBackEntry->isWeak;
-              cbMeta.code = 0;
-              cbMeta.state = ths->state;
-              cbMeta.seqNum = pRollBackEntry->seqNum;
-              ths->pFsm->FpRollBackCb(ths->pFsm, &rpcMsg, cbMeta);
-              rpcFreeCont(rpcMsg.pCont);
-            }
-
-            syncEntryDestory(pRollBackEntry);
-          }
-        }
-
-        // delete confict entries
-        ths->pLogStore->truncate(ths->pLogStore, extraIndex);
-
-        // append new entries
-        ths->pLogStore->appendEntry(ths->pLogStore, pAppendEntry);
-
-        // pre commit
-        SRpcMsg rpcMsg;
-        syncEntry2OriginalRpc(pAppendEntry, &rpcMsg);
-        if (ths->pFsm != NULL) {
-          // if (ths->pFsm->FpPreCommitCb != NULL && pAppendEntry->originalRpcType != TDMT_SYNC_NOOP) {
-          if (ths->pFsm->FpPreCommitCb != NULL && syncUtilUserPreCommit(pAppendEntry->originalRpcType)) {
-            SFsmCbMeta cbMeta = {0};
-            cbMeta.index = pAppendEntry->index;
-            cbMeta.lastConfigIndex = syncNodeGetSnapshotConfigIndex(ths, cbMeta.index);
-            cbMeta.isWeak = pAppendEntry->isWeak;
-            cbMeta.code = 2;
-            cbMeta.state = ths->state;
-            cbMeta.seqNum = pAppendEntry->seqNum;
-            ths->pFsm->FpPreCommitCb(ths->pFsm, &rpcMsg, cbMeta);
-          }
-        }
-        rpcFreeCont(rpcMsg.pCont);
-      }
-
-      // free memory
-      syncEntryDestory(pExtraEntry);
-      syncEntryDestory(pAppendEntry);
-
-    } else if (hasExtraEntries && !hasAppendEntries) {
-      // do nothing
-
-    } else if (!hasExtraEntries && hasAppendEntries) {
-      SSyncRaftEntry* pAppendEntry = syncEntryDeserialize(pMsg->data, pMsg->dataLen);
-      if (pAppendEntry == NULL) {
-        syncNodeErrorLog(ths, "syncEntryDeserialize pAppendEntry2 error");
-        return -1;
-      }
-
-      // append new entries
-      ths->pLogStore->appendEntry(ths->pLogStore, pAppendEntry);
-
-      // pre commit
-      SRpcMsg rpcMsg;
-      syncEntry2OriginalRpc(pAppendEntry, &rpcMsg);
-      if (ths->pFsm != NULL) {
-        // if (ths->pFsm->FpPreCommitCb != NULL && pAppendEntry->originalRpcType != TDMT_SYNC_NOOP) {
-        if (ths->pFsm->FpPreCommitCb != NULL && syncUtilUserPreCommit(pAppendEntry->originalRpcType)) {
-          SFsmCbMeta cbMeta = {0};
-          cbMeta.index = pAppendEntry->index;
-          cbMeta.lastConfigIndex = syncNodeGetSnapshotConfigIndex(ths, cbMeta.index);
-          cbMeta.isWeak = pAppendEntry->isWeak;
-          cbMeta.code = 3;
-          cbMeta.state = ths->state;
-          cbMeta.seqNum = pAppendEntry->seqNum;
-          ths->pFsm->FpPreCommitCb(ths->pFsm, &rpcMsg, cbMeta);
-        }
-      }
-      rpcFreeCont(rpcMsg.pCont);
-
-      // free memory
-      syncEntryDestory(pAppendEntry);
-
-    } else if (!hasExtraEntries && !hasAppendEntries) {
-      // do nothing
-
-    } else {
-      syncNodeLog3("", ths);
-      ASSERT(0);
-    }
-
-    SyncAppendEntriesReply* pReply = syncAppendEntriesReplyBuild(ths->vgId);
-    pReply->srcId = ths->myRaftId;
-    pReply->destId = pMsg->srcId;
-    pReply->term = ths->pRaftStore->currentTerm;
-    pReply->success = true;
-
-    if (hasAppendEntries) {
-      pReply->matchIndex = pMsg->prevLogIndex + 1;
-    } else {
-      pReply->matchIndex = pMsg->prevLogIndex;
-    }
+    // msg event log
+    do {
+      char     host[128];
+      uint16_t port;
+      syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+      sDebug(
+          "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+          "match-index:%ld}",
+          ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+    } while (0);
 
     SRpcMsg rpcMsg;
     syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -626,8 +383,6 @@ int32_t syncNodeOnAppendEntriesCb(SSyncNode* ths, SyncAppendEntries* pMsg) {
   return ret;
 }
 
-#endif
-
 static int32_t syncNodeMakeLogSame(SSyncNode* ths, SyncAppendEntries* pMsg) {
   int32_t code;
 
@@ -842,8 +597,8 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
       do {
         char logBuf[128];
         snprintf(logBuf, sizeof(logBuf),
-                 "recv sync-append-entries-batch, fake match2, pre-index:%ld, pre-term:%lu, datalen:%d",
-                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen);
+                 "recv sync-append-entries-batch, fake match2, {pre-index:%ld, pre-term:%lu, datalen:%d, datacount:%d}",
+                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen, pMsg->dataCount);
         syncNodeEventLog(ths, logBuf);
       } while (0);
 
@@ -876,7 +631,7 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
           code = syncNodePreCommit(ths, pAppendEntry);
           ASSERT(code == 0);
 
-          syncEntryDestory(pAppendEntry);
+          // syncEntryDestory(pAppendEntry);
         }
 
         // fsync once
@@ -897,6 +652,17 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
       pReply->success = true;
       pReply->matchIndex = matchIndex;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -931,8 +697,8 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
       do {
         char logBuf[128];
         snprintf(logBuf, sizeof(logBuf),
-                 "recv sync-append-entries-batch, not match, pre-index:%ld, pre-term:%lu, datalen:%d",
-                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen);
+                 "recv sync-append-entries-batch, not match, {pre-index:%ld, pre-term:%lu, datalen:%d, datacount:%d}",
+                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen, pMsg->dataCount);
         syncNodeEventLog(ths, logBuf);
       } while (0);
 
@@ -945,6 +711,17 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
       pReply->success = false;
       pReply->matchIndex = SYNC_INDEX_INVALID;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -976,8 +753,9 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
 
       do {
         char logBuf[128];
-        snprintf(logBuf, sizeof(logBuf), "recv sync-append-entries, match, pre-index:%ld, pre-term:%lu, datalen:%d",
-                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen);
+        snprintf(logBuf, sizeof(logBuf),
+                 "recv sync-append-entries-batch, match, {pre-index:%ld, pre-term:%lu, datalen:%d, datacount:%d}",
+                 pMsg->prevLogIndex, pMsg->prevLogTerm, pMsg->dataLen, pMsg->dataCount);
         syncNodeEventLog(ths, logBuf);
       } while (0);
 
@@ -999,7 +777,7 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
           code = syncNodePreCommit(ths, pAppendEntry);
           ASSERT(code == 0);
 
-          syncEntryDestory(pAppendEntry);
+          // syncEntryDestory(pAppendEntry);
         }
 
         // fsync once
@@ -1017,6 +795,17 @@ int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatc
       pReply->success = true;
       pReply->matchIndex = hasAppendEntries ? pMsg->prevLogIndex + pMsg->dataCount : pMsg->prevLogIndex;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -1226,6 +1015,17 @@ int32_t syncNodeOnAppendEntriesSnapshotCb(SSyncNode* ths, SyncAppendEntries* pMs
       pReply->success = true;
       pReply->matchIndex = matchIndex;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -1271,6 +1071,17 @@ int32_t syncNodeOnAppendEntriesSnapshotCb(SSyncNode* ths, SyncAppendEntries* pMs
       pReply->success = false;
       pReply->matchIndex = SYNC_INDEX_INVALID;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
@@ -1336,6 +1147,17 @@ int32_t syncNodeOnAppendEntriesSnapshotCb(SSyncNode* ths, SyncAppendEntries* pMs
       pReply->success = true;
       pReply->matchIndex = hasAppendEntries ? pMsg->prevLogIndex + 1 : pMsg->prevLogIndex;
 
+      // msg event log
+      do {
+        char     host[128];
+        uint16_t port;
+        syncUtilU642Addr(pReply->destId.addr, host, sizeof(host), &port);
+        sDebug(
+            "vgId:%d, send sync-append-entries-reply to %s:%d, {term:%lu, pterm:%lu, success:%d, "
+            "match-index:%ld}",
+            ths->vgId, host, port, pReply->term, pReply->privateTerm, pReply->success, pReply->matchIndex);
+      } while (0);
+
       // send response
       SRpcMsg rpcMsg;
       syncAppendEntriesReply2RpcMsg(pReply, &rpcMsg);
diff --git a/source/libs/sync/src/syncAppendEntriesReply.c b/source/libs/sync/src/syncAppendEntriesReply.c
index e4724fc999dcedb565e309f5591818d03f6775b9..3f19b6759e9dcc4924681e5978065cbe602e019f 100644
--- a/source/libs/sync/src/syncAppendEntriesReply.c
+++ b/source/libs/sync/src/syncAppendEntriesReply.c
@@ -174,8 +174,12 @@ int32_t syncNodeOnAppendEntriesReplySnapshot2Cb(SSyncNode* ths, SyncAppendEntrie
     SyncIndex newNextIndex = pMsg->matchIndex + 1;
     SyncIndex newMatchIndex = pMsg->matchIndex;
 
-    if (ths->pLogStore->syncLogExist(ths->pLogStore, newNextIndex) &&
-        ths->pLogStore->syncLogExist(ths->pLogStore, newNextIndex - 1)) {
+    bool needStartSnapshot = false;
+    if (newMatchIndex >= SYNC_INDEX_BEGIN && !ths->pLogStore->syncLogExist(ths->pLogStore, newMatchIndex)) {
+      needStartSnapshot = true;
+    }
+
+    if (!needStartSnapshot) {
       // update next-index, match-index
       syncIndexMgrSetIndex(ths->pNextIndex, &(pMsg->srcId), newNextIndex);
       syncIndexMgrSetIndex(ths->pMatchIndex, &(pMsg->srcId), newMatchIndex);
@@ -197,15 +201,36 @@ int32_t syncNodeOnAppendEntriesReplySnapshot2Cb(SSyncNode* ths, SyncAppendEntrie
       syncIndexMgrSetIndex(ths->pMatchIndex, &(pMsg->srcId), newMatchIndex);
     }
 
+    // event log, update next-index
+    do {
+      char    host[64];
+      int16_t port;
+      syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);
+
+      char logBuf[256];
+      snprintf(logBuf, sizeof(logBuf), "reset next-index:%ld, match-index:%ld for %s:%d", newNextIndex, newMatchIndex,
+               host, port);
+      syncNodeEventLog(ths, logBuf);
+
+    } while (0);
+
   } else {
     SyncIndex nextIndex = syncIndexMgrGetIndex(ths->pNextIndex, &(pMsg->srcId));
 
     if (nextIndex > SYNC_INDEX_BEGIN) {
       --nextIndex;
 
-      if (ths->pLogStore->syncLogExist(ths->pLogStore, nextIndex) &&
-          ths->pLogStore->syncLogExist(ths->pLogStore, nextIndex - 1)) {
+      bool needStartSnapshot = false;
+      if (nextIndex >= SYNC_INDEX_BEGIN && !ths->pLogStore->syncLogExist(ths->pLogStore, nextIndex)) {
+        needStartSnapshot = true;
+      }
+      if (nextIndex - 1 >= SYNC_INDEX_BEGIN && !ths->pLogStore->syncLogExist(ths->pLogStore, nextIndex - 1)) {
+        needStartSnapshot = true;
+      }
+
+      if (!needStartSnapshot) {
         // do nothing
+
       } else {
         SSyncRaftEntry* pEntry;
         int32_t         code = ths->pLogStore->syncLogGetEntry(ths->pLogStore, nextIndex, &pEntry);
@@ -227,6 +252,21 @@ int32_t syncNodeOnAppendEntriesReplySnapshot2Cb(SSyncNode* ths, SyncAppendEntrie
       nextIndex = SYNC_INDEX_BEGIN;
     }
     syncIndexMgrSetIndex(ths->pNextIndex, &(pMsg->srcId), nextIndex);
+
+    // event log, update next-index
+    do {
+      char    host[64];
+      int16_t port;
+      syncUtilU642Addr(pMsg->srcId.addr, host, sizeof(host), &port);
+
+      SyncIndex newNextIndex = nextIndex;
+      SyncIndex newMatchIndex = syncIndexMgrGetIndex(ths->pMatchIndex, &(pMsg->srcId));
+      char      logBuf[256];
+      snprintf(logBuf, sizeof(logBuf), "reset2 next-index:%ld, match-index:%ld for %s:%d", newNextIndex, newMatchIndex,
+               host, port);
+      syncNodeEventLog(ths, logBuf);
+
+    } while (0);
   }
 
   return 0;
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index 56fc6594ab7c94f5f6de2d084440313c52fc1791..7fa13c9dc8088cdabd98082e62752e1536806f46 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -1311,8 +1311,10 @@ int32_t syncNodeSendMsgById(const SRaftId* destRaftId, SSyncNode* pSyncNode, SRp
     pMsg->info.noResp = 1;
     pSyncNode->FpSendMsg(&epSet, pMsg);
   } else {
-    sTrace("syncNodeSendMsgById pSyncNode->FpSendMsg is NULL");
+    sError("vgId:%d, sync send msg by id error, fp-send-msg is null", pSyncNode->vgId);
+    return -1;
   }
+
   return 0;
 }
 
@@ -1326,7 +1328,7 @@ int32_t syncNodeSendMsgByInfo(const SNodeInfo* nodeInfo, SSyncNode* pSyncNode, S
     pMsg->info.noResp = 1;
     pSyncNode->FpSendMsg(&epSet, pMsg);
   } else {
-    sTrace("syncNodeSendMsgByInfo pSyncNode->FpSendMsg is NULL");
+    sError("vgId:%d, sync send msg by info error, fp-send-msg is null", pSyncNode->vgId);
   }
   return 0;
 }
@@ -1526,12 +1528,14 @@ void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(logBuf, sizeof(logBuf),
                "vgId:%d, sync %s %s, term:%lu, commit:%ld, beginlog:%ld, lastlog:%ld, lastsnapshot:%ld, standby:%d, "
+               "strategy:%d, batch:%d, "
                "replica-num:%d, "
                "lconfig:%ld, changing:%d, restore:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex,
-               pSyncNode->pRaftCfg->isStandBy, pSyncNode->replicaNum, pSyncNode->pRaftCfg->lastConfigIndex,
-               pSyncNode->changing, pSyncNode->restoreFinish, printStr);
+               pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
+               pSyncNode->replicaNum, pSyncNode->pRaftCfg->lastConfigIndex, pSyncNode->changing,
+               pSyncNode->restoreFinish, printStr);
     } else {
       snprintf(logBuf, sizeof(logBuf), "%s", str);
     }
@@ -1543,12 +1547,14 @@ void syncNodeEventLog(const SSyncNode* pSyncNode, char* str) {
     if (pSyncNode != NULL && pSyncNode->pRaftCfg != NULL && pSyncNode->pRaftStore != NULL) {
       snprintf(s, len,
                "vgId:%d, sync %s %s, term:%lu, commit:%ld, beginlog:%ld, lastlog:%ld, lastsnapshot:%ld, standby:%d, "
+               "strategy:%d, batch:%d, "
                "replica-num:%d, "
                "lconfig:%ld, changing:%d, restore:%d, %s",
                pSyncNode->vgId, syncUtilState2String(pSyncNode->state), str, pSyncNode->pRaftStore->currentTerm,
                pSyncNode->commitIndex, logBeginIndex, logLastIndex, snapshot.lastApplyIndex,
-               pSyncNode->pRaftCfg->isStandBy, pSyncNode->replicaNum, pSyncNode->pRaftCfg->lastConfigIndex,
-               pSyncNode->changing, pSyncNode->restoreFinish, printStr);
+               pSyncNode->pRaftCfg->isStandBy, pSyncNode->pRaftCfg->snapshotStrategy, pSyncNode->pRaftCfg->batchSize,
+               pSyncNode->replicaNum, pSyncNode->pRaftCfg->lastConfigIndex, pSyncNode->changing,
+               pSyncNode->restoreFinish, printStr);
     } else {
       snprintf(s, len, "%s", str);
     }
diff --git a/source/libs/sync/src/syncMessage.c b/source/libs/sync/src/syncMessage.c
index e53b9d5e367735baae6800a848929fdced87965c..697c25f3040d8cb09baefb5c45ef2691d6408973 100644
--- a/source/libs/sync/src/syncMessage.c
+++ b/source/libs/sync/src/syncMessage.c
@@ -1605,7 +1605,7 @@ void syncAppendEntriesLog2(char* s, const SyncAppendEntries* pMsg) {
 
 SyncAppendEntriesBatch* syncAppendEntriesBatchBuild(SSyncRaftEntry** entryPArr, int32_t arrSize, int32_t vgId) {
   ASSERT(entryPArr != NULL);
-  ASSERT(arrSize > 0);
+  ASSERT(arrSize >= 0);
 
   int32_t dataLen = 0;
   int32_t metaArrayLen = sizeof(SOffsetAndContLen) * arrSize;  // <offset, contLen>
diff --git a/source/libs/sync/src/syncOnMessage.c b/source/libs/sync/src/syncOnMessage.c
deleted file mode 100644
index ce8bed9cd39c44df9b090ae931cba063d1dda53c..0000000000000000000000000000000000000000
--- a/source/libs/sync/src/syncOnMessage.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * 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 "syncOnMessage.h"
-
-// TLA+ Spec
-// Receive(m) ==
-//     LET i == m.mdest
-//         j == m.msource
-//     IN \* Any RPC with a newer term causes the recipient to advance
-//        \* its term first. Responses with stale terms are ignored.
-//        \/ UpdateTerm(i, j, m)
-//        \/ /\ m.mtype = RequestVoteRequest
-//           /\ HandleRequestVoteRequest(i, j, m)
-//        \/ /\ m.mtype = RequestVoteResponse
-//           /\ \/ DropStaleResponse(i, j, m)
-//              \/ HandleRequestVoteResponse(i, j, m)
-//        \/ /\ m.mtype = AppendEntriesRequest
-//           /\ HandleAppendEntriesRequest(i, j, m)
-//        \/ /\ m.mtype = AppendEntriesResponse
-//           /\ \/ DropStaleResponse(i, j, m)
-//              \/ HandleAppendEntriesResponse(i, j, m)
-
-// DuplicateMessage(m) ==
-//     /\ Send(m)
-//     /\ UNCHANGED <<serverVars, candidateVars, leaderVars, logVars>>
-
-// DropMessage(m) ==
-//     /\ Discard(m)
-//     /\ UNCHANGED <<serverVars, candidateVars, leaderVars, logVars>>
-
-// Next == /\ \/ \E i \in Server : Restart(i)
-//            \/ \E i \in Server : Timeout(i)
-//            \/ \E i,j \in Server : RequestVote(i, j)
-//            \/ \E i \in Server : BecomeLeader(i)
-//            \/ \E i \in Server, v \in Value : ClientRequest(i, v)
-//            \/ \E i \in Server : AdvanceCommitIndex(i)
-//            \/ \E i,j \in Server : AppendEntries(i, j)
-//            \/ \E m \in DOMAIN messages : Receive(m)
-//            \/ \E m \in DOMAIN messages : DuplicateMessage(m)
-//            \/ \E m \in DOMAIN messages : DropMessage(m)
-//            \* History variable that tracks every log ever:
-//         /\ allLogs' = allLogs \cup {log[i] : i \in Server}
-//
\ No newline at end of file
diff --git a/source/libs/sync/src/syncRaftCfg.c b/source/libs/sync/src/syncRaftCfg.c
index ead1168632a154be285c07c4a7183a2a202451dd..6c381f6e7d9ad61a35bcffe4a9e7bf8141c90c06 100644
--- a/source/libs/sync/src/syncRaftCfg.c
+++ b/source/libs/sync/src/syncRaftCfg.c
@@ -101,7 +101,7 @@ cJSON *syncCfg2Json(SSyncCfg *pSyncCfg) {
 
 char *syncCfg2Str(SSyncCfg *pSyncCfg) {
   cJSON *pJson = syncCfg2Json(pSyncCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -109,7 +109,7 @@ char *syncCfg2Str(SSyncCfg *pSyncCfg) {
 char *syncCfg2SimpleStr(SSyncCfg *pSyncCfg) {
   if (pSyncCfg != NULL) {
     int32_t len = 512;
-    char *  s = taosMemoryMalloc(len);
+    char   *s = taosMemoryMalloc(len);
     memset(s, 0, len);
 
     snprintf(s, len, "{replica-num:%d, my-index:%d, ", pSyncCfg->replicaNum, pSyncCfg->myIndex);
@@ -206,7 +206,7 @@ cJSON *raftCfg2Json(SRaftCfg *pRaftCfg) {
 
 char *raftCfg2Str(SRaftCfg *pRaftCfg) {
   cJSON *pJson = raftCfg2Json(pRaftCfg);
-  char * serialized = cJSON_Print(pJson);
+  char  *serialized = cJSON_Print(pJson);
   cJSON_Delete(pJson);
   return serialized;
 }
@@ -285,7 +285,7 @@ int32_t raftCfgFromJson(const cJSON *pRoot, SRaftCfg *pRaftCfg) {
     (pRaftCfg->configIndexArr)[i] = atoll(pIndex->valuestring);
   }
 
-  cJSON * pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
+  cJSON  *pJsonSyncCfg = cJSON_GetObjectItem(pJson, "SSyncCfg");
   int32_t code = syncCfgFromJson(pJsonSyncCfg, &(pRaftCfg->cfg));
   ASSERT(code == 0);
 
diff --git a/source/libs/sync/src/syncRaftLog.c b/source/libs/sync/src/syncRaftLog.c
index c5d339b08fa6dcbf683124b077a4aa5482a58672..3a44933eeab29c6ef50cd02b7875b6f54271f0a8 100644
--- a/source/libs/sync/src/syncRaftLog.c
+++ b/source/libs/sync/src/syncRaftLog.c
@@ -326,6 +326,14 @@ static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIn
 
     ASSERT(0);
   }
+
+  // event log
+  do {
+    char logBuf[128];
+    snprintf(logBuf, sizeof(logBuf), "wal truncate, from-index:%ld", fromIndex);
+    syncNodeEventLog(pData->pSyncNode, logBuf);
+  } while (0);
+
   return code;
 }
 
@@ -463,6 +471,14 @@ int32_t logStoreTruncate(SSyncLogStore* pLogStore, SyncIndex fromIndex) {
 
     ASSERT(0);
   }
+
+  // event log
+  do {
+    char logBuf[128];
+    snprintf(logBuf, sizeof(logBuf), "wal truncate, from-index:%ld", fromIndex);
+    syncNodeEventLog(pData->pSyncNode, logBuf);
+  } while (0);
+
   return 0;
 }
 
diff --git a/source/libs/sync/src/syncReplication.c b/source/libs/sync/src/syncReplication.c
index da31e9c4c46f3fac3625844b8af69e2a78e49cdd..f1c093fe378f874eaf2c393a7620c8861c8731ac 100644
--- a/source/libs/sync/src/syncReplication.c
+++ b/source/libs/sync/src/syncReplication.c
@@ -148,7 +148,7 @@ int32_t syncNodeAppendEntriesPeersSnapshot2(SSyncNode* pSyncNode) {
     // get entry batch
     int32_t   getCount = 0;
     SyncIndex getEntryIndex = nextIndex;
-    for (int32_t i = 0; i < pSyncNode->batchSize; ++i) {
+    for (int32_t i = 0; i < pSyncNode->pRaftCfg->batchSize; ++i) {
       SSyncRaftEntry* pEntry = NULL;
       int32_t         code = pSyncNode->pLogStore->syncLogGetEntry(pSyncNode->pLogStore, getEntryIndex, &pEntry);
       if (code == 0) {
@@ -162,12 +162,22 @@ int32_t syncNodeAppendEntriesPeersSnapshot2(SSyncNode* pSyncNode) {
       }
     }
 
+    // event log
+    do {
+      char     logBuf[128];
+      char     host[64];
+      uint16_t port;
+      syncUtilU642Addr(pDestId->addr, host, sizeof(host), &port);
+      snprintf(logBuf, sizeof(logBuf), "build batch:%d for %s:%d", getCount, host, port);
+      syncNodeEventLog(pSyncNode, logBuf);
+    } while (0);
+
     // build msg
     SyncAppendEntriesBatch* pMsg = syncAppendEntriesBatchBuild(entryPArr, getCount, pSyncNode->vgId);
     ASSERT(pMsg != NULL);
 
     // free entries
-    for (int32_t i = 0; i < pSyncNode->batchSize; ++i) {
+    for (int32_t i = 0; i < pSyncNode->pRaftCfg->batchSize; ++i) {
       SSyncRaftEntry* pEntry = entryPArr[i];
       if (pEntry != NULL) {
         syncEntryDestory(pEntry);
diff --git a/source/libs/sync/test/CMakeLists.txt b/source/libs/sync/test/CMakeLists.txt
index 37d9707cfd85c395786d68730b149e50e325fe40..e1f3a2b2fc18d1d0481576ccbb3363cf95c5358a 100644
--- a/source/libs/sync/test/CMakeLists.txt
+++ b/source/libs/sync/test/CMakeLists.txt
@@ -54,6 +54,7 @@ add_executable(syncRaftLogTest2 "")
 add_executable(syncRaftLogTest3 "")
 add_executable(syncLeaderTransferTest "")
 add_executable(syncReconfigFinishTest "")
+add_executable(syncRestoreFromSnapshot "")
 
 
 target_sources(syncTest
@@ -280,6 +281,10 @@ target_sources(syncReconfigFinishTest
     PRIVATE
     "syncReconfigFinishTest.cpp"
 )
+target_sources(syncRestoreFromSnapshot
+    PRIVATE
+    "syncRestoreFromSnapshot.cpp"
+)
 
 
 target_include_directories(syncTest
@@ -562,6 +567,11 @@ target_include_directories(syncReconfigFinishTest
     "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
+target_include_directories(syncRestoreFromSnapshot
+    PUBLIC
+    "${TD_SOURCE_DIR}/include/libs/sync"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+)
 
 
 target_link_libraries(syncTest
@@ -788,6 +798,10 @@ target_link_libraries(syncReconfigFinishTest
     sync
     gtest_main
 )
+target_link_libraries(syncRestoreFromSnapshot
+    sync
+    gtest_main
+)
 
 
 enable_testing()
diff --git a/source/libs/sync/test/syncLogStoreTest.cpp b/source/libs/sync/test/syncLogStoreTest.cpp
index 27e1009335a82e42e0d8e8e1b00f8cfe709e9534..9cb8194aa732101cae417bf6402513aec86791ab 100644
--- a/source/libs/sync/test/syncLogStoreTest.cpp
+++ b/source/libs/sync/test/syncLogStoreTest.cpp
@@ -85,6 +85,7 @@ void logStoreTest() {
 }
 
 int main(int argc, char** argv) {
+  gRaftDetailLog = true;
   tsAsyncLog = 0;
   sDebugFlag = DEBUG_TRACE + DEBUG_SCREEN + DEBUG_FILE;
 
diff --git a/source/libs/sync/test/syncRestoreFromSnapshot.cpp b/source/libs/sync/test/syncRestoreFromSnapshot.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..470dd678b09bfd5ff03d9eff3bbe76c1524c06ab
--- /dev/null
+++ b/source/libs/sync/test/syncRestoreFromSnapshot.cpp
@@ -0,0 +1,78 @@
+#include <gtest/gtest.h>
+#include <stdio.h>
+#include "syncEnv.h"
+#include "syncIO.h"
+#include "syncInt.h"
+#include "syncRaftLog.h"
+#include "syncRaftStore.h"
+#include "syncUtil.h"
+#include "wal.h"
+
+void logTest() {
+  sTrace("--- sync log test: trace");
+  sDebug("--- sync log test: debug");
+  sInfo("--- sync log test: info");
+  sWarn("--- sync log test: warn");
+  sError("--- sync log test: error");
+  sFatal("--- sync log test: fatal");
+}
+
+void init() {
+  int code = walInit();
+  assert(code == 0);
+}
+
+void cleanup() { walCleanUp(); }
+
+SWal* createWal(char* path, int32_t vgId) {
+  SWalCfg walCfg;
+  memset(&walCfg, 0, sizeof(SWalCfg));
+  walCfg.vgId = vgId;
+  walCfg.fsyncPeriod = 1000;
+  walCfg.retentionPeriod = 1000;
+  walCfg.rollPeriod = 1000;
+  walCfg.retentionSize = 1000;
+  walCfg.segSize = 1000;
+  walCfg.level = TAOS_WAL_FSYNC;
+  SWal* pWal = walOpen(path, &walCfg);
+  assert(pWal != NULL);
+  return pWal;
+}
+
+SSyncNode* createSyncNode(SWal* pWal) {
+  SSyncNode* pSyncNode = (SSyncNode*)taosMemoryMalloc(sizeof(SSyncNode));
+  memset(pSyncNode, 0, sizeof(SSyncNode));
+  pSyncNode->pWal = pWal;
+  return pSyncNode;
+}
+
+void usage(char* exe) { printf("usage: %s path vgId snapshotIndex \n", exe); }
+
+int main(int argc, char** argv) {
+  if (argc != 4) {
+    usage(argv[0]);
+    exit(-1);
+  }
+  char*   path = argv[1];
+  int32_t vgId = atoi(argv[2]);
+  int64_t snapshotIndex = atoll(argv[3]);
+
+  init();
+  SWal* pWal = createWal(path, vgId);
+  assert(pWal != NULL);
+  SSyncNode* pSyncNode = createSyncNode(pWal);
+  assert(pSyncNode != NULL);
+
+  SSyncLogStore* pLog = logStoreCreate(pSyncNode);
+  assert(pLog != NULL);
+
+  int32_t code = pLog->syncLogRestoreFromSnapshot(pLog, snapshotIndex);
+  assert(code == 0);
+
+  walClose(pWal);
+  logStoreDestory(pLog);
+  taosMemoryFree(pSyncNode);
+
+  cleanup();
+  return 0;
+}
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 94163fb369041f8859f8ceab9bf9c2fe1a2e1eba..6fd3199990dc220f3653bb929435394afee6840b 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -573,8 +573,8 @@ static void cliRecvCb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
     return;
   }
   if (nread < 0) {
-    tError("%s conn %p read error: %s, ref: %d", CONN_GET_INST_LABEL(conn), conn, uv_err_name(nread),
-           T_REF_VAL_GET(conn));
+    tWarn("%s conn %p read error: %s, ref: %d", CONN_GET_INST_LABEL(conn), conn, uv_err_name(nread),
+          T_REF_VAL_GET(conn));
     conn->broken = true;
     cliHandleExcept(conn);
   }
diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c
index 120649f8390c2d1d907aa596308e5aab15e7a881..2624c252a21b5e9a5239785f96b1e755f6f8c576 100644
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@@ -305,7 +305,7 @@ void uvOnRecvCb(uv_stream_t* cli, ssize_t nread, const uv_buf_t* buf) {
     return;
   }
 
-  tError("%s conn %p read error:%s", transLabel(pTransInst), conn, uv_err_name(nread));
+  tWarn("%s conn %p read error:%s", transLabel(pTransInst), conn, uv_err_name(nread));
   if (nread < 0) {
     conn->broken = true;
     if (conn->status == ConnAcquire) {
diff --git a/source/libs/transport/test/CMakeLists.txt b/source/libs/transport/test/CMakeLists.txt
index 98a252e008d85b27206fa58055f757dd02d64a78..5645f49284027c17a2b2abc1f085a3140d57bbe4 100644
--- a/source/libs/transport/test/CMakeLists.txt
+++ b/source/libs/transport/test/CMakeLists.txt
@@ -1,30 +1,16 @@
 add_executable(transportTest "")
-add_executable(client "")
-add_executable(server "")
 add_executable(transUT "")
-add_executable(syncClient "")
 add_executable(pushServer "")
 
 target_sources(transUT
   PRIVATE
   "transUT.cpp"
-)  
+)
+
 target_sources(transportTest 
   PRIVATE
   "transportTests.cpp"
-)  
-target_sources (client
-  PRIVATE
-  "rclient.c" 
-)   
-target_sources (server
-  PRIVATE
-  "rserver.c" 
-)   
-target_sources (syncClient
-  PRIVATE
-  "syncClient.c" 
-)   
+)
 
 target_sources(pushServer
   PRIVATE
@@ -35,7 +21,7 @@ target_include_directories(transportTest
   PUBLIC
   "${TD_SOURCE_DIR}/include/libs/transport" 
   "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
+)
 
 target_link_libraries (transportTest
   os  
@@ -44,64 +30,27 @@ target_link_libraries (transportTest
   gtest_main
   transport 
 )
-target_link_libraries (transUT
-  os  
-  util
-  common
-  gtest_main
-  transport 
-)
-
-target_include_directories(client
-  PUBLIC
-  "${TD_SOURCE_DIR}/include/libs/transport" 
-  "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
 
-target_link_libraries (client
+target_link_libraries (transUT
   os  
   util
   common
   gtest_main
   transport 
 )
-target_include_directories(server
-  PUBLIC
-  "${TD_SOURCE_DIR}/include/libs/transport" 
-  "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
 
 target_include_directories(transUT
   PUBLIC
   "${TD_SOURCE_DIR}/include/libs/transport" 
   "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
-
-target_link_libraries (server
-  os  
-  util
-  common
-  gtest_main
-  transport 
-)
-target_include_directories(syncClient
-  PUBLIC
-  "${TD_SOURCE_DIR}/include/libs/transport" 
-  "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
-target_link_libraries (syncClient
-  os  
-  util
-  common
-  gtest_main
-  transport 
 )
 
 target_include_directories(pushServer
   PUBLIC
   "${TD_SOURCE_DIR}/include/libs/transport" 
   "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-) 
+)
+
 target_link_libraries (pushServer
   os  
   util
@@ -110,7 +59,6 @@ target_link_libraries (pushServer
   transport 
 )
 
-
 add_test(
   NAME transUT 
   COMMAND transUT 
diff --git a/source/libs/transport/test/rclient.c b/source/libs/transport/test/rclient.c
deleted file mode 100644
index 55e6dd000a1270889894fe28f0a024164e5255eb..0000000000000000000000000000000000000000
--- a/source/libs/transport/test/rclient.c
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * 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 <tdatablock.h>
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "transLog.h"
-#include "trpc.h"
-#include "tutil.h"
-
-typedef struct {
-  int      index;
-  SEpSet   epSet;
-  int      num;
-  int      numOfReqs;
-  int      msgSize;
-  tsem_t   rspSem;
-  tsem_t * pOverSem;
-  TdThread thread;
-  void *   pRpc;
-} SInfo;
-static void processResponse(void *pParent, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SInfo *pInfo = (SInfo *)pMsg->info.ahandle;
-  // tError("thread:%d, response is received, type:%d contLen:%d code:0x%x", pInfo->index, pMsg->msgType, pMsg->contLen,
-  //       pMsg->code);
-
-  if (pEpSet) pInfo->epSet = *pEpSet;
-
-  rpcFreeCont(pMsg->pCont);
-  // tsem_post(&pInfo->rspSem);
-  tsem_post(&pInfo->rspSem);
-}
-
-static int tcount = 0;
-
-static void *sendRequest(void *param) {
-  SInfo * pInfo = (SInfo *)param;
-  SRpcMsg rpcMsg = {0};
-
-  tError("thread:%d, start to send request", pInfo->index);
-
-  tError("thread:%d, reqs: %d", pInfo->index, pInfo->numOfReqs);
-  int u100 = 0;
-  int u500 = 0;
-  int u1000 = 0;
-  int u10000 = 0;
-
-  while (pInfo->numOfReqs == 0 || pInfo->num < pInfo->numOfReqs) {
-    pInfo->num++;
-    rpcMsg.pCont = rpcMallocCont(pInfo->msgSize);
-    rpcMsg.contLen = pInfo->msgSize;
-    rpcMsg.info.ahandle = pInfo;
-    rpcMsg.msgType = 1;
-    // tDebug("thread:%d, send request, contLen:%d num:%d", pInfo->index, pInfo->msgSize, pInfo->num);
-    int64_t start = taosGetTimestampUs();
-    rpcSendRequest(pInfo->pRpc, &pInfo->epSet, &rpcMsg, NULL);
-    if (pInfo->num % 20000 == 0) tError("thread:%d, %d requests have been sent", pInfo->index, pInfo->num);
-    // tsem_wait(&pInfo->rspSem);
-    tsem_wait(&pInfo->rspSem);
-    int64_t end = taosGetTimestampUs() - start;
-    if (end <= 100) {
-      u100++;
-    } else if (end > 100 && end <= 500) {
-      u500++;
-    } else if (end > 500 && end < 1000) {
-      u1000++;
-    } else {
-      u10000++;
-    }
-
-    tDebug("recv response succefully");
-
-    // taosSsleep(100);
-  }
-
-  tError("send and recv sum: %d, %d, %d, %d", u100, u500, u1000, u10000);
-  tError("thread:%d, it is over", pInfo->index);
-  tcount++;
-
-  return NULL;
-}
-
-int main(int argc, char *argv[]) {
-  SRpcInit       rpcInit;
-  SEpSet         epSet = {0};
-  int            msgSize = 128;
-  int            numOfReqs = 0;
-  int            appThreads = 1;
-  char           serverIp[40] = "127.0.0.1";
-  char           secret[20] = "mypassword";
-  struct timeval systemTime;
-  int64_t        startTime, endTime;
-  TdThreadAttr   thattr;
-
-  // server info
-  epSet.inUse = 0;
-  addEpIntoEpSet(&epSet, serverIp, 7000);
-  addEpIntoEpSet(&epSet, "192.168.0.1", 7000);
-
-  // client info
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localPort = 0;
-  rpcInit.label = "APP";
-  rpcInit.numOfThreads = 1;
-  rpcInit.cfp = processResponse;
-  rpcInit.sessions = 100;
-  rpcInit.idleTime = 100;
-  rpcInit.user = "michael";
-  rpcInit.connType = TAOS_CONN_CLIENT;
-  rpcDebugFlag = 131;
-
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "-p") == 0 && i < argc - 1) {
-      epSet.eps[0].port = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-i") == 0 && i < argc - 1) {
-      tstrncpy(epSet.eps[0].fqdn, argv[++i], sizeof(epSet.eps[0].fqdn));
-    } else if (strcmp(argv[i], "-t") == 0 && i < argc - 1) {
-      rpcInit.numOfThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-m") == 0 && i < argc - 1) {
-      msgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-s") == 0 && i < argc - 1) {
-      rpcInit.sessions = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-n") == 0 && i < argc - 1) {
-      numOfReqs = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-a") == 0 && i < argc - 1) {
-      appThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-o") == 0 && i < argc - 1) {
-      tsCompressMsgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-u") == 0 && i < argc - 1) {
-      rpcInit.user = argv[++i];
-    } else if (strcmp(argv[i], "-k") == 0 && i < argc - 1) {
-    } else if (strcmp(argv[i], "-spi") == 0 && i < argc - 1) {
-    } else if (strcmp(argv[i], "-d") == 0 && i < argc - 1) {
-      rpcDebugFlag = atoi(argv[++i]);
-    } else {
-      printf("\nusage: %s [options] \n", argv[0]);
-      printf("  [-i ip]: first server IP address, default is:%s\n", serverIp);
-      printf("  [-p port]: server port number, default is:%d\n", epSet.eps[0].port);
-      printf("  [-t threads]: number of rpc threads, default is:%d\n", rpcInit.numOfThreads);
-      printf("  [-s sessions]: number of rpc sessions, default is:%d\n", rpcInit.sessions);
-      printf("  [-m msgSize]: message body size, default is:%d\n", msgSize);
-      printf("  [-a threads]: number of app threads, default is:%d\n", appThreads);
-      printf("  [-n requests]: number of requests per thread, default is:%d\n", numOfReqs);
-      printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
-      printf("  [-u user]: user name for the connection, default is:%s\n", rpcInit.user);
-      printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
-      printf("  [-h help]: print out this help\n\n");
-      exit(0);
-    }
-  }
-
-  const char *path = TD_TMP_DIR_PATH "transport/client";
-  taosRemoveDir(path);
-  taosMkDir(path);
-  tstrncpy(tsLogDir, path, PATH_MAX);
-  taosInitLog("client.log", 10);
-
-  void *pRpc = rpcOpen(&rpcInit);
-  if (pRpc == NULL) {
-    tError("failed to initialize RPC");
-    return -1;
-  }
-
-  tError("client is initialized");
-  tError("threads:%d msgSize:%d requests:%d", appThreads, msgSize, numOfReqs);
-
-  taosGetTimeOfDay(&systemTime);
-  startTime = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-
-  SInfo *pInfo = (SInfo *)taosMemoryCalloc(1, sizeof(SInfo) * appThreads);
-
-  taosThreadAttrInit(&thattr);
-  taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
-
-  for (int i = 0; i < appThreads; ++i) {
-    pInfo->index = i;
-    pInfo->epSet = epSet;
-    pInfo->numOfReqs = numOfReqs;
-    pInfo->msgSize = msgSize;
-    tsem_init(&pInfo->rspSem, 0, 0);
-    pInfo->pRpc = pRpc;
-    taosThreadCreate(&pInfo->thread, &thattr, sendRequest, pInfo);
-    pInfo++;
-  }
-
-  do {
-    taosUsleep(1);
-  } while (tcount < appThreads);
-
-  taosGetTimeOfDay(&systemTime);
-  endTime = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-  float usedTime = (endTime - startTime) / 1000.0f;  // mseconds
-
-  tError("it takes %.3f mseconds to send %d requests to server", usedTime, numOfReqs * appThreads);
-  tError("Performance: %.3f requests per second, msgSize:%d bytes", 1000.0 * numOfReqs * appThreads / usedTime,
-         msgSize);
-
-  int ch = getchar();
-  UNUSED(ch);
-
-  taosCloseLog();
-
-  return 0;
-}
diff --git a/source/libs/transport/test/rsclient.c b/source/libs/transport/test/rsclient.c
deleted file mode 100644
index e7fc7b45e1ed74b3a8d82983ba381757cadfc831..0000000000000000000000000000000000000000
--- a/source/libs/transport/test/rsclient.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * 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 "os.h"
-#include "tutil.h"
-#include "tglobal.h"
-#include "rpcLog.h"
-#include "trpc.h"
-#include "taoserror.h"
-
-typedef struct {
-  int       index;
-  SRpcEpSet epSet;
-  int       num;
-  int       numOfReqs;
-  int       msgSize;
-  tsem_t    rspSem; 
-  tsem_t   *pOverSem; 
-  TdThread thread;
-  void     *pRpc;
-} SInfo;
-
-
-static int tcount = 0;
-static int terror = 0;
-
-static void *sendRequest(void *param) {
-  SInfo  *pInfo = (SInfo *)param;
-  SRpcMsg rpcMsg, rspMsg;
-
-  tDebug("thread:%d, start to send request", pInfo->index);
-
-  while ( pInfo->numOfReqs == 0 || pInfo->num < pInfo->numOfReqs) {
-    pInfo->num++;
-    rpcMsg.pCont = rpcMallocCont(pInfo->msgSize);
-    rpcMsg.contLen = pInfo->msgSize;
-    rpcMsg.handle = pInfo;
-    rpcMsg.msgType = 1;
-    tDebug("thread:%d, send request, contLen:%d num:%d", pInfo->index, pInfo->msgSize, pInfo->num);
-
-    rpcSendRecv(pInfo->pRpc, &pInfo->epSet, &rpcMsg, &rspMsg);
-    
-    // handle response
-    if (rspMsg.code != 0) terror++;
-
-    tDebug("thread:%d, rspLen:%d code:%d", pInfo->index, rspMsg.contLen, rspMsg.code);
-
-    rpcFreeCont(rspMsg.pCont);
-
-    if ( pInfo->num % 20000 == 0 ) 
-      tInfo("thread:%d, %d requests have been sent", pInfo->index, pInfo->num);
-  }
-
-  tDebug("thread:%d, it is over", pInfo->index);
-  tcount++;
-
-  return NULL;
-}
-
-int main(int argc, char *argv[]) {
-  SRpcInit  rpcInit;
-  SRpcEpSet epSet;
-  int      msgSize = 128;
-  int      numOfReqs = 0;
-  int      appThreads = 1;
-  char     serverIp[40] = "127.0.0.1";
-  char     secret[TSDB_KEY_LEN] = "mypassword";
-  struct   timeval systemTime;
-  int64_t  startTime, endTime;
-  TdThreadAttr thattr;
-
-  // server info
-  epSet.numOfEps = 1;
-  epSet.inUse = 0;
-  epSet.port[0] = 7000;
-  epSet.port[1] = 7000;
-  strcpy(epSet.fqdn[0], serverIp);
-  strcpy(epSet.fqdn[1], "192.168.0.1");
-
-  // client info
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  //rpcInit.localIp      = "0.0.0.0";
-  rpcInit.localPort    = 0;
-  rpcInit.label        = "APP";
-  rpcInit.numOfThreads = 1;
-  rpcInit.sessions     = 100;
-  rpcInit.idleTime     = 3000; //tsShellActivityTimer*1000;
-  rpcInit.user         = "michael";
-  rpcInit.secret       = secret;
-  rpcInit.ckey         = "key";
-  rpcInit.spi          = 1;
-  rpcInit.connType     = TAOS_CONN_CLIENT;
-
-  for (int i=1; i<argc; ++i) { 
-    if (strcmp(argv[i], "-p")==0 && i < argc-1) {
-      epSet.port[0] = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-i") ==0 && i < argc-1) {
-      tstrncpy(epSet.fqdn[0], argv[++i], sizeof(epSet.fqdn[0])); 
-    } else if (strcmp(argv[i], "-t")==0 && i < argc-1) {
-      rpcInit.numOfThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-m")==0 && i < argc-1) {
-      msgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-s")==0 && i < argc-1) {
-      rpcInit.sessions = atoi(argv[++i]); 
-    } else if (strcmp(argv[i], "-n")==0 && i < argc-1) {
-      numOfReqs = atoi(argv[++i]); 
-    } else if (strcmp(argv[i], "-a")==0 && i < argc-1) {
-      appThreads = atoi(argv[++i]); 
-    } else if (strcmp(argv[i], "-o")==0 && i < argc-1) {
-      tsCompressMsgSize = atoi(argv[++i]); 
-    } else if (strcmp(argv[i], "-u")==0 && i < argc-1) {
-      rpcInit.user = argv[++i];
-    } else if (strcmp(argv[i], "-k")==0 && i < argc-1) {
-      rpcInit.secret = argv[++i];
-    } else if (strcmp(argv[i], "-spi")==0 && i < argc-1) {
-      rpcInit.spi = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-d")==0 && i < argc-1) {
-      rpcDebugFlag = atoi(argv[++i]);
-    } else {
-      printf("\nusage: %s [options] \n", argv[0]);
-      printf("  [-i ip]: first server IP address, default is:%s\n", serverIp);
-      printf("  [-p port]: server port number, default is:%d\n", epSet.port[0]);
-      printf("  [-t threads]: number of rpc threads, default is:%d\n", rpcInit.numOfThreads);
-      printf("  [-s sessions]: number of rpc sessions, default is:%d\n", rpcInit.sessions);
-      printf("  [-m msgSize]: message body size, default is:%d\n", msgSize);
-      printf("  [-a threads]: number of app threads, default is:%d\n", appThreads);
-      printf("  [-n requests]: number of requests per thread, default is:%d\n", numOfReqs);
-      printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
-      printf("  [-u user]: user name for the connection, default is:%s\n", rpcInit.user);
-      printf("  [-k secret]: password for the connection, default is:%s\n", rpcInit.secret);
-      printf("  [-spi SPI]: security parameter index, default is:%d\n", rpcInit.spi);
-      printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
-      printf("  [-h help]: print out this help\n\n");
-      exit(0);
-    }
-  }
-
-  taosInitLog("client.log", 10);
-
-  void *pRpc = rpcOpen(&rpcInit);
-  if (pRpc == NULL) {
-    tError("failed to initialize RPC");
-    return -1;
-  }
-
-  tInfo("client is initialized");
-
-  taosGetTimeOfDay(&systemTime);
-  startTime = systemTime.tv_sec*1000000 + systemTime.tv_usec;
-
-  SInfo *pInfo = (SInfo *)taosMemoryCalloc(1, sizeof(SInfo)*appThreads);
- 
-  taosThreadAttrInit(&thattr);
-  taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
-
-  for (int i=0; i<appThreads; ++i) {
-    pInfo->index = i;
-    pInfo->epSet = epSet;
-    pInfo->numOfReqs = numOfReqs;
-    pInfo->msgSize = msgSize;
-    tsem_init(&pInfo->rspSem, 0, 0);
-    pInfo->pRpc = pRpc;
-    taosThreadCreate(&pInfo->thread, &thattr, sendRequest, pInfo);
-    pInfo++;
-  }
-
-  do {
-    taosUsleep(1);
-  } while ( tcount < appThreads);
-
-  taosGetTimeOfDay(&systemTime);
-  endTime = systemTime.tv_sec*1000000 + systemTime.tv_usec;  
-  float usedTime = (endTime - startTime)/1000.0;  // mseconds
-
-  tInfo("it takes %.3f mseconds to send %d requests to server, error num:%d", usedTime, numOfReqs*appThreads, terror);
-  tInfo("Performance: %.3f requests per second, msgSize:%d bytes", 1000.0*numOfReqs*appThreads/usedTime, msgSize);
-
-  taosCloseLog();
-
-  return 0;
-}
-
-
diff --git a/source/libs/transport/test/rserver.c b/source/libs/transport/test/rserver.c
deleted file mode 100644
index 1fd78be77de7575d47e3d2ce70bf6e0908dfec8e..0000000000000000000000000000000000000000
--- a/source/libs/transport/test/rserver.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * 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/>.
- */
-
-//#define _DEFAULT_SOURCE
-#include "os.h"
-#include "tglobal.h"
-#include "tqueue.h"
-#include "transLog.h"
-#include "trpc.h"
-
-int         msgSize = 128;
-int         commit = 0;
-TdFilePtr   pDataFile = NULL;
-STaosQueue *qhandle = NULL;
-STaosQset * qset = NULL;
-
-void processShellMsg() {
-  static int num = 0;
-  STaosQall *qall;
-  SRpcMsg *  pRpcMsg, rpcMsg;
-  int        type;
-  void *     pvnode;
-
-  qall = taosAllocateQall();
-
-  while (1) {
-    int numOfMsgs = taosReadAllQitemsFromQset(qset, qall, &pvnode, NULL);
-    tDebug("%d shell msgs are received", numOfMsgs);
-    if (numOfMsgs <= 0) break;
-
-    for (int i = 0; i < numOfMsgs; ++i) {
-      taosGetQitem(qall, (void **)&pRpcMsg);
-
-      if (pDataFile != NULL) {
-        if (taosWriteFile(pDataFile, pRpcMsg->pCont, pRpcMsg->contLen) < 0) {
-          tInfo("failed to write data file, reason:%s", strerror(errno));
-        }
-      }
-    }
-
-    if (commit >= 2) {
-      num += numOfMsgs;
-      // if (taosFsync(pDataFile) < 0) {
-      //  tInfo("failed to flush data to file, reason:%s", strerror(errno));
-      //}
-
-      if (num % 10000 == 0) {
-        tInfo("%d request have been written into disk", num);
-      }
-    }
-
-    taosResetQitems(qall);
-    for (int i = 0; i < numOfMsgs; ++i) {
-      taosGetQitem(qall, (void **)&pRpcMsg);
-      rpcFreeCont(pRpcMsg->pCont);
-
-      memset(&rpcMsg, 0, sizeof(rpcMsg));
-      rpcMsg.pCont = rpcMallocCont(msgSize);
-      rpcMsg.contLen = msgSize;
-      rpcMsg.info = pRpcMsg->info;
-      rpcMsg.code = 0;
-      rpcSendResponse(&rpcMsg);
-
-      taosFreeQitem(pRpcMsg);
-    }
-  }
-
-  taosFreeQall(qall);
-}
-
-int retrieveAuthInfo(void *parent, char *meterId, char *spi, char *encrypt, char *secret, char *ckey) {
-  // app shall retrieve the auth info based on meterID from DB or a data file
-  // demo code here only for simple demo
-  int ret = 0;
-
-  if (strcmp(meterId, "michael") == 0) {
-    *spi = 1;
-    *encrypt = 0;
-    strcpy(secret, "mypassword");
-    strcpy(ckey, "key");
-  } else if (strcmp(meterId, "jeff") == 0) {
-    *spi = 0;
-    *encrypt = 0;
-  } else {
-    ret = -1;  // user not there
-  }
-
-  return ret;
-}
-
-void processRequestMsg(void *pParent, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SRpcMsg *pTemp;
-
-  pTemp = taosAllocateQitem(sizeof(SRpcMsg), DEF_QITEM);
-  memcpy(pTemp, pMsg, sizeof(SRpcMsg));
-
-  tDebug("request is received, type:%d, contLen:%d, item:%p", pMsg->msgType, pMsg->contLen, pTemp);
-  taosWriteQitem(qhandle, pTemp);
-}
-
-int main(int argc, char *argv[]) {
-  SRpcInit rpcInit;
-  char     dataName[20] = "server.data";
-
-  taosBlockSIGPIPE();
-
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localPort = 7000;
-  rpcInit.label = "SER";
-  rpcInit.numOfThreads = 1;
-  rpcInit.cfp = processRequestMsg;
-  rpcInit.sessions = 1000;
-  rpcInit.idleTime = 2 * 1500;
-
-  rpcDebugFlag = 131;
-
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "-p") == 0 && i < argc - 1) {
-      rpcInit.localPort = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-t") == 0 && i < argc - 1) {
-      rpcInit.numOfThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-m") == 0 && i < argc - 1) {
-      msgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-s") == 0 && i < argc - 1) {
-      rpcInit.sessions = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-o") == 0 && i < argc - 1) {
-      tsCompressMsgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-w") == 0 && i < argc - 1) {
-      commit = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-d") == 0 && i < argc - 1) {
-      rpcDebugFlag = atoi(argv[++i]);
-      dDebugFlag = rpcDebugFlag;
-      uDebugFlag = rpcDebugFlag;
-    } else {
-      printf("\nusage: %s [options] \n", argv[0]);
-      printf("  [-p port]: server port number, default is:%d\n", rpcInit.localPort);
-      printf("  [-t threads]: number of rpc threads, default is:%d\n", rpcInit.numOfThreads);
-      printf("  [-s sessions]: number of sessions, default is:%d\n", rpcInit.sessions);
-      printf("  [-m msgSize]: message body size, default is:%d\n", msgSize);
-      printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
-      printf("  [-w write]: write received data to file(0, 1, 2), default is:%d\n", commit);
-      printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
-      printf("  [-h help]: print out this help\n\n");
-      exit(0);
-    }
-  }
-
-  tsAsyncLog = 0;
-  rpcInit.connType = TAOS_CONN_SERVER;
-
-  const char *path = TD_TMP_DIR_PATH "transport/server";
-  taosRemoveDir(path);
-  taosMkDir(path);
-  tstrncpy(tsLogDir, path, PATH_MAX);
-  taosInitLog("server.log", 10);
-
-  void *pRpc = rpcOpen(&rpcInit);
-  if (pRpc == NULL) {
-    tError("failed to start RPC server");
-    return -1;
-  }
-  // sleep(5);
-
-  tInfo("RPC server is running, ctrl-c to exit");
-
-  if (commit) {
-    pDataFile = taosOpenFile(dataName, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
-    if (pDataFile == NULL) tInfo("failed to open data file, reason:%s", strerror(errno));
-  }
-  qhandle = taosOpenQueue();
-  qset = taosOpenQset();
-  taosAddIntoQset(qset, qhandle, NULL);
-
-  processShellMsg();
-
-  if (pDataFile != NULL) {
-    taosCloseFile(&pDataFile);
-    taosRemoveFile(dataName);
-  }
-
-  return 0;
-}
diff --git a/source/libs/transport/test/syncClient.c b/source/libs/transport/test/syncClient.c
deleted file mode 100644
index bc6461eaed1f5d2c7ca9d82f9ae47dbebf4fc02b..0000000000000000000000000000000000000000
--- a/source/libs/transport/test/syncClient.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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 <tdatablock.h>
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "transLog.h"
-#include "trpc.h"
-#include "tutil.h"
-
-typedef struct {
-  int      index;
-  SEpSet   epSet;
-  int      num;
-  int      numOfReqs;
-  int      msgSize;
-  tsem_t   rspSem;
-  tsem_t * pOverSem;
-  TdThread thread;
-  void *   pRpc;
-} SInfo;
-static void processResponse(void *pParent, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SInfo *pInfo = (SInfo *)pMsg->info.ahandle;
-  tDebug("thread:%d, response is received, type:%d contLen:%d code:0x%x", pInfo->index, pMsg->msgType, pMsg->contLen,
-         pMsg->code);
-
-  if (pEpSet) pInfo->epSet = *pEpSet;
-
-  rpcFreeCont(pMsg->pCont);
-  // tsem_post(&pInfo->rspSem);
-  tsem_post(&pInfo->rspSem);
-}
-
-static int tcount = 0;
-
-static void *sendRequest(void *param) {
-  SInfo * pInfo = (SInfo *)param;
-  SRpcMsg rpcMsg = {0};
-
-  tDebug("thread:%d, start to send request", pInfo->index);
-
-  tDebug("thread:%d, reqs: %d", pInfo->index, pInfo->numOfReqs);
-  int     u100 = 0;
-  int     u500 = 0;
-  int     u1000 = 0;
-  int     u10000 = 0;
-  SRpcMsg respMsg = {0};
-  while (pInfo->numOfReqs == 0 || pInfo->num < pInfo->numOfReqs) {
-    pInfo->num++;
-    rpcMsg.pCont = rpcMallocCont(pInfo->msgSize);
-    rpcMsg.contLen = pInfo->msgSize;
-    rpcMsg.info.ahandle = pInfo;
-    rpcMsg.msgType = 1;
-    // tDebug("thread:%d, send request, contLen:%d num:%d", pInfo->index, pInfo->msgSize, pInfo->num);
-    int64_t start = taosGetTimestampUs();
-    rpcSendRecv(pInfo->pRpc, &pInfo->epSet, &rpcMsg, &respMsg);
-    // rpcSendRequest(pInfo->pRpc, &pInfo->epSet, &rpcMsg, NULL);
-    if (pInfo->num % 20000 == 0) tInfo("thread:%d, %d requests have been sent", pInfo->index, pInfo->num);
-    // tsem_wait(&pInfo->rspSem);
-    // wtsem_wait(&pInfo->rspSem);
-    int64_t end = taosGetTimestampUs() - start;
-    if (end <= 100) {
-      u100++;
-    } else if (end > 100 && end <= 500) {
-      u500++;
-    } else if (end > 500 && end < 1000) {
-      u1000++;
-    } else {
-      u10000++;
-    }
-
-    tDebug("recv response succefully");
-
-    // taosSsleep(100);
-  }
-
-  tError("send and recv sum: %d, %d, %d, %d", u100, u500, u1000, u10000);
-  tDebug("thread:%d, it is over", pInfo->index);
-  tcount++;
-
-  return NULL;
-}
-
-int main(int argc, char *argv[]) {
-  SRpcInit       rpcInit;
-  SEpSet         epSet = {0};
-  int            msgSize = 128;
-  int            numOfReqs = 0;
-  int            appThreads = 1;
-  char           serverIp[40] = "127.0.0.1";
-  char           secret[20] = "mypassword";
-  struct timeval systemTime;
-  int64_t        startTime, endTime;
-  TdThreadAttr   thattr;
-
-  // server info
-  epSet.inUse = 0;
-  addEpIntoEpSet(&epSet, serverIp, 7000);
-  addEpIntoEpSet(&epSet, "192.168.0.1", 7000);
-
-  // client info
-  memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localPort = 0;
-  rpcInit.label = "APP";
-  rpcInit.numOfThreads = 1;
-  rpcInit.cfp = processResponse;
-  rpcInit.sessions = 100;
-  rpcInit.idleTime = 100;
-  rpcInit.user = "michael";
-  rpcInit.connType = TAOS_CONN_CLIENT;
-
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "-p") == 0 && i < argc - 1) {
-      epSet.eps[0].port = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-i") == 0 && i < argc - 1) {
-      tstrncpy(epSet.eps[0].fqdn, argv[++i], sizeof(epSet.eps[0].fqdn));
-    } else if (strcmp(argv[i], "-t") == 0 && i < argc - 1) {
-      rpcInit.numOfThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-m") == 0 && i < argc - 1) {
-      msgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-s") == 0 && i < argc - 1) {
-      rpcInit.sessions = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-n") == 0 && i < argc - 1) {
-      numOfReqs = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-a") == 0 && i < argc - 1) {
-      appThreads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-o") == 0 && i < argc - 1) {
-      tsCompressMsgSize = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-u") == 0 && i < argc - 1) {
-      rpcInit.user = argv[++i];
-    } else if (strcmp(argv[i], "-k") == 0 && i < argc - 1) {
-    } else if (strcmp(argv[i], "-spi") == 0 && i < argc - 1) {
-    } else if (strcmp(argv[i], "-d") == 0 && i < argc - 1) {
-      rpcDebugFlag = atoi(argv[++i]);
-    } else {
-      printf("\nusage: %s [options] \n", argv[0]);
-      printf("  [-i ip]: first server IP address, default is:%s\n", serverIp);
-      printf("  [-p port]: server port number, default is:%d\n", epSet.eps[0].port);
-      printf("  [-t threads]: number of rpc threads, default is:%d\n", rpcInit.numOfThreads);
-      printf("  [-s sessions]: number of rpc sessions, default is:%d\n", rpcInit.sessions);
-      printf("  [-m msgSize]: message body size, default is:%d\n", msgSize);
-      printf("  [-a threads]: number of app threads, default is:%d\n", appThreads);
-      printf("  [-n requests]: number of requests per thread, default is:%d\n", numOfReqs);
-      printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
-      printf("  [-u user]: user name for the connection, default is:%s\n", rpcInit.user);
-      printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
-      printf("  [-h help]: print out this help\n\n");
-      exit(0);
-    }
-  }
-
-  taosInitLog("client.log", 10);
-
-  void *pRpc = rpcOpen(&rpcInit);
-  if (pRpc == NULL) {
-    tError("failed to initialize RPC");
-    return -1;
-  }
-
-  tInfo("client is initialized");
-  tInfo("threads:%d msgSize:%d requests:%d", appThreads, msgSize, numOfReqs);
-
-  taosGetTimeOfDay(&systemTime);
-  startTime = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-
-  SInfo *pInfo = (SInfo *)taosMemoryCalloc(1, sizeof(SInfo) * appThreads);
-
-  taosThreadAttrInit(&thattr);
-  taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
-
-  for (int i = 0; i < appThreads; ++i) {
-    pInfo->index = i;
-    pInfo->epSet = epSet;
-    pInfo->numOfReqs = numOfReqs;
-    pInfo->msgSize = msgSize;
-    tsem_init(&pInfo->rspSem, 0, 0);
-    pInfo->pRpc = pRpc;
-    taosThreadCreate(&pInfo->thread, &thattr, sendRequest, pInfo);
-    pInfo++;
-  }
-
-  do {
-    taosUsleep(1);
-  } while (tcount < appThreads);
-
-  taosGetTimeOfDay(&systemTime);
-  endTime = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-  float usedTime = (endTime - startTime) / 1000.0f;  // mseconds
-
-  tInfo("it takes %.3f mseconds to send %d requests to server", usedTime, numOfReqs * appThreads);
-  tInfo("Performance: %.3f requests per second, msgSize:%d bytes", 1000.0 * numOfReqs * appThreads / usedTime, msgSize);
-
-  int ch = getchar();
-  UNUSED(ch);
-
-  taosCloseLog();
-
-  return 0;
-}
diff --git a/source/os/src/osStrptime.c b/source/os/src/osStrptime.c
deleted file mode 100644
index 8d878577ea2f30afbef3dd44cd3503b28e646ef7..0000000000000000000000000000000000000000
--- a/source/os/src/osStrptime.c
+++ /dev/null
@@ -1,405 +0,0 @@
-/*	$Id$	*/
-/*	$NetBSD: strptime.c,v 1.18 1999/04/29 02:58:30 tv Exp $	*/
-
-/*-
-* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
-* All rights reserved.
-*
-* This code was contributed to The NetBSD Foundation by Klaus Klein.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions
-* are met:
-* 1. Redistributions of source code must retain the above copyright
-*    notice, this list of conditions and the following disclaimer.
-* 2. Redistributions in binary form must reproduce the above copyright
-*    notice, this list of conditions and the following disclaimer in the
-*    documentation and/or other materials provided with the distribution.
-* 3. All advertising materials mentioning features or use of this software
-*    must display the following acknowledgement:
-*        This product includes software developed by the NetBSD
-*        Foundation, Inc. and its contributors.
-* 4. Neither the name of The NetBSD Foundation nor the names of its
-*    contributors may be used to endorse or promote products derived
-*    from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
-* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
-* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-* POSSIBILITY OF SUCH DAMAGE.
-*/
-//
-//#include "lukemftp.h"
-
-// #ifdef WINDOWS
-
-// #include <time.h>  
-// #include <stdlib.h>  
-// #include <string.h>
-// #include <winsock2.h>
-// //#define TM_YEAR_BASE 1970 //origin
-// #define TM_YEAR_BASE 1900 //slguan
-// /*
-// * We do not implement alternate representations. However, we always
-// * check whether a given modifier is allowed for a certain conversion.
-// */
-// #define ALT_E			0x01
-// #define ALT_O			0x02
-// #define	LEGAL_ALT(x)		{ if (alt_format & ~(x)) return (0); }
-
-
-// static int conv_num(const char **buf, int *dest, int llim, int ulim)
-// {
-//     int result = 0;
-
-//     /* The limit also determines the number of valid digits. */
-//     int rulim = ulim;
-
-//     if (**buf < '0' || **buf > '9')
-//         return (0);
-
-//     do {
-//         result *= 10;
-//         result += *(*buf)++ - '0';
-//         rulim /= 10;
-//     } while ((result * 10 <= ulim) && rulim && **buf >= '0' && **buf <= '9');
-
-//     if (result < llim || result > ulim)
-//         return (0);
-
-//     *dest = result;
-//     return (1);
-// }
-
-// static const char *day[7] = {
-//     "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
-//     "Friday", "Saturday"
-// };
-// static const char *abday[7] = {
-//     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-// };
-// static const char *mon[12] = {
-//     "January", "February", "March", "April", "May", "June", "July",
-//     "August", "September", "October", "November", "December"
-// };
-// static const char *abmon[12] = {
-//     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-//     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-// };
-// static const char *am_pm[2] = {
-//     "AM", "PM"
-// };
-
-// #endif
-
-// char *taosStrpTime(const char *buf, const char *fmt, struct tm *tm) {
-// #ifdef WINDOWS
-//     char c;
-//     const char *bp;
-//     size_t len = 0;
-//     int alt_format, i, split_year = 0;
-
-//     bp = buf;
-
-//     while ((c = *fmt) != '\0') {
-//         /* Clear `alternate' modifier prior to new conversion. */
-//         alt_format = 0;
-
-//         /* Eat up white-space. */
-//         if (isspace(c)) {
-//             while (isspace(*bp))
-//                 bp++;
-
-//             fmt++;
-//             continue;
-//         }
-
-//         if ((c = *fmt++) != '%')
-//             goto literal;
-
-
-//     again:		switch (c = *fmt++) {
-//     case '%':	/* "%%" is converted to "%". */
-//         literal :
-//             if (c != *bp++)
-//                 return (0);
-//         break;
-
-//         /*
-//         * "Alternative" modifiers. Just set the appropriate flag
-//         * and start over again.
-//         */
-//     case 'E':	/* "%E?" alternative conversion modifier. */
-//         LEGAL_ALT(0);
-//         alt_format |= ALT_E;
-//         goto again;
-
-//     case 'O':	/* "%O?" alternative conversion modifier. */
-//         LEGAL_ALT(0);
-//         alt_format |= ALT_O;
-//         goto again;
-
-//         /*
-//         * "Complex" conversion rules, implemented through recursion.
-//         */
-//     case 'c':	/* Date and time, using the locale's format. */
-//         LEGAL_ALT(ALT_E);
-//         if (!(bp = taosStrpTime(bp, "%x %X", tm)))
-//             return (0);
-//         break;
-
-//     case 'D':	/* The date as "%m/%d/%y". */
-//         LEGAL_ALT(0);
-//         if (!(bp = taosStrpTime(bp, "%m/%d/%y", tm)))
-//             return (0);
-//         break;
-
-//     case 'R':	/* The time as "%H:%M". */
-//         LEGAL_ALT(0);
-//         if (!(bp = taosStrpTime(bp, "%H:%M", tm)))
-//             return (0);
-//         break;
-
-//     case 'r':	/* The time in 12-hour clock representation. */
-//         LEGAL_ALT(0);
-//         if (!(bp = taosStrpTime(bp, "%I:%M:%S %p", tm)))
-//             return (0);
-//         break;
-
-//     case 'T':	/* The time as "%H:%M:%S". */
-//         LEGAL_ALT(0);
-//         if (!(bp = taosStrpTime(bp, "%H:%M:%S", tm)))
-//             return (0);
-//         break;
-
-//     case 'X':	/* The time, using the locale's format. */
-//         LEGAL_ALT(ALT_E);
-//         if (!(bp = taosStrpTime(bp, "%H:%M:%S", tm)))
-//             return (0);
-//         break;
-
-//     case 'x':	/* The date, using the locale's format. */
-//         LEGAL_ALT(ALT_E);
-//         if (!(bp = taosStrpTime(bp, "%m/%d/%y", tm)))
-//             return (0);
-//         break;
-
-//         /*
-//         * "Elementary" conversion rules.
-//         */
-//     case 'A':	/* The day of week, using the locale's form. */
-//     case 'a':
-//         LEGAL_ALT(0);
-//         for (i = 0; i < 7; i++) {
-//             /* Full name. */
-//             len = strlen(day[i]);
-//             if (strncmp(day[i], bp, len) == 0)
-//                 break;
-
-//             /* Abbreviated name. */
-//             len = strlen(abday[i]);
-//             if (strncmp(abday[i], bp, len) == 0)
-//                 break;
-//         }
-
-//         /* Nothing matched. */
-//         if (i == 7)
-//             return (0);
-
-//         tm->tm_wday = i;
-//         bp += len;
-//         break;
-
-//     case 'B':	/* The month, using the locale's form. */
-//     case 'b':
-//     case 'h':
-//         LEGAL_ALT(0);
-//         for (i = 0; i < 12; i++) {
-//             /* Full name. */
-//             len = strlen(mon[i]);
-//             if (strncmp(mon[i], bp, len) == 0)
-//                 break;
-
-//             /* Abbreviated name. */
-//             len = strlen(abmon[i]);
-//             if (strncmp(abmon[i], bp, len) == 0)
-//                 break;
-//         }
-
-//         /* Nothing matched. */
-//         if (i == 12)
-//             return (0);
-
-//         tm->tm_mon = i;
-//         bp += len;
-//         break;
-
-//     case 'C':	/* The century number. */
-//         LEGAL_ALT(ALT_E);
-//         if (!(conv_num(&bp, &i, 0, 99)))
-//             return (0);
-
-//         if (split_year) {
-//             tm->tm_year = (tm->tm_year % 100) + (i * 100);
-//         }
-//         else {
-//             tm->tm_year = i * 100;
-//             split_year = 1;
-//         }
-//         break;
-
-//     case 'd':	/* The day of month. */
-//     case 'e':
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_mday, 1, 31)))
-//             return (0);
-//         break;
-
-//     case 'k':	/* The hour (24-hour clock representation). */
-//         LEGAL_ALT(0);
-//         /* FALLTHROUGH */
-//     case 'H':
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_hour, 0, 23)))
-//             return (0);
-//         break;
-
-//     case 'l':	/* The hour (12-hour clock representation). */
-//         LEGAL_ALT(0);
-//         /* FALLTHROUGH */
-//     case 'I':
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_hour, 1, 12)))
-//             return (0);
-//         if (tm->tm_hour == 12)
-//             tm->tm_hour = 0;
-//         break;
-
-//     case 'j':	/* The day of year. */
-//         LEGAL_ALT(0);
-//         if (!(conv_num(&bp, &i, 1, 366)))
-//             return (0);
-//         tm->tm_yday = i - 1;
-//         break;
-
-//     case 'M':	/* The minute. */
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_min, 0, 59)))
-//             return (0);
-//         break;
-
-//     case 'm':	/* The month. */
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &i, 1, 12)))
-//             return (0);
-//         tm->tm_mon = i - 1;
-//         break;
-
-//     case 'p':	/* The locale's equivalent of AM/PM. */
-//         LEGAL_ALT(0);
-//         /* AM? */
-//         if (strcmp(am_pm[0], bp) == 0) {
-//             if (tm->tm_hour > 11)
-//                 return (0);
-
-//             bp += strlen(am_pm[0]);
-//             break;
-//         }
-//         /* PM? */
-//         else if (strcmp(am_pm[1], bp) == 0) {
-//             if (tm->tm_hour > 11)
-//                 return (0);
-
-//             tm->tm_hour += 12;
-//             bp += strlen(am_pm[1]);
-//             break;
-//         }
-
-//         /* Nothing matched. */
-//         return (0);
-
-//     case 'S':	/* The seconds. */
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_sec, 0, 61)))
-//             return (0);
-//         break;
-
-//     case 'U':	/* The week of year, beginning on sunday. */
-//     case 'W':	/* The week of year, beginning on monday. */
-//         LEGAL_ALT(ALT_O);
-//         /*
-//         * XXX This is bogus, as we can not assume any valid
-//         * information present in the tm structure at this
-//         * point to calculate a real value, so just check the
-//         * range for now.
-//         */
-//         if (!(conv_num(&bp, &i, 0, 53)))
-//             return (0);
-//         break;
-
-//     case 'w':	/* The day of week, beginning on sunday. */
-//         LEGAL_ALT(ALT_O);
-//         if (!(conv_num(&bp, &tm->tm_wday, 0, 6)))
-//             return (0);
-//         break;
-
-//     case 'Y':	/* The year. */
-//         LEGAL_ALT(ALT_E);
-//         if (!(conv_num(&bp, &i, 0, 9999)))
-//             return (0);
-
-//         tm->tm_year = i - TM_YEAR_BASE;
-//         break;
-
-//     case 'y':	/* The year within 100 years of the epoch. */
-//         LEGAL_ALT(ALT_E | ALT_O);
-//         if (!(conv_num(&bp, &i, 0, 99)))
-//             return (0);
-
-//         if (split_year) {
-//             tm->tm_year = ((tm->tm_year / 100) * 100) + i;
-//             break;
-//         }
-//         split_year = 1;
-//         if (i <= 68)
-//             tm->tm_year = i + 2000 - TM_YEAR_BASE;
-//         else
-//             tm->tm_year = i + 1900 - TM_YEAR_BASE;
-//         break;
-
-//         /*
-//         * Miscellaneous conversions.
-//         */
-//     case 'n':	/* Any kind of white-space. */
-//     case 't':
-//         LEGAL_ALT(0);
-//         while (isspace(*bp))
-//             bp++;
-//         break;
-
-
-//     default:	/* Unknown/unsupported conversion. */
-//         return (0);
-//     }
-
-
-//     }
-
-//     /* LINTED functional specification */
-//     return ((char *)bp);
-// #elif defined(_TD_DARWIN_64)
-//     return strptime(buf, fmt, tm);
-// #else
-//     return strptime(buf, fmt, tm);
-// #endif
-// }
-
-
-
diff --git a/source/util/src/tpagedbuf.c b/source/util/src/tpagedbuf.c
index f50fd22ba6f577797eae6196582a4c164aa38358..0e608d0da22da836f0a357c7bd4f9b194c11fd13 100644
--- a/source/util/src/tpagedbuf.c
+++ b/source/util/src/tpagedbuf.c
@@ -518,8 +518,8 @@ void releaseBufPageInfo(SDiskbasedBuf* pBuf, SPageInfo* pi) {
 #ifdef BUF_PAGE_DEBUG
   uDebug("page_releaseBufPageInfo pageId:%d, used:%d, offset:%"PRId64, pi->pageId, pi->used, pi->offset);
 #endif
-  assert(pi->pData != NULL && pi->used == true);
-//  assert(pi->pData != NULL);
+  // assert(pi->pData != NULL && pi->used == true);
+  assert(pi->pData != NULL);
   pi->used = false;
   pBuf->statis.releasePages += 1;
 }
diff --git a/source/util/src/ttrace.c b/source/util/src/ttrace.c
deleted file mode 100644
index f183fd58fd6acd7b4e111575de1414cc4776c9d0..0000000000000000000000000000000000000000
--- a/source/util/src/ttrace.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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 "ttrace.h"
-#include "taos.h"
-#include "thash.h"
-#include "tuuid.h"
-
-// clang-format off
-//static TdThreadOnce init = PTHREAD_ONCE_INIT;
-//static void *              ids = NULL;
-//static TdThreadMutex       mtx;
-//
-//void traceInit() {
-//  ids = taosHashInit(4096, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
-//  taosThreadMutexInit(&mtx, NULL);
-//}
-//void traceCreateEnv() {
-//  taosThreadOnce(&init, traceInit);
-//}
-//void traceDestroyEnv() {
-//  taosThreadMutexDestroy(&mtx);
-//  taosHashCleanup(ids);
-//}
-//
-//STraceId traceInitId(STraceSubId *h, STraceSubId *l) {
-//  STraceId id = *h; 
-//  id = ((id << 32) & 0xFFFFFFFF) |  ((*l) & 0xFFFFFFFF);  
-//  return id;
-//}
-//void traceId2Str(STraceId *id, char *buf) {
-//  int32_t f = (*id >> 32) & 0xFFFFFFFF;
-//  int32_t s = (*id) & 0xFFFFFFFF;
-//  sprintf(buf, "%d:%d", f, s); 
-//}
-//
-//void traceSetSubId(STraceId *id, STraceSubId *subId) {
-//  int32_t parent = ((*id >> 32) & 0xFFFFFFFF); 
-//  taosThreadMutexLock(&mtx);    
-//  taosHashPut(ids, subId, sizeof(*subId), &parent, sizeof(parent));
-//  taosThreadMutexUnlock(&mtx);    
-//}
-//
-//STraceSubId traceGetParentId(STraceId *id) {
-//  int32_t parent = ((*id >> 32) & 0xFFFFFFFF);   
-//  taosThreadMutexLock(&mtx);    
-//  STraceSubId *p = taosHashGet(ids, (void *)&parent, sizeof(parent));
-//  parent = *p;
-//  taosThreadMutexUnlock(&mtx);    
-//
-//  return parent;  
-//}
-//
-//STraceSubId  traceGenSubId() {
-//  return tGenIdPI32();
-//}
-//void    traceSetRootId(STraceId *traceid, int64_t rootId) {
-//  traceId->rootId = rootId;
-//}
-//int64_t traceGetRootId(STraceId *traceId);
-//
-//void    traceSetMsgId(STraceId *traceid, int64_t msgId);
-//int64_t traceGetMsgId(STraceId *traceid);
-//
-//char *trace2Str(STraceId *id);
-//
-//void traceSetSubId(STraceId *id, int32_t *subId);
-// clang-format on
diff --git a/tests/pytest/crash_gen.sh b/tests/pytest/crash_gen.sh
index 127e13c5be1ea562cbe536bbb05f6ecd5844b0ea..539314dea46d7901a4e6d58f8aed0f7aeef603e1 100755
--- a/tests/pytest/crash_gen.sh
+++ b/tests/pytest/crash_gen.sh
@@ -48,7 +48,12 @@ fi
 PYTHON_EXEC=python3.8
 
 # First we need to set up a path for Python to find our own TAOS modules, so that "import" can work.
-export PYTHONPATH=$(pwd)/../../src/connector/python:$(pwd)
+# export PYTHONPATH=$(pwd)/../../src/connector/python:$(pwd)
+# NOTE: we are now pointing outside the current github, per Wade on 7/7/2022, we'll be keeping connectors outside
+# and there does not seem to be a module to reference that.
+PROJECT_PARENT=$(pwd)/../../..
+TAOS_PYTHON_PROJECT_DIR=$PROJECT_PARENT/taos-connector-python 
+export PYTHONPATH=$TAOS_PYTHON_PROJECT_DIR:$(pwd)
 
 # Then let us set up the library path so that our compiled SO file can be loaded by Python
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$LIB_DIR
diff --git a/tests/pytest/crash_gen/crash_gen_main.py b/tests/pytest/crash_gen/crash_gen_main.py
index b743eee2ef50c49da050cc78c77d0038acf0e507..08155f656bfb313dc1305eb1d0c846ee98f57cb9 100755
--- a/tests/pytest/crash_gen/crash_gen_main.py
+++ b/tests/pytest/crash_gen/crash_gen_main.py
@@ -466,6 +466,7 @@ class ThreadCoordinator:
         self._te = None  # No more executor, time to end
         Logging.debug("Main thread tapping all threads one last time...")
         self.tapAllThreads()  # Let the threads run one last time
+        #TODO: looks like we are not capturing the failures for the last step yet (i.e. calling registerFailure if neccessary)
 
         Logging.debug("\r\n\n--> Main thread ready to finish up...")
         Logging.debug("Main thread joining all threads")
@@ -1290,6 +1291,7 @@ class Task():
 
     def _isErrAcceptable(self, errno, msg):
         if errno in [
+                # TDengine 2.x Error Codes:
                 0x05,  # TSDB_CODE_RPC_NOT_READY
                 0x0B,  # Unable to establish connection, more details in TD-1648
                 # 0x200, # invalid SQL， TODO: re-examine with TD-934
@@ -1310,6 +1312,18 @@ class Task():
                 0x14,   # db not ready, errno changed
                 0x600,  # Invalid table ID, why?
                 0x218,  # Table does not exist
+
+                # TDengine 3.0 Error Codes:
+                0x0333, # Object is creating # TODO: this really is NOT an acceptable error
+                0x03A0, # STable already exists
+                0x03A1, # STable [does] not exist
+                0x03AA, # Tag already exists
+                0x0603, # Table already exists
+                0x2602, # Table does not exist
+                0x260d, # Tags number not matched
+
+
+
                 1000  # REST catch-all error
             ]: 
             return True # These are the ALWAYS-ACCEPTABLE ones
@@ -1749,6 +1763,8 @@ class TdSuperTable:
             tagType = tags[tagName]
             if tagType == 'BINARY':
                 tagStrs.append("'Beijing-Shanghai-LosAngeles'")
+            elif tagType== 'VARCHAR':
+                tagStrs.append("'London-Paris-Berlin'")
             elif tagType == 'FLOAT':
                 tagStrs.append('9.9')
             elif tagType == 'INT':
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 4e009e702d35038904ef3f39097eed5141a4e8a6..0783aa0fd1d7007cd4389383b0cc9b74a6de0b42 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -163,8 +163,8 @@
 # --- sma
 ./test.sh -f tsim/sma/drop_sma.sim
 ./test.sh -f tsim/sma/tsmaCreateInsertQuery.sim
-#./test.sh -f tsim/sma/rsmaCreateInsertQuery.sim
-#./test.sh -f tsim/sma/rsmaPersistenceRecovery.sim
+./test.sh -f tsim/sma/rsmaCreateInsertQuery.sim
+./test.sh -f tsim/sma/rsmaPersistenceRecovery.sim
 
 # --- valgrind
 ./test.sh -f tsim/valgrind/checkError1.sim
diff --git a/tests/script/loop.sh b/tests/script/loop.sh
index b435eef12306fc994dd4878b8225946f179adf7e..b3bc9728de7b54ba779b1b443d9ec2d9ee7e72a1 100755
--- a/tests/script/loop.sh
+++ b/tests/script/loop.sh
@@ -13,7 +13,7 @@ CMD_NAME=
 LOOP_TIMES=5
 SLEEP_TIME=0
 
-while getopts "f:t:s:" arg
+while getopts "hf:t:s:" arg
 do
   case $arg in
     f)
@@ -25,6 +25,12 @@ do
     s)
       SLEEP_TIME=$OPTARG
       ;;
+    h)
+      echo "Usage: $(basename $0) -f [cmd name] "
+      echo "                  -t [loop times] "
+      echo "                  -s [sleep time] "
+      exit 0
+      ;;
     ?)
       echo "unknow argument"
       ;;
diff --git a/tests/script/tsim/sync/vnodesnapshot.sim b/tests/script/tsim/sync/vnodesnapshot.sim
index 7ad3afe309c40c3b986683623bb7bf65d247d687..aa42047400bf773406dafa87031169c7e57c7477 100644
--- a/tests/script/tsim/sync/vnodesnapshot.sim
+++ b/tests/script/tsim/sync/vnodesnapshot.sim
@@ -142,20 +142,33 @@ sql create table ct1 using stb tags(1000)
 
 system sh/exec.sh -n dnode4 -s stop -x SIGINT
 
-sql insert into ct1 values(now+0s, 10, 2.0, 3.0)
-sql insert into ct1 values(now+1s, 11, 2.1, 3.1)(now+2s, -12, -2.2, -3.2)(now+3s, -13, -2.3, -3.3)
+$N = 100
+$count = 0
+while $count < $N
+	$ms = 1591200000000 + $count
+    sql insert into ct1 values( $ms , $count , 2.1, 3.1)
+    $count = $count + 1
+endw
 
-sql flush database db;
 
-system sh/exec.sh -n dnode4 -s start
 
-sql insert into ct1 values(now+1s, 81, 8.1, 8.1)(now+2s, -92, -9.2, -9.2)(now+3s, -73, -7.3, -7.3)
+#sql insert into ct1 values(now+0s, 10, 2.0, 3.0)
+#sql insert into ct1 values(now+1s, 11, 2.1, 3.1)(now+2s, -12, -2.2, -3.2)(now+3s, -13, -2.3, -3.3)
+
+#sql flush database db;
+
+#system sh/exec.sh -n dnode4 -s start
+
+#sql insert into ct1 values(now+1s, 81, 8.1, 8.1)(now+2s, -92, -9.2, -9.2)(now+3s, -73, -7.3, -7.3)
+
+
 
+sleep 5000
 
 
-#system sh/exec.sh -n dnode1 -s stop -x SIGINT
-#system sh/exec.sh -n dnode2 -s stop -x SIGINT
-#system sh/exec.sh -n dnode3 -s stop -x SIGINT
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec.sh -n dnode3 -s stop -x SIGINT
 #system sh/exec.sh -n dnode4 -s stop -x SIGINT
 
 
diff --git a/tests/system-test/2-query/and_or_for_byte.py b/tests/system-test/2-query/and_or_for_byte.py
index 3a0b6652bacfd26037d08bd6de96440c90614c24..aab9cce0408bbe62d4170ce0e385e110e72aff36 100644
--- a/tests/system-test/2-query/and_or_for_byte.py
+++ b/tests/system-test/2-query/and_or_for_byte.py
@@ -230,7 +230,7 @@ class TDTestCase:
                 work_sql += f"cast({arg} as bigint){opera}"
 
         if not agg:
-            work_sql+= f" from {tbname} order by ts"
+            work_sql+= f" from {tbname} order by tbname ,ts"
         else:
             work_sql+= f" from {tbname} "
         tdSql.query(work_sql)
@@ -243,7 +243,7 @@ class TDTestCase:
             else:
                 origin_sql += f"cast({arg} as bigint),"
         if not agg:
-            origin_sql+= f" from {tbname} order by ts"
+            origin_sql+= f" from {tbname} order by tbname ,ts"
         else:
             origin_sql+= f" from {tbname} "
         tdSql.query(origin_sql)
diff --git a/tests/system-test/2-query/json_tag.py b/tests/system-test/2-query/json_tag.py
index 79ce04d7d130bb67131413cd99f3d332e6a43d8d..f66f0f67ab03ce1c9c87ebc54dc2f879954c07bc 100644
--- a/tests/system-test/2-query/json_tag.py
+++ b/tests/system-test/2-query/json_tag.py
@@ -323,12 +323,12 @@ class TDTestCase:
         # where json value is bool
         tdSql.query("select * from jsons1 where jtag->'tag1'=true")
         tdSql.checkRows(0)
-        #tdSql.query("select * from jsons1 where jtag->'tag1'=false")
-        #tdSql.checkRows(1)
+        tdSql.query("select * from jsons1 where jtag->'tag1'=false")
+        tdSql.checkRows(1)
         tdSql.query("select * from jsons1 where jtag->'tag1'!=false")
         tdSql.checkRows(0)
-        #tdSql.query("select * from jsons1 where jtag->'tag1'>false")
-        #tdSql.checkRows(0)
+        tdSql.query("select * from jsons1 where jtag->'tag1'>false")
+        tdSql.checkRows(0)
 
         # where json value is null
         tdSql.query("select * from jsons1 where jtag->'tag1'=null")
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb-funcNFilter.py b/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb-funcNFilter.py
index bd8531d7c8cbc2d30dcb1c2a50e5e4bb9c73e11f..d22d183e863d26a0c0498e37861b2f526fe4262d 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb-funcNFilter.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb-funcNFilter.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb.py b/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb.py
index 1d2aaccda52c76c33fcd21eb981e689969bcb164..951a747069a2ad279dec56fd64781609ec2aa0f4 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb-1ctb.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb-funcNFilter.py b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb-funcNFilter.py
index 2720b7cdcec35071cb6cb428b2cb77bc66bccef2..6ee089af4e1fd53d4de7490db94f9847cb1d7aee 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb-funcNFilter.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb-funcNFilter.py
@@ -64,9 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        # tdDnodes.start(1)
-        tdDnodes.starttaosd(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.starttaosd(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py
index 0b2dddd24adcf6f4b17c40cf056226403967454e..882989bfb68a7f3a77ca8eaefb74138cf1283dae 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py
@@ -64,9 +64,10 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        # tdDnodes.start(1)
-        tdDnodes.starttaosd(1)
+        # tdDnodes.stop(1)
+        # # tdDnodes.start(1)
+        # tdDnodes.starttaosd(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg.py b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg.py
index a4d66482765146c894e9c387d6f892142144adc5..c334ff752bf7ec5753fc68f8d627b73ee86a6482 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb-mutilVg.py
@@ -64,9 +64,10 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        # tdDnodes.start(1)
-        tdDnodes.starttaosd(1)
+        # tdDnodes.stop(1)
+        # # tdDnodes.start(1)
+        # tdDnodes.starttaosd(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb.py b/tests/system-test/7-tmq/tmqConsFromTsdb.py
index c18474dcc3c26d7a5f27ac6e255cccaa74175768..a4a242365aa6ddb8c0040cbde7d8adfb199177ad 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase1(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py
index 540c9dbbe12372b5a4c3ef32630ce2b4b46af232..ec11b3286c7a100fa3a5a552f877c11a7ca13b34 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb.py
index 5cb373092ba8ac43405f027a85249e369a41df4b..4878652593d673aeabba66fe6dd2f931ea7156b5 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-1ctb.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
index eaef1348457223d0754e9148d4d7cf315f136886..451dc43343409e7feeb6db5705cdf4a4151caa6d 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py
index c1b327e5f14879a9223376bd55be7d57d814b400..3b3467f9f99807262864940deefe6e96c95a8af4 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg.py b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg.py
index dd8a0ad33ac40344ebe2cc93e8a1144085f0d24b..d1fe69f0b7acbcc374df5c08b3498c75083f0f70 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1-mutilVg.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/7-tmq/tmqConsFromTsdb1.py b/tests/system-test/7-tmq/tmqConsFromTsdb1.py
index a183eda1c7f05a0116a7d490542ea18ed6de243f..597f7968ae26d17590e0b611c07539ded2990b9b 100644
--- a/tests/system-test/7-tmq/tmqConsFromTsdb1.py
+++ b/tests/system-test/7-tmq/tmqConsFromTsdb1.py
@@ -64,8 +64,9 @@ class TDTestCase:
                                                startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx'])
         
         tdLog.info("restart taosd to ensure that the data falls into the disk")
-        tdDnodes.stop(1)
-        tdDnodes.start(1)
+        # tdDnodes.stop(1)
+        # tdDnodes.start(1)
+        tdSql.query("flush database %s"%(paraDict['dbName']))
         return
 
     def tmqCase3(self):
diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh
index 1e305f2518806fa6bd9e62c7d51f131534a31da7..409fb5e930c5650b6cdb38bb09a9f0839398f486 100755
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@@ -117,7 +117,7 @@ python3 ./test.py -f 2-query/distribute_agg_avg.py
 python3 ./test.py -f 2-query/distribute_agg_stddev.py
 python3 ./test.py -f 2-query/twa.py
 python3 ./test.py -f 2-query/irate.py
-#python3 ./test.py -f 2-query/and_or_for_byte.py
+python3 ./test.py -f 2-query/and_or_for_byte.py
 
 python3 ./test.py -f 2-query/function_null.py
 python3 ./test.py -f 2-query/queryQnode.py
diff --git a/tests/system-test/loop.sh b/tests/system-test/loop.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b3bc9728de7b54ba779b1b443d9ec2d9ee7e72a1
--- /dev/null
+++ b/tests/system-test/loop.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+##################################################
+# 
+# Do simulation test 
+#
+##################################################
+
+set -e
+#set -x
+
+CMD_NAME=
+LOOP_TIMES=5
+SLEEP_TIME=0
+
+while getopts "hf:t:s:" arg
+do
+  case $arg in
+    f)
+      CMD_NAME=$OPTARG
+      ;;
+    t)
+      LOOP_TIMES=$OPTARG
+      ;;
+    s)
+      SLEEP_TIME=$OPTARG
+      ;;
+    h)
+      echo "Usage: $(basename $0) -f [cmd name] "
+      echo "                  -t [loop times] "
+      echo "                  -s [sleep time] "
+      exit 0
+      ;;
+    ?)
+      echo "unknow argument"
+      ;;
+  esac
+done
+
+echo LOOP_TIMES ${LOOP_TIMES}
+echo CMD_NAME ${CMD_NAME}
+echo SLEEP_TIME ${SLEEP_TIME}
+
+GREEN='\033[1;32m'
+GREEN_DARK='\033[0;32m'
+GREEN_UNDERLINE='\033[4;32m'
+NC='\033[0m'
+
+for ((i=0; i<$LOOP_TIMES; i++ ))
+do
+    echo -e $GREEN loop $i $NC
+    echo -e $GREEN cmd $CMD_NAME $NC
+    $CMD_NAME
+    sleep ${SLEEP_TIME}
+done
diff --git a/tools/taosadapter b/tools/taosadapter
index 389047db713a3dddfbce292c3260b0864b17d936..c885e967e490105999b84d009a15168728dfafaf 160000
--- a/tools/taosadapter
+++ b/tools/taosadapter
@@ -1 +1 @@
-Subproject commit 389047db713a3dddfbce292c3260b0864b17d936
+Subproject commit c885e967e490105999b84d009a15168728dfafaf