diff --git a/cmake/taostools_CMakeLists.txt.in b/cmake/taostools_CMakeLists.txt.in
index c2ef22c338..ed2ec0b6da 100644
--- a/cmake/taostools_CMakeLists.txt.in
+++ b/cmake/taostools_CMakeLists.txt.in
@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG cf30c86
+        GIT_TAG d5df76d
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index ed0f5cd31d..89ec9dc6c8 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -129,6 +129,7 @@ extern char tsUdfdLdLibPath[];
 extern char tsSmlChildTableName[];
 extern char tsSmlTagName[];
 extern bool tsSmlDataFormat;
+extern int32_t tsSmlBatchSize;
 
 // wal
 extern int64_t tsWalFsyncDataSizeLimit;
diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 0bca254e14..d210004760 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -160,13 +160,6 @@ int32_t qAsyncKillTask(qTaskInfo_t tinfo);
  */
 void qDestroyTask(qTaskInfo_t tinfo);
 
-/**
- * Get the queried table uid
- * @param qHandle
- * @return
- */
-int64_t qGetQueriedTableUid(qTaskInfo_t tinfo);
-
 /**
  * Extract the qualified table id list, and than pass them to the TSDB driver to load the required table data blocks.
  *
diff --git a/include/libs/sync/sync.h b/include/libs/sync/sync.h
index 1b65d95cb1..604e1479d5 100644
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@@ -67,6 +67,7 @@ typedef struct SWal           SWal;
 typedef struct SSyncRaftEntry SSyncRaftEntry;
 
 typedef enum {
+  TAOS_SYNC_STATE_OFFLINE = 0,
   TAOS_SYNC_STATE_FOLLOWER = 100,
   TAOS_SYNC_STATE_CANDIDATE = 101,
   TAOS_SYNC_STATE_LEADER = 102,
diff --git a/include/os/osSocket.h b/include/os/osSocket.h
index 2c7c579401..3ba28d8156 100644
--- a/include/os/osSocket.h
+++ b/include/os/osSocket.h
@@ -169,6 +169,9 @@ void        taosSetMaskSIGPIPE();
 uint32_t    taosInetAddr(const char *ipAddr);
 const char *taosInetNtoa(struct in_addr ipInt, char *dstStr, int32_t len);
 
+uint64_t taosHton64(uint64_t val);
+uint64_t taosNtoh64(uint64_t val);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/util/tarray.h b/include/util/tarray.h
index beebd70dea..0e78397ecb 100644
--- a/include/util/tarray.h
+++ b/include/util/tarray.h
@@ -220,15 +220,10 @@ void taosArrayClear(SArray* pArray);
  */
 void taosArrayClearEx(SArray* pArray, void (*fp)(void*));
 
-/**
- * clear the array (remove all element)
- * @param pArray
- * @param fp
- */
-void taosArrayClearP(SArray* pArray, FDelete fp);
-
 void* taosArrayDestroy(SArray* pArray);
+
 void  taosArrayDestroyP(SArray* pArray, FDelete fp);
+
 void  taosArrayDestroyEx(SArray* pArray, FDelete fp);
 
 /**
@@ -238,12 +233,6 @@ void  taosArrayDestroyEx(SArray* pArray, FDelete fp);
  */
 void taosArraySort(SArray* pArray, __compar_fn_t comparFn);
 
-/**
- * sort string array
- * @param pArray
- */
-void taosArraySortString(SArray* pArray, __compar_fn_t comparFn);
-
 /**
  * search the array
  * @param pArray
diff --git a/source/client/src/clientSml.c b/source/client/src/clientSml.c
index f4d8c80e3f..d811eb7fec 100644
--- a/source/client/src/clientSml.c
+++ b/source/client/src/clientSml.c
@@ -79,7 +79,6 @@
 #define NCHAR_ADD_LEN  3  // L"nchar"   3 means L" "
 
 #define MAX_RETRY_TIMES 5
-#define LINE_BATCH      2000
 //=================================================================================================
 typedef TSDB_SML_PROTOCOL_TYPE SMLProtocolType;
 
@@ -467,6 +466,13 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
         goto end;
       }
       info->cost.numOfCreateSTables++;
+      taosMemoryFreeClear(pTableMeta);
+
+      code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
+      if (code != TSDB_CODE_SUCCESS) {
+        uError("SML:0x%" PRIx64 " catalogGetSTableMeta failed. super table name %s", info->id, pName.tname);
+        goto end;
+      }
     } else if (code == TSDB_CODE_SUCCESS) {
       hashTmp = taosHashInit(pTableMeta->tableInfo.numOfTags, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true,
                              HASH_NO_LOCK);
@@ -505,16 +511,16 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
           uError("SML:0x%" PRIx64 " smlSendMetaMsg failed. can not create %s", info->id, pName.tname);
           goto end;
         }
-      }
 
-      taosMemoryFreeClear(pTableMeta);
-      code = catalogRefreshTableMeta(info->pCatalog, &conn, &pName, -1);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto end;
-      }
-      code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto end;
+        taosMemoryFreeClear(pTableMeta);
+        code = catalogRefreshTableMeta(info->pCatalog, &conn, &pName, -1);
+        if (code != TSDB_CODE_SUCCESS) {
+          goto end;
+        }
+        code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
+        if (code != TSDB_CODE_SUCCESS) {
+          goto end;
+        }
       }
 
       taosHashClear(hashTmp);
@@ -552,12 +558,18 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
           uError("SML:0x%" PRIx64 " smlSendMetaMsg failed. can not create %s", info->id, pName.tname);
           goto end;
         }
+
+        code = catalogRefreshTableMeta(info->pCatalog, &conn, &pName, -1);
+        if (code != TSDB_CODE_SUCCESS) {
+          goto end;
+        }
+        code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
+        if (code != TSDB_CODE_SUCCESS) {
+          uError("SML:0x%" PRIx64 " catalogGetSTableMeta failed. super table name %s", info->id, pName.tname);
+          goto end;
+        }
       }
 
-      code = catalogRefreshTableMeta(info->pCatalog, &conn, &pName, -1);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto end;
-      }
       needCheckMeta = true;
       taosHashCleanup(hashTmp);
       hashTmp = NULL;
@@ -565,13 +577,6 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
       uError("SML:0x%" PRIx64 " load table meta error: %s", info->id, tstrerror(code));
       goto end;
     }
-    taosMemoryFreeClear(pTableMeta);
-
-    code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
-    if (code != TSDB_CODE_SUCCESS) {
-      uError("SML:0x%" PRIx64 " catalogGetSTableMeta failed. super table name %s", info->id, pName.tname);
-      goto end;
-    }
 
     if (needCheckMeta) {
       code = smlCheckMeta(&(pTableMeta->schema[pTableMeta->tableInfo.numOfColumns]), pTableMeta->tableInfo.numOfTags,
@@ -596,7 +601,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
 end:
   taosHashCleanup(hashTmp);
   taosMemoryFreeClear(pTableMeta);
-  catalogRefreshTableMeta(info->pCatalog, &conn, &pName, 1);
+//  catalogRefreshTableMeta(info->pCatalog, &conn, &pName, 1);
   return code;
 }
 
@@ -815,6 +820,11 @@ static int8_t smlGetTsTypeByPrecision(int8_t precision) {
 }
 
 static int64_t smlParseInfluxTime(SSmlHandle *info, const char *data, int32_t len) {
+  void *tmp = taosMemoryCalloc(1, len + 1);
+  memcpy(tmp, data, len);
+  uDebug("SML:0x%" PRIx64 " smlParseInfluxTime tslen:%d, ts:%s", info->id, len, (char*)tmp);
+  taosMemoryFree(tmp);
+
   if (len == 0 || (len == 1 && data[0] == '0')) {
     return taosGetTimestampNs();
   }
@@ -2066,7 +2076,10 @@ static int32_t smlParseJSONString(SSmlHandle *info, cJSON *root, SSmlTableInfo *
 
 static int32_t smlParseInfluxLine(SSmlHandle *info, const char *sql, const int len) {
   SSmlLineInfo elements = {0};
-  uDebug("SML:0x%" PRIx64 " smlParseInfluxLine sql:%s", info->id, (info->isRawLine ? "rawdata" : sql));
+  void *tmp = taosMemoryCalloc(1, len + 1);
+  memcpy(tmp, sql, len);
+  uDebug("SML:0x%" PRIx64 " smlParseInfluxLine raw:%d, len:%d, sql:%s", info->id, info->isRawLine, len, (info->isRawLine ? (char*)tmp : sql));
+  taosMemoryFree(tmp);
 
   int ret = smlParseInfluxString(sql, sql + len, &elements, &info->msgBuf);
   if (ret != TSDB_CODE_SUCCESS) {
@@ -2562,7 +2575,7 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
     goto end;
   }
 
-  batchs = ceil(((double)numLines) / LINE_BATCH);
+  batchs = ceil(((double)numLines) / tsSmlBatchSize);
   params.total = batchs;
   for (int i = 0; i < batchs; ++i) {
     SRequestObj *req = (SRequestObj *)createRequest(pTscObj->id, TSDB_SQL_INSERT, 0);
@@ -2581,7 +2594,7 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
     info->isRawLine = (rawLine == NULL);
     info->ttl       = ttl;
 
-    int32_t perBatch = LINE_BATCH;
+    int32_t perBatch = tsSmlBatchSize;
 
     if (numLines > perBatch) {
       numLines -= perBatch;
diff --git a/source/common/src/systable.c b/source/common/src/systable.c
index c3a1f9f67e..1255116d0c 100644
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@@ -206,16 +206,15 @@ static const SSysDbTableSchema vgroupsSchema[] = {
     {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
     {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "tables", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "v1_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "v1_status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "v2_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "v2_status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "v3_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "v3_status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "status", .bytes = 12 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "v1_dnode", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
+    {.name = "v1_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "v2_dnode", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
+    {.name = "v2_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "v3_dnode", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
+    {.name = "v3_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "v4_dnode", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT, .sysInfo = true},
+    {.name = "v4_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "cacheload", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "nfiles", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "file_size", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
     {.name = "tsma", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = true},
 };
 
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index b6c039f375..ab46ba24cf 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -75,6 +75,7 @@ char tsSmlChildTableName[TSDB_TABLE_NAME_LEN] = "";  // user defined child table
                                                      // If set to empty system will generate table name using MD5 hash.
 // true means that the name and order of cols in each line are the same(only for influx protocol)
 bool tsSmlDataFormat = false;
+int32_t  tsSmlBatchSize  = 10000;
 
 // query
 int32_t tsQueryPolicy = 1;
@@ -306,6 +307,7 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   if (cfgAddString(pCfg, "smlChildTableName", "", 1) != 0) return -1;
   if (cfgAddString(pCfg, "smlTagName", tsSmlTagName, 1) != 0) return -1;
   if (cfgAddBool(pCfg, "smlDataFormat", tsSmlDataFormat, 1) != 0) return -1;
+  if (cfgAddInt32(pCfg, "smlBatchSize", tsSmlBatchSize, 1, INT32_MAX, true) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxMemUsedByInsert", tsMaxMemUsedByInsert, 1, INT32_MAX, true) != 0) return -1;
   if (cfgAddInt32(pCfg, "rpcRetryLimit", tsRpcRetryLimit, 1, 100000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "rpcRetryInterval", tsRpcRetryInterval, 1, 100000, 0) != 0) return -1;
@@ -648,6 +650,7 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   tstrncpy(tsSmlTagName, cfgGetItem(pCfg, "smlTagName")->str, TSDB_COL_NAME_LEN);
   tsSmlDataFormat = cfgGetItem(pCfg, "smlDataFormat")->bval;
 
+  tsSmlBatchSize = cfgGetItem(pCfg, "smlBatchSize")->i32;
   tsMaxMemUsedByInsert = cfgGetItem(pCfg, "maxMemUsedByInsert")->i32;
 
   tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
@@ -1021,6 +1024,8 @@ int32_t taosSetCfg(SConfig *pCfg, char *name) {
         tstrncpy(tsSmlTagName, cfgGetItem(pCfg, "smlTagName")->str, TSDB_COL_NAME_LEN);
       } else if (strcasecmp("smlDataFormat", name) == 0) {
         tsSmlDataFormat = cfgGetItem(pCfg, "smlDataFormat")->bval;
+      } else if (strcasecmp("smlBatchSize", name) == 0) {
+        tsSmlBatchSize = cfgGetItem(pCfg, "smlBatchSize")->i32;
       } else if (strcasecmp("shellActivityTimer", name) == 0) {
         tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
       } else if (strcasecmp("supportVnodes", name) == 0) {
diff --git a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
index 8a8561161b..a7ad983b0c 100644
--- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
+++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
@@ -150,7 +150,7 @@ static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {
   SServerStatusRsp statusRsp = {0};
   SMonMloadInfo    minfo = {0};
   (*pMgmt->getMnodeLoadsFp)(&minfo);
-  if (minfo.isMnode && minfo.load.syncState == TAOS_SYNC_STATE_ERROR) {
+  if (minfo.isMnode && (minfo.load.syncState == TAOS_SYNC_STATE_ERROR || minfo.load.syncState == TAOS_SYNC_STATE_OFFLINE)) {
     pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
     snprintf(pStatus->details, sizeof(pStatus->details), "mnode sync state is %s", syncStr(minfo.load.syncState));
     return;
@@ -160,7 +160,7 @@ static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {
   (*pMgmt->getVnodeLoadsFp)(&vinfo);
   for (int32_t i = 0; i < taosArrayGetSize(vinfo.pVloads); ++i) {
     SVnodeLoad *pLoad = taosArrayGet(vinfo.pVloads, i);
-    if (pLoad->syncState == TAOS_SYNC_STATE_ERROR) {
+    if (pLoad->syncState == TAOS_SYNC_STATE_ERROR || pLoad->syncState == TAOS_SYNC_STATE_OFFLINE) {
       pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
       snprintf(pStatus->details, sizeof(pStatus->details), "vnode:%d sync state is %s", pLoad->vgId,
                syncStr(pLoad->syncState));
diff --git a/source/dnode/mnode/impl/inc/mndVgroup.h b/source/dnode/mnode/impl/inc/mndVgroup.h
index 94469899fc..765d4fd33d 100644
--- a/source/dnode/mnode/impl/inc/mndVgroup.h
+++ b/source/dnode/mnode/impl/inc/mndVgroup.h
@@ -36,8 +36,6 @@ int64_t  mndGetVgroupMemory(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup);
 SArray *mndBuildDnodesArray(SMnode *, int32_t exceptDnodeId);
 int32_t mndAllocSmaVgroup(SMnode *, SDbObj *pDb, SVgObj *pVgroup);
 int32_t mndAllocVgroup(SMnode *, SDbObj *pDb, SVgObj **ppVgroups);
-int32_t mndAddVnodeToVgroup(SMnode *, SVgObj *pVgroup, SArray *pArray);
-int32_t mndRemoveVnodeFromVgroup(SMnode *, SVgObj *pVgroup, SArray *pArray, SVnodeGid *pDelVgid);
 int32_t mndAddCreateVnodeAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid);
 int32_t mndAddAlterVnodeConfirmAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup);
 int32_t mndAddAlterVnodeAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, tmsg_t msgType);
diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c
index 58f8172282..4397ea0751 100644
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@@ -538,7 +538,7 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
 
   int32_t code = -1;
   SArray *newSub = subscribe.topicNames;
-  taosArraySortString(newSub, taosArrayCompareString);
+  taosArraySort(newSub, taosArrayCompareString);
   taosArrayRemoveDuplicateP(newSub, taosArrayCompareString, taosMemoryFree);
 
   int32_t newTopicNum = taosArrayGetSize(newSub);
@@ -850,7 +850,8 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
 
     // add to current topic
     taosArrayPush(pOldConsumer->currentTopics, &addedTopic);
-    taosArraySortString(pOldConsumer->currentTopics, taosArrayCompareString);
+    taosArraySort(pOldConsumer->currentTopics, taosArrayCompareString);
+
     // set status
     if (taosArrayGetSize(pOldConsumer->rebNewTopics) == 0 && taosArrayGetSize(pOldConsumer->rebRemovedTopics) == 0) {
       if (pOldConsumer->status == MQ_CONSUMER_STATUS__MODIFY ||
diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c
index 2d888d2ff7..f533fafeee 100644
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@@ -151,10 +151,10 @@ static void mndSetVgroupOffline(SMnode *pMnode, int32_t dnodeId, int64_t curMs)
     bool roleChanged = false;
     for (int32_t vg = 0; vg < pVgroup->replica; ++vg) {
       if (pVgroup->vnodeGid[vg].dnodeId == dnodeId) {
-        if (pVgroup->vnodeGid[vg].syncState != TAOS_SYNC_STATE_ERROR) {
+        if (pVgroup->vnodeGid[vg].syncState != TAOS_SYNC_STATE_OFFLINE) {
           mInfo("vgId:%d, state changed by offline check, old state:%s restored:%d new state:error restored:0",
                 pVgroup->vgId, syncStr(pVgroup->vnodeGid[vg].syncState), pVgroup->vnodeGid[vg].syncRestore);
-          pVgroup->vnodeGid[vg].syncState = TAOS_SYNC_STATE_ERROR;
+          pVgroup->vnodeGid[vg].syncState = TAOS_SYNC_STATE_OFFLINE;
           pVgroup->vnodeGid[vg].syncRestore = 0;
           roleChanged = true;
         }
@@ -491,6 +491,15 @@ void mndPreClose(SMnode *pMnode) {
   if (pMnode != NULL) {
     syncLeaderTransfer(pMnode->syncMgmt.sync);
     syncPreStop(pMnode->syncMgmt.sync);
+
+    while (syncSnapshotRecving(pMnode->syncMgmt.sync)) {
+      mInfo("vgId:1, snapshot is recving");
+      taosMsleep(300);
+    }
+    while (syncSnapshotSending(pMnode->syncMgmt.sync)) {
+      mInfo("vgId:1, snapshot is sending");
+      taosMsleep(300);
+    }
   }
 }
 
@@ -747,7 +756,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
         tstrncpy(desc.status, "ready", sizeof(desc.status));
         pClusterInfo->vgroups_alive++;
       }
-      if (pVgid->syncState != TAOS_SYNC_STATE_ERROR) {
+      if (pVgid->syncState != TAOS_SYNC_STATE_ERROR && pVgid->syncState != TAOS_SYNC_STATE_OFFLINE) {
         pClusterInfo->vnodes_alive++;
       }
       pClusterInfo->vnodes_total++;
diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c
index b02ca4c773..7c86a5be22 100644
--- a/source/dnode/mnode/impl/src/mndMnode.c
+++ b/source/dnode/mnode/impl/src/mndMnode.c
@@ -185,7 +185,7 @@ static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj) {
     return -1;
   }
 
-  pObj->syncState = TAOS_SYNC_STATE_ERROR;
+  pObj->syncState = TAOS_SYNC_STATE_OFFLINE;
   mndReloadSyncConfig(pSdb->pMnode);
   return 0;
 }
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index 4fa00dcf7c..d06853e470 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -179,6 +179,22 @@ static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew) {
   pOld->hashEnd = pNew->hashEnd;
   pOld->replica = pNew->replica;
   pOld->isTsma = pNew->isTsma;
+  for (int32_t i = 0; i < pNew->replica; ++i) {
+    SVnodeGid *pNewGid = &pNew->vnodeGid[i];
+    for (int32_t j = 0; j < pOld->replica; ++j) {
+      SVnodeGid *pOldGid = &pOld->vnodeGid[j];
+      if (pNewGid->dnodeId == pOldGid->dnodeId) {
+        pNewGid->syncState = pOldGid->syncState;
+        pNewGid->syncRestore = pOldGid->syncRestore;
+      }
+    }
+  }
+  pNew->numOfTables = pOld->numOfTables;
+  pNew->numOfTimeSeries = pOld->numOfTimeSeries;
+  pNew->totalStorage = pOld->totalStorage;
+  pNew->compStorage = pOld->compStorage;
+  pNew->pointsWritten = pOld->pointsWritten;
+  pNew->compact = pOld->compact;
   memcpy(pOld->vnodeGid, pNew->vnodeGid, TSDB_MAX_REPLICA * sizeof(SVnodeGid));
   return 0;
 }
@@ -659,11 +675,12 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->numOfTables, false);
 
-    // default 3 replica
-    for (int32_t i = 0; i < 3; ++i) {
+    // default 3 replica, add 1 replica if move vnode
+    for (int32_t i = 0; i < 4; ++i) {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       if (i < pVgroup->replica) {
-        colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->vnodeGid[i].dnodeId, false);
+        int16_t dnodeId = (int16_t)pVgroup->vnodeGid[i].dnodeId;
+        colDataAppend(pColInfo, numOfRows, (const char *)&dnodeId, false);
 
         bool       exist = false;
         bool       online = false;
@@ -695,16 +712,8 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppendNULL(pColInfo, numOfRows);
-
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->cacheUsage, false);
-
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppendNULL(pColInfo, numOfRows);
-
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppendNULL(pColInfo, numOfRows);
+    int32_t cacheUsage = (int32_t)pVgroup->cacheUsage;
+    colDataAppend(pColInfo, numOfRows, (const char *)&cacheUsage, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->isTsma, false);
@@ -851,7 +860,7 @@ static void mndCancelGetNextVnode(SMnode *pMnode, void *pIter) {
   sdbCancelFetch(pSdb, pIter);
 }
 
-int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
+static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SArray *pArray) {
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
     SDnodeObj *pDnode = taosArrayGet(pArray, i);
@@ -887,12 +896,21 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
     }
 
     pVgid->dnodeId = pDnode->id;
-    pVgid->syncState = TAOS_SYNC_STATE_ERROR;
+    pVgid->syncState = TAOS_SYNC_STATE_OFFLINE;
     mInfo("db:%s, vgId:%d, vn:%d is added, memory:%" PRId64 ", dnode:%d avail:%" PRId64 " used:%" PRId64,
           pVgroup->dbName, pVgroup->vgId, pVgroup->replica, vgMem, pVgid->dnodeId, pDnode->memAvail, pDnode->memUsed);
 
     pVgroup->replica++;
     pDnode->numOfVnodes++;
+
+    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
+    if (pVgRaw == NULL) return -1;
+    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+      sdbFreeRaw(pVgRaw);
+      return -1;
+    }
+    (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
+
     return 0;
   }
 
@@ -901,7 +919,8 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
   return -1;
 }
 
-int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray, SVnodeGid *pDelVgid) {
+static int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SArray *pArray,
+                                        SVnodeGid *pDelVgid) {
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
     SDnodeObj *pDnode = taosArrayGet(pArray, i);
@@ -941,6 +960,15 @@ _OVER:
     SVnodeGid *pVgid = &pVgroup->vnodeGid[vn];
     mInfo("db:%s, vgId:%d, vn:%d dnode:%d is reserved", pVgroup->dbName, pVgroup->vgId, vn, pVgid->dnodeId);
   }
+
+  SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
+  if (pVgRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    sdbFreeRaw(pVgRaw);
+    return -1;
+  }
+  (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
+
   return 0;
 }
 
@@ -1088,7 +1116,7 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
 
   if (!force) {
     mInfo("vgId:%d, will add 1 vnode", pVgroup->vgId);
-    if (mndAddVnodeToVgroup(pMnode, &newVg, pArray) != 0) return -1;
+    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray) != 0) return -1;
     for (int32_t i = 0; i < newVg.replica - 1; ++i) {
       if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
     }
@@ -1100,6 +1128,16 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
     SVnodeGid del = newVg.vnodeGid[vnIndex];
     newVg.vnodeGid[vnIndex] = newVg.vnodeGid[newVg.replica];
     memset(&newVg.vnodeGid[newVg.replica], 0, sizeof(SVnodeGid));
+    {
+      SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
+      if (pRaw == NULL) return -1;
+      if (mndTransAppendRedolog(pTrans, pRaw) != 0) {
+        sdbFreeRaw(pRaw);
+        return -1;
+      }
+      (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    }
+
     if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true) != 0) return -1;
     for (int32_t i = 0; i < newVg.replica; ++i) {
       if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
@@ -1107,11 +1145,20 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
     if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;
   } else {
     mInfo("vgId:%d, will add 1 vnode and force remove 1 vnode", pVgroup->vgId);
-    if (mndAddVnodeToVgroup(pMnode, &newVg, pArray) != 0) return -1;
+    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray) != 0) return -1;
     newVg.replica--;
     SVnodeGid del = newVg.vnodeGid[vnIndex];
     newVg.vnodeGid[vnIndex] = newVg.vnodeGid[newVg.replica];
     memset(&newVg.vnodeGid[newVg.replica], 0, sizeof(SVnodeGid));
+    {
+      SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
+      if (pRaw == NULL) return -1;
+      if (mndTransAppendRedolog(pTrans, pRaw) != 0) {
+        sdbFreeRaw(pRaw);
+        return -1;
+      }
+      (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    }
 
     for (int32_t i = 0; i < newVg.replica; ++i) {
       if (i != vnIndex) {
@@ -1128,16 +1175,12 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
 
   {
     SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendRedolog(pTrans, pRaw) != 0) return -1;
+    if (pRaw == NULL) return -1;
+    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+      sdbFreeRaw(pRaw);
+      return -1;
+    }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
-  }
-
-  {
-    SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) return -1;
-    (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
   }
 
   mInfo("vgId:%d, vgroup info after move, replica:%d", newVg.vgId, newVg.replica);
@@ -1193,7 +1236,15 @@ static int32_t mndAddIncVgroupReplicaToTrans(SMnode *pMnode, STrans *pTrans, SDb
   SVnodeGid *pGid = &pVgroup->vnodeGid[pVgroup->replica];
   pVgroup->replica++;
   pGid->dnodeId = newDnodeId;
-  pGid->syncState = TAOS_SYNC_STATE_ERROR;
+  pGid->syncState = TAOS_SYNC_STATE_OFFLINE;
+
+  SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
+  if (pVgRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    sdbFreeRaw(pVgRaw);
+    return -1;
+  }
+  (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
   for (int32_t i = 0; i < pVgroup->replica - 1; ++i) {
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
@@ -1224,6 +1275,14 @@ static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, S
   memcpy(pGid, &pVgroup->vnodeGid[pVgroup->replica], sizeof(SVnodeGid));
   memset(&pVgroup->vnodeGid[pVgroup->replica], 0, sizeof(SVnodeGid));
 
+  SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
+  if (pVgRaw == NULL) return -1;
+  if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    sdbFreeRaw(pVgRaw);
+    return -1;
+  }
+  (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
+
   if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true) != 0) return -1;
   for (int32_t i = 0; i < pVgroup->replica; ++i) {
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
@@ -1236,9 +1295,8 @@ static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, S
 static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgroup, SDnodeObj *pNew1,
                                      SDnodeObj *pOld1, SDnodeObj *pNew2, SDnodeObj *pOld2, SDnodeObj *pNew3,
                                      SDnodeObj *pOld3) {
-  int32_t  code = -1;
-  SSdbRaw *pRaw = NULL;
-  STrans  *pTrans = NULL;
+  int32_t code = -1;
+  STrans *pTrans = NULL;
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "red-vgroup");
   if (pTrans == NULL) goto _OVER;
@@ -1319,17 +1377,13 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
   }
 
   {
-    pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendRedolog(pTrans, pRaw) != 0) goto _OVER;
+    SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
+    if (pRaw == NULL) return -1;
+    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+      sdbFreeRaw(pRaw);
+      return -1;
+    }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
-  }
-
-  {
-    pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
-    (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
   }
 
   mInfo("vgId:%d, vgroup info after redistribute, replica:%d", newVg.vgId, newVg.replica);
@@ -1342,7 +1396,6 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
 
 _OVER:
   mndTransDrop(pTrans);
-  sdbFreeRaw(pRaw);
   mndReleaseDb(pMnode, pDb);
   return code;
 }
@@ -1593,13 +1646,13 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
     mInfo("db:%s, vgId:%d, will add 2 vnodes, vn:0 dnode:%d", pVgroup->dbName, pVgroup->vgId,
           pVgroup->vnodeGid[0].dnodeId);
 
-    if (mndAddVnodeToVgroup(pMnode, &newVgroup, pArray) != 0) return -1;
+    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray) != 0) return -1;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
       return -1;
     if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[1]) != 0) return -1;
     if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
 
-    if (mndAddVnodeToVgroup(pMnode, &newVgroup, pArray) != 0) return -1;
+    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray) != 0) return -1;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
       return -1;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[1].dnodeId) != 0)
@@ -1612,7 +1665,7 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
 
     SVnodeGid del1 = {0};
     SVnodeGid del2 = {0};
-    if (mndRemoveVnodeFromVgroup(pMnode, &newVgroup, pArray, &del1) != 0) return -1;
+    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, &newVgroup, pArray, &del1) != 0) return -1;
     if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del1, true) != 0) return -1;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
       return -1;
@@ -1620,7 +1673,7 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
       return -1;
     if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
 
-    if (mndRemoveVnodeFromVgroup(pMnode, &newVgroup, pArray, &del2) != 0) return -1;
+    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, &newVgroup, pArray, &del2) != 0) return -1;
     if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del2, true) != 0) return -1;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
       return -1;
@@ -1629,16 +1682,6 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
     return -1;
   }
 
-  {
-    SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
-      sdbFreeRaw(pVgRaw);
-      return -1;
-    }
-    (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
-  }
-
   {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
     if (pVgRaw == NULL) return -1;
@@ -1657,10 +1700,9 @@ static int32_t mndAddAdjustVnodeHashRangeAction(SMnode *pMnode, STrans *pTrans,
 }
 
 static int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgroup) {
-  int32_t  code = -1;
-  SSdbRaw *pRaw = NULL;
-  STrans  *pTrans = NULL;
-  SArray  *pArray = mndBuildDnodesArray(pMnode, 0);
+  int32_t code = -1;
+  STrans *pTrans = NULL;
+  SArray *pArray = mndBuildDnodesArray(pMnode, 0);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "split-vgroup");
   if (pTrans == NULL) goto _OVER;
@@ -1676,13 +1718,13 @@ static int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj
   }
 
   if (newVg1.replica == 1) {
-    if (mndAddVnodeToVgroup(pMnode, &newVg1, pArray) != 0) goto _OVER;
+    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg1, pArray) != 0) goto _OVER;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
     if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg1, &newVg1.vnodeGid[1]) != 0) goto _OVER;
     if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
   } else if (newVg1.replica == 3) {
     SVnodeGid del1 = {0};
-    if (mndRemoveVnodeFromVgroup(pMnode, &newVg1, pArray, &del1) != 0) goto _OVER;
+    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, &newVg1, pArray, &del1) != 0) goto _OVER;
     if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg1, &del1, true) != 0) goto _OVER;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
     if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId) != 0) goto _OVER;
@@ -1727,17 +1769,23 @@ static int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj
 #endif
 
   {
-    pRaw = mndVgroupActionEncode(&newVg1);
-    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+    SSdbRaw *pRaw = mndVgroupActionEncode(&newVg1);
+    if (pRaw == NULL) return -1;
+    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+      sdbFreeRaw(pRaw);
+      return -1;
+    }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
   }
 
   {
-    pRaw = mndVgroupActionEncode(&newVg2);
-    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+    SSdbRaw *pRaw = mndVgroupActionEncode(&newVg2);
+    if (pRaw == NULL) return -1;
+    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+      sdbFreeRaw(pRaw);
+      return -1;
+    }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-    pRaw = NULL;
   }
 
   mInfo("vgId:%d, vgroup info after adjust hash, replica:%d hashBegin:%u hashEnd:%u vnode:0 dnode:%d", newVg1.vgId,
@@ -1757,7 +1805,6 @@ static int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj
 _OVER:
   taosArrayDestroy(pArray);
   mndTransDrop(pTrans);
-  sdbFreeRaw(pRaw);
   return code;
 }
 
@@ -1802,16 +1849,8 @@ static int32_t mndSetBalanceVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SD
 
   {
     SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendRedolog(pTrans, pRaw) != 0) {
-      sdbFreeRaw(pRaw);
-      return -1;
-    }
-    (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-  }
-
-  {
-    SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+    if (pRaw == NULL) return -1;
+    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
       sdbFreeRaw(pRaw);
       return -1;
     }
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 26c9ce6810..83532c2a20 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -2543,6 +2543,7 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader*
       goto _err;
     }
 
+    // TODO: opt the perf of read del index
     code = tsdbReadDelIdx(pDelFReader, aDelIdx);
     if (code != TSDB_CODE_SUCCESS) {
       taosArrayDestroy(aDelIdx);
diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c
index 6c205b5522..dd382411c1 100644
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@@ -515,6 +515,16 @@ void vnodeSyncPreClose(SVnode *pVnode) {
   vInfo("vgId:%d, pre close sync", pVnode->config.vgId);
   syncLeaderTransfer(pVnode->sync);
   syncPreStop(pVnode->sync);
+
+  while (syncSnapshotRecving(pVnode->sync)) {
+    vInfo("vgId:%d, snapshot is recving", pVnode->config.vgId);
+    taosMsleep(300);
+  }
+  while (syncSnapshotSending(pVnode->sync)) {
+    vInfo("vgId:%d, snapshot is sending", pVnode->config.vgId);
+    taosMsleep(300);
+  }
+
   taosThreadMutexLock(&pVnode->lock);
   if (pVnode->blocked) {
     vInfo("vgId:%d, post block after close sync", pVnode->config.vgId);
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index 875528576d..51150ede3c 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -161,4 +161,6 @@ int32_t convertFillType(int32_t mode);
 int32_t resultrowComparAsc(const void* p1, const void* p2);
 int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified);
 
+void printDataBlock(SSDataBlock* pBlock, const char* flag);
+
 #endif  // TDENGINE_QUERYUTIL_H
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index db642c05c8..f17d7f6468 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -538,23 +538,6 @@ typedef struct SStreamIntervalOperatorInfo {
   SWinKey            delKey;
 } SStreamIntervalOperatorInfo;
 
-typedef struct SFillOperatorInfo {
-  struct SFillInfo* pFillInfo;
-  SSDataBlock*      pRes;
-  SSDataBlock*      pFinalRes;
-  int64_t           totalInputRows;
-  void**            p;
-  SSDataBlock*      existNewGroupBlock;
-  STimeWindow       win;
-  SColMatchInfo     matchInfo;
-  int32_t           primaryTsCol;
-  int32_t           primarySrcSlotId;
-  uint64_t          curGroupId;  // current handled group id
-  SExprInfo*        pExprInfo;
-  int32_t           numOfExpr;
-  SExprSupp         noFillExprSupp;
-} SFillOperatorInfo;
-
 typedef struct SDataGroupInfo {
   uint64_t groupId;
   int64_t  numOfRows;
@@ -806,8 +789,6 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead
 int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, qTaskInfo_t* pTaskInfo, SReadHandle* readHandle);
 int32_t getOperatorExplainExecInfo(SOperatorInfo* operatorInfo, SArray* pExecInfoList);
 
-void    printTaskExecCostInLog(SExecTaskInfo* pTaskInfo);
-
 int32_t getMaximumIdleDurationSec();
 
 STimeWindow getActiveTimeWindow(SDiskbasedBuf* pBuf, SResultRowInfo* pResultRowInfo, int64_t ts, SInterval* pInterval,
@@ -825,9 +806,8 @@ bool isDeletedWindow(STimeWindow* pWin, uint64_t groupId, SAggSupporter* pSup);
 bool isDeletedStreamWindow(STimeWindow* pWin, uint64_t groupId, SStreamState* pState, STimeWindowAggSupp* pTwSup);
 void appendOneRowToStreamSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid,
                                       uint64_t* pGp, void* pTbName);
-void printDataBlock(SSDataBlock* pBlock, const char* flag);
-uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId);
-void     calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock);
+uint64_t    calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId);
+void        calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock);
 
 int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
                            SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo);
diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h
index b0017fef50..fad4059515 100644
--- a/source/libs/executor/inc/tfill.h
+++ b/source/libs/executor/inc/tfill.h
@@ -25,6 +25,8 @@ extern "C" {
 #include "tcommon.h"
 #include "tsimplehash.h"
 
+#define GET_DEST_SLOT_ID(_p) ((_p)->pExpr->base.resSchema.slotId)
+
 struct SSDataBlock;
 
 typedef struct SFillColInfo {
@@ -113,12 +115,12 @@ typedef struct SStreamFillInfo {
 
 int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, int64_t ekey, int32_t maxNumOfRows);
 
-void                 taosFillSetStartInfo(struct SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey);
-void                 taosResetFillInfo(struct SFillInfo* pFillInfo, TSKEY startTimestamp);
-void                 taosFillSetInputDataBlock(struct SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
-struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfFillExpr, SExprInfo* pNotFillExpr,
-                                       int32_t numOfNotFillCols, const struct SNodeListNode* val);
-bool                 taosFillHasMoreResults(struct SFillInfo* pFillInfo);
+void          taosFillSetStartInfo(struct SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey);
+void          taosResetFillInfo(struct SFillInfo* pFillInfo, TSKEY startTimestamp);
+void          taosFillSetInputDataBlock(struct SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
+SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfFillExpr, SExprInfo* pNotFillExpr,
+                                int32_t numOfNotFillCols, const struct SNodeListNode* val);
+bool          taosFillHasMoreResults(struct SFillInfo* pFillInfo);
 
 SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity,
                               SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId,
@@ -128,6 +130,8 @@ void*   taosDestroyFillInfo(struct SFillInfo* pFillInfo);
 int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity);
 int64_t getFillInfoStart(struct SFillInfo* pFillInfo);
 
+bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
+                                     int32_t rowIndex);
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c
index b2ddff45a4..963a273290 100644
--- a/source/libs/executor/src/exchangeoperator.c
+++ b/source/libs/executor/src/exchangeoperator.c
@@ -15,26 +15,15 @@
 
 #include "filter.h"
 #include "function.h"
-#include "functionMgt.h"
 #include "os.h"
-#include "querynodes.h"
-#include "tfill.h"
 #include "tname.h"
 #include "tref.h"
-
 #include "tdatablock.h"
-#include "tglobal.h"
 #include "tmsg.h"
-#include "tsort.h"
-#include "ttime.h"
-
 #include "executorimpl.h"
 #include "index.h"
 #include "query.h"
-#include "tcompare.h"
 #include "thash.h"
-#include "ttypes.h"
-#include "vnode.h"
 
 typedef struct SFetchRspHandleWrapper {
   uint32_t exchangeId;
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index b135566caa..8a85885d98 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -2002,3 +2002,13 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
 
   return TSDB_CODE_SUCCESS;
 }
+
+void printDataBlock(SSDataBlock* pBlock, const char* flag) {
+  if (!pBlock || pBlock->info.rows == 0) {
+    qDebug("===stream===printDataBlock: Block is Null or Empty");
+    return;
+  }
+  char* pBuf = NULL;
+  qDebug("%s", dumpBlockData(pBlock, flag, &pBuf));
+  taosMemoryFree(pBuf);
+}
\ No newline at end of file
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 34bd9cf8ca..10ceb9ccee 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -704,6 +704,20 @@ int32_t qAsyncKillTask(qTaskInfo_t qinfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+static void printTaskExecCostInLog(SExecTaskInfo* pTaskInfo) {
+  STaskCostInfo* pSummary = &pTaskInfo->cost;
+
+  SFileBlockLoadRecorder* pRecorder = pSummary->pRecoder;
+  if (pSummary->pRecoder != NULL) {
+    qDebug(
+        "%s :cost summary: elapsed time:%.2f ms, extract tableList:%.2f ms, createGroupIdMap:%.2f ms, total blocks:%d, "
+        "load block SMA:%d, load data block:%d, total rows:%" PRId64 ", check rows:%" PRId64,
+        GET_TASKID(pTaskInfo), pSummary->elapsedTime / 1000.0, pSummary->extractListTime, pSummary->groupIdMapTime,
+        pRecorder->totalBlocks, pRecorder->loadBlockStatis, pRecorder->loadBlocks, pRecorder->totalRows,
+        pRecorder->totalCheckedRows);
+  }
+}
+
 void qDestroyTask(qTaskInfo_t qTaskHandle) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)qTaskHandle;
   if (pTaskInfo == NULL) {
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 164f8ae234..d0d8b42442 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -91,7 +91,6 @@ static void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock*
 
 static void releaseQueryBuf(size_t numOfTables);
 
-static void    destroyFillOperatorInfo(void* param);
 static void    destroyAggOperatorInfo(void* param);
 static void    initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size);
 static void    doSetTableGroupOutputBuf(SOperatorInfo* pOperator, int32_t numOfOutput, uint64_t groupId);
@@ -1157,20 +1156,6 @@ void doBuildResultDatablock(SOperatorInfo* pOperator, SOptrBasicInfo* pbInfo, SG
   }
 }
 
-void printTaskExecCostInLog(SExecTaskInfo* pTaskInfo) {
-  STaskCostInfo* pSummary = &pTaskInfo->cost;
-
-  SFileBlockLoadRecorder* pRecorder = pSummary->pRecoder;
-  if (pSummary->pRecoder != NULL) {
-    qDebug(
-        "%s :cost summary: elapsed time:%.2f ms, extract tableList:%.2f ms, createGroupIdMap:%.2f ms, total blocks:%d, "
-        "load block SMA:%d, load data block:%d, total rows:%" PRId64 ", check rows:%" PRId64,
-        GET_TASKID(pTaskInfo), pSummary->elapsedTime / 1000.0, pSummary->extractListTime, pSummary->groupIdMapTime,
-        pRecorder->totalBlocks, pRecorder->loadBlockStatis, pRecorder->loadBlocks, pRecorder->totalRows,
-        pRecorder->totalCheckedRows);
-  }
-}
-
 // void skipBlocks(STaskRuntimeEnv *pRuntimeEnv) {
 //   STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
 //
@@ -1603,179 +1588,6 @@ static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
   return (rows == 0) ? NULL : pInfo->pRes;
 }
 
-static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo,
-                                               SResultInfo* pResultInfo, SExecTaskInfo* pTaskInfo) {
-  pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
-  SSDataBlock* pResBlock = pInfo->pFinalRes;
-
-  int32_t order = TSDB_ORDER_ASC;
-  int32_t scanFlag = MAIN_SCAN;
-  getTableScanInfo(pOperator, &order, &scanFlag);
-
-  int64_t ekey = pInfo->existNewGroupBlock->info.window.ekey;
-  taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo));
-
-  blockDataCleanup(pInfo->pRes);
-  doApplyScalarCalculation(pOperator, pInfo->existNewGroupBlock, order, scanFlag);
-
-  taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ekey);
-  taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes);
-
-  int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows;
-  taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
-
-  pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId;
-  pInfo->existNewGroupBlock = NULL;
-}
-
-static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo,
-                                            SResultInfo* pResultInfo, SExecTaskInfo* pTaskInfo) {
-  if (taosFillHasMoreResults(pInfo->pFillInfo)) {
-    int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows;
-    taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
-    pInfo->pRes->info.id.groupId = pInfo->curGroupId;
-    return;
-  }
-
-  // handle the cached new group data block
-  if (pInfo->existNewGroupBlock) {
-    doHandleRemainBlockForNewGroupImpl(pOperator, pInfo, pResultInfo, pTaskInfo);
-  }
-}
-
-static void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) {
-  SFillOperatorInfo* pInfo = pOperator->info;
-  SExprSupp*         pSup = &pOperator->exprSupp;
-  setInputDataBlock(pSup, pBlock, order, scanFlag, false);
-  projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL);
-
-  // reset the row value before applying the no-fill functions to the input data block, which is "pBlock" in this case.
-  pInfo->pRes->info.rows = 0;
-  SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp;
-  setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false);
-
-  projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, NULL);
-  pInfo->pRes->info.id.groupId = pBlock->info.id.groupId;
-}
-
-static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
-  SFillOperatorInfo* pInfo = pOperator->info;
-  SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
-
-  SResultInfo* pResultInfo = &pOperator->resultInfo;
-  SSDataBlock* pResBlock = pInfo->pFinalRes;
-
-  blockDataCleanup(pResBlock);
-
-  int32_t order = TSDB_ORDER_ASC;
-  int32_t scanFlag = MAIN_SCAN;
-  getTableScanInfo(pOperator, &order, &scanFlag);
-
-  doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, pTaskInfo);
-  if (pResBlock->info.rows > 0) {
-    pResBlock->info.id.groupId = pInfo->curGroupId;
-    return pResBlock;
-  }
-
-  SOperatorInfo* pDownstream = pOperator->pDownstream[0];
-  while (1) {
-    SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
-    if (pBlock == NULL) {
-      if (pInfo->totalInputRows == 0) {
-        setOperatorCompleted(pOperator);
-        return NULL;
-      }
-
-      taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
-    } else {
-      blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId);
-
-      blockDataCleanup(pInfo->pRes);
-      blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows);
-      blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows);
-      doApplyScalarCalculation(pOperator, pBlock, order, scanFlag);
-
-      if (pInfo->curGroupId == 0 || pInfo->curGroupId == pInfo->pRes->info.id.groupId) {
-        pInfo->curGroupId = pInfo->pRes->info.id.groupId;  // the first data block
-        pInfo->totalInputRows += pInfo->pRes->info.rows;
-
-        if (order == pInfo->pFillInfo->order) {
-          taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, pBlock->info.window.ekey);
-        } else {
-          taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, pBlock->info.window.skey);
-        }
-        taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes);
-      } else if (pInfo->curGroupId != pBlock->info.id.groupId) {  // the new group data block
-        pInfo->existNewGroupBlock = pBlock;
-
-        // Fill the previous group data block, before handle the data block of new group.
-        // Close the fill operation for previous group data block
-        taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
-      }
-    }
-
-    int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows;
-    taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
-
-    // current group has no more result to return
-    if (pResBlock->info.rows > 0) {
-      // 1. The result in current group not reach the threshold of output result, continue
-      // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
-      if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || pInfo->existNewGroupBlock != NULL) {
-        pResBlock->info.id.groupId = pInfo->curGroupId;
-        return pResBlock;
-      }
-
-      doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, pTaskInfo);
-      if (pResBlock->info.rows >= pOperator->resultInfo.threshold || pBlock == NULL) {
-        pResBlock->info.id.groupId = pInfo->curGroupId;
-        return pResBlock;
-      }
-    } else if (pInfo->existNewGroupBlock) {  // try next group
-      assert(pBlock != NULL);
-
-      blockDataCleanup(pResBlock);
-
-      doHandleRemainBlockForNewGroupImpl(pOperator, pInfo, pResultInfo, pTaskInfo);
-      if (pResBlock->info.rows > pResultInfo->threshold) {
-        pResBlock->info.id.groupId = pInfo->curGroupId;
-        return pResBlock;
-      }
-    } else {
-      return NULL;
-    }
-  }
-}
-
-static SSDataBlock* doFill(SOperatorInfo* pOperator) {
-  SFillOperatorInfo* pInfo = pOperator->info;
-  SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
-
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  SSDataBlock* fillResult = NULL;
-  while (true) {
-    fillResult = doFillImpl(pOperator);
-    if (fillResult == NULL) {
-      setOperatorCompleted(pOperator);
-      break;
-    }
-
-    doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
-    if (fillResult->info.rows > 0) {
-      break;
-    }
-  }
-
-  if (fillResult != NULL) {
-    pOperator->resultInfo.totalRows += fillResult->info.rows;
-  }
-
-  return fillResult;
-}
-
 void destroyExprInfo(SExprInfo* pExpr, int32_t numOfExprs) {
   for (int32_t i = 0; i < numOfExprs; ++i) {
     SExprInfo* pExprInfo = &pExpr[i];
@@ -2045,167 +1857,6 @@ void destroyAggOperatorInfo(void* param) {
   taosMemoryFreeClear(param);
 }
 
-void destroyFillOperatorInfo(void* param) {
-  SFillOperatorInfo* pInfo = (SFillOperatorInfo*)param;
-  pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
-  pInfo->pRes = blockDataDestroy(pInfo->pRes);
-  pInfo->pFinalRes = blockDataDestroy(pInfo->pFinalRes);
-
-  cleanupExprSupp(&pInfo->noFillExprSupp);
-
-  taosMemoryFreeClear(pInfo->p);
-  taosArrayDestroy(pInfo->matchInfo.pList);
-  taosMemoryFreeClear(param);
-}
-
-static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr,
-                            int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity,
-                            const char* id, SInterval* pInterval, int32_t fillType, int32_t order) {
-  SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode);
-
-  int64_t     startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey;
-  STimeWindow w = getAlignQueryTimeWindow(pInterval, pInterval->precision, startKey);
-  w = getFirstQualifiedTimeWindow(startKey, &w, pInterval, order);
-
-  pInfo->pFillInfo = taosCreateFillInfo(w.skey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo,
-                                        pInfo->primaryTsCol, order, id);
-
-  if (order == TSDB_ORDER_ASC) {
-    pInfo->win.skey = win.skey;
-    pInfo->win.ekey = win.ekey;
-  } else {
-    pInfo->win.skey = win.ekey;
-    pInfo->win.ekey = win.skey;
-  }
-  pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES);
-
-  if (pInfo->pFillInfo == NULL || pInfo->p == NULL) {
-    taosMemoryFree(pInfo->pFillInfo);
-    taosMemoryFree(pInfo->p);
-    return TSDB_CODE_OUT_OF_MEMORY;
-  } else {
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static bool isWstartColumnExist(SFillOperatorInfo* pInfo) {
-  if (pInfo->noFillExprSupp.numOfExprs == 0) {
-    return false;
-  }
-
-  for (int32_t i = 0; i < pInfo->noFillExprSupp.numOfExprs; ++i) {
-    SExprInfo* exprInfo = pInfo->noFillExprSupp.pExprInfo + i;
-    if (exprInfo->pExpr->nodeType == QUERY_NODE_COLUMN && exprInfo->base.numOfParams == 1 &&
-        exprInfo->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiNode* pPhyFillNode, SExprSupp* pExprSupp,
-                                           const char* idStr) {
-  bool wstartExist = isWstartColumnExist(pInfo);
-
-  if (wstartExist == false) {
-    if (pPhyFillNode->pWStartTs->type != QUERY_NODE_TARGET) {
-      qError("pWStartTs of fill physical node is not a target node, %s", idStr);
-      return TSDB_CODE_QRY_SYS_ERROR;
-    }
-
-    SExprInfo* pExpr = taosMemoryRealloc(pExprSupp->pExprInfo, (pExprSupp->numOfExprs + 1) * sizeof(SExprInfo));
-    if (pExpr == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-
-    createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
-    pExprSupp->numOfExprs += 1;
-    pExprSupp->pExprInfo = pExpr;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode,
-                                      SExecTaskInfo* pTaskInfo) {
-  SFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SFillOperatorInfo));
-  SOperatorInfo*     pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-
-  pInfo->pRes = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
-  SExprInfo* pExprInfo = createExprInfo(pPhyFillNode->pFillExprs, NULL, &pInfo->numOfExpr);
-  pOperator->exprSupp.pExprInfo = pExprInfo;
-
-  SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp;
-  pNoFillSupp->pExprInfo = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &pNoFillSupp->numOfExprs);
-  int32_t code = createPrimaryTsExprIfNeeded(pInfo, pPhyFillNode, pNoFillSupp, pTaskInfo->id.str);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  code = initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  SInterval* pInterval =
-      QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL == downstream->operatorType
-          ? &((SMergeAlignedIntervalAggOperatorInfo*)downstream->info)->intervalAggOperatorInfo->interval
-          : &((SIntervalAggOperatorInfo*)downstream->info)->interval;
-
-  int32_t order = (pPhyFillNode->inputTsOrder == ORDER_ASC) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
-  int32_t type = convertFillType(pPhyFillNode->mode);
-
-  SResultInfo* pResultInfo = &pOperator->resultInfo;
-
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
-  code = initExprSupp(&pOperator->exprSupp, pExprInfo, pInfo->numOfExpr);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  pInfo->primaryTsCol = ((STargetNode*)pPhyFillNode->pWStartTs)->slotId;
-  pInfo->primarySrcSlotId = ((SColumnNode*)((STargetNode*)pPhyFillNode->pWStartTs)->pExpr)->slotId;
-
-  int32_t numOfOutputCols = 0;
-  code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc, &numOfOutputCols,
-                             COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
-
-  code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs,
-                      (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity,
-                      pTaskInfo->id.str, pInterval, type, order);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  pInfo->pFinalRes = createOneDataBlock(pInfo->pRes, false);
-  blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity);
-
-  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->exprSupp.numOfExprs = pInfo->numOfExpr;
-  pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, NULL);
-
-  code = appendDownstream(pOperator, &downstream, 1);
-  return pOperator;
-
-_error:
-  if (pInfo != NULL) {
-    destroyFillOperatorInfo(pInfo);
-  }
-
-  pTaskInfo->code = code;
-  taosMemoryFreeClear(pOperator);
-  return NULL;
-}
-
 static SExecTaskInfo* createExecTaskInfo(uint64_t queryId, uint64_t taskId, EOPTR_EXEC_MODEL model, char* dbFName) {
   SExecTaskInfo* pTaskInfo = taosMemoryCalloc(1, sizeof(SExecTaskInfo));
   if (pTaskInfo == NULL) {
diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c
new file mode 100644
index 0000000000..e26bfe9889
--- /dev/null
+++ b/source/libs/executor/src/filloperator.c
@@ -0,0 +1,1494 @@
+/*
+ * 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 "filter.h"
+#include "os.h"
+#include "query.h"
+#include "taosdef.h"
+#include "tmsg.h"
+#include "ttypes.h"
+
+#include "executorimpl.h"
+#include "tcommon.h"
+#include "thash.h"
+#include "ttime.h"
+
+#include "executorInt.h"
+#include "function.h"
+#include "querynodes.h"
+#include "tdatablock.h"
+#include "tfill.h"
+
+#define FILL_POS_INVALID 0
+#define FILL_POS_START   1
+#define FILL_POS_MID     2
+#define FILL_POS_END     3
+
+typedef struct STimeRange {
+  TSKEY    skey;
+  TSKEY    ekey;
+  uint64_t groupId;
+} STimeRange;
+
+typedef struct SFillOperatorInfo {
+  struct SFillInfo* pFillInfo;
+  SSDataBlock*      pRes;
+  SSDataBlock*      pFinalRes;
+  int64_t           totalInputRows;
+  void**            p;
+  SSDataBlock*      existNewGroupBlock;
+  STimeWindow       win;
+  SColMatchInfo     matchInfo;
+  int32_t           primaryTsCol;
+  int32_t           primarySrcSlotId;
+  uint64_t          curGroupId;  // current handled group id
+  SExprInfo*        pExprInfo;
+  int32_t           numOfExpr;
+  SExprSupp         noFillExprSupp;
+} SFillOperatorInfo;
+
+static void destroyFillOperatorInfo(void* param);
+static void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag);
+
+static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo,
+                                               SResultInfo* pResultInfo, SExecTaskInfo* pTaskInfo) {
+  pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
+  SSDataBlock* pResBlock = pInfo->pFinalRes;
+
+  int32_t order = TSDB_ORDER_ASC;
+  int32_t scanFlag = MAIN_SCAN;
+  getTableScanInfo(pOperator, &order, &scanFlag);
+
+  int64_t ekey = pInfo->existNewGroupBlock->info.window.ekey;
+  taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo));
+
+  blockDataCleanup(pInfo->pRes);
+  doApplyScalarCalculation(pOperator, pInfo->existNewGroupBlock, order, scanFlag);
+
+  taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ekey);
+  taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes);
+
+  int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows;
+  taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+
+  pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId;
+  pInfo->existNewGroupBlock = NULL;
+}
+
+static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo,
+                                            SResultInfo* pResultInfo, SExecTaskInfo* pTaskInfo) {
+  if (taosFillHasMoreResults(pInfo->pFillInfo)) {
+    int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows;
+    taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
+    pInfo->pRes->info.id.groupId = pInfo->curGroupId;
+    return;
+  }
+
+  // handle the cached new group data block
+  if (pInfo->existNewGroupBlock) {
+    doHandleRemainBlockForNewGroupImpl(pOperator, pInfo, pResultInfo, pTaskInfo);
+  }
+}
+
+void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) {
+  SFillOperatorInfo* pInfo = pOperator->info;
+  SExprSupp*         pSup = &pOperator->exprSupp;
+  setInputDataBlock(pSup, pBlock, order, scanFlag, false);
+  projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL);
+
+  // reset the row value before applying the no-fill functions to the input data block, which is "pBlock" in this case.
+  pInfo->pRes->info.rows = 0;
+  SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp;
+  setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false);
+
+  projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, NULL);
+  pInfo->pRes->info.id.groupId = pBlock->info.id.groupId;
+}
+
+static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
+  SFillOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
+
+  SResultInfo* pResultInfo = &pOperator->resultInfo;
+  SSDataBlock* pResBlock = pInfo->pFinalRes;
+
+  blockDataCleanup(pResBlock);
+
+  int32_t order = TSDB_ORDER_ASC;
+  int32_t scanFlag = MAIN_SCAN;
+  getTableScanInfo(pOperator, &order, &scanFlag);
+
+  doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, pTaskInfo);
+  if (pResBlock->info.rows > 0) {
+    pResBlock->info.id.groupId = pInfo->curGroupId;
+    return pResBlock;
+  }
+
+  SOperatorInfo* pDownstream = pOperator->pDownstream[0];
+  while (1) {
+    SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
+    if (pBlock == NULL) {
+      if (pInfo->totalInputRows == 0) {
+        setOperatorCompleted(pOperator);
+        return NULL;
+      }
+
+      taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
+    } else {
+      blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId);
+
+      blockDataCleanup(pInfo->pRes);
+      blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows);
+      blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows);
+      doApplyScalarCalculation(pOperator, pBlock, order, scanFlag);
+
+      if (pInfo->curGroupId == 0 || pInfo->curGroupId == pInfo->pRes->info.id.groupId) {
+        pInfo->curGroupId = pInfo->pRes->info.id.groupId;  // the first data block
+        pInfo->totalInputRows += pInfo->pRes->info.rows;
+
+        if (order == pInfo->pFillInfo->order) {
+          taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, pBlock->info.window.ekey);
+        } else {
+          taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, pBlock->info.window.skey);
+        }
+        taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes);
+      } else if (pInfo->curGroupId != pBlock->info.id.groupId) {  // the new group data block
+        pInfo->existNewGroupBlock = pBlock;
+
+        // Fill the previous group data block, before handle the data block of new group.
+        // Close the fill operation for previous group data block
+        taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
+      }
+    }
+
+    int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows;
+    taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+
+    // current group has no more result to return
+    if (pResBlock->info.rows > 0) {
+      // 1. The result in current group not reach the threshold of output result, continue
+      // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
+      if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || pInfo->existNewGroupBlock != NULL) {
+        pResBlock->info.id.groupId = pInfo->curGroupId;
+        return pResBlock;
+      }
+
+      doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, pTaskInfo);
+      if (pResBlock->info.rows >= pOperator->resultInfo.threshold || pBlock == NULL) {
+        pResBlock->info.id.groupId = pInfo->curGroupId;
+        return pResBlock;
+      }
+    } else if (pInfo->existNewGroupBlock) {  // try next group
+      assert(pBlock != NULL);
+
+      blockDataCleanup(pResBlock);
+
+      doHandleRemainBlockForNewGroupImpl(pOperator, pInfo, pResultInfo, pTaskInfo);
+      if (pResBlock->info.rows > pResultInfo->threshold) {
+        pResBlock->info.id.groupId = pInfo->curGroupId;
+        return pResBlock;
+      }
+    } else {
+      return NULL;
+    }
+  }
+}
+
+static SSDataBlock* doFill(SOperatorInfo* pOperator) {
+  SFillOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
+
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  SSDataBlock* fillResult = NULL;
+  while (true) {
+    fillResult = doFillImpl(pOperator);
+    if (fillResult == NULL) {
+      setOperatorCompleted(pOperator);
+      break;
+    }
+
+    doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
+    if (fillResult->info.rows > 0) {
+      break;
+    }
+  }
+
+  if (fillResult != NULL) {
+    pOperator->resultInfo.totalRows += fillResult->info.rows;
+  }
+
+  return fillResult;
+}
+
+void destroyFillOperatorInfo(void* param) {
+  SFillOperatorInfo* pInfo = (SFillOperatorInfo*)param;
+  pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
+  pInfo->pRes = blockDataDestroy(pInfo->pRes);
+  pInfo->pFinalRes = blockDataDestroy(pInfo->pFinalRes);
+
+  cleanupExprSupp(&pInfo->noFillExprSupp);
+
+  taosMemoryFreeClear(pInfo->p);
+  taosArrayDestroy(pInfo->matchInfo.pList);
+  taosMemoryFreeClear(param);
+}
+
+static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr,
+                            int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity,
+                            const char* id, SInterval* pInterval, int32_t fillType, int32_t order) {
+  SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode);
+
+  int64_t     startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey;
+  STimeWindow w = getAlignQueryTimeWindow(pInterval, pInterval->precision, startKey);
+  w = getFirstQualifiedTimeWindow(startKey, &w, pInterval, order);
+
+  pInfo->pFillInfo = taosCreateFillInfo(w.skey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo,
+                                        pInfo->primaryTsCol, order, id);
+
+  if (order == TSDB_ORDER_ASC) {
+    pInfo->win.skey = win.skey;
+    pInfo->win.ekey = win.ekey;
+  } else {
+    pInfo->win.skey = win.ekey;
+    pInfo->win.ekey = win.skey;
+  }
+  pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES);
+
+  if (pInfo->pFillInfo == NULL || pInfo->p == NULL) {
+    taosMemoryFree(pInfo->pFillInfo);
+    taosMemoryFree(pInfo->p);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  } else {
+    return TSDB_CODE_SUCCESS;
+  }
+}
+
+static bool isWstartColumnExist(SFillOperatorInfo* pInfo) {
+  if (pInfo->noFillExprSupp.numOfExprs == 0) {
+    return false;
+  }
+
+  for (int32_t i = 0; i < pInfo->noFillExprSupp.numOfExprs; ++i) {
+    SExprInfo* exprInfo = pInfo->noFillExprSupp.pExprInfo + i;
+    if (exprInfo->pExpr->nodeType == QUERY_NODE_COLUMN && exprInfo->base.numOfParams == 1 &&
+        exprInfo->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiNode* pPhyFillNode, SExprSupp* pExprSupp,
+                                           const char* idStr) {
+  bool wstartExist = isWstartColumnExist(pInfo);
+
+  if (wstartExist == false) {
+    if (pPhyFillNode->pWStartTs->type != QUERY_NODE_TARGET) {
+      qError("pWStartTs of fill physical node is not a target node, %s", idStr);
+      return TSDB_CODE_QRY_SYS_ERROR;
+    }
+
+    SExprInfo* pExpr = taosMemoryRealloc(pExprSupp->pExprInfo, (pExprSupp->numOfExprs + 1) * sizeof(SExprInfo));
+    if (pExpr == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+
+    createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
+    pExprSupp->numOfExprs += 1;
+    pExprSupp->pExprInfo = pExpr;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode,
+                                      SExecTaskInfo* pTaskInfo) {
+  SFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SFillOperatorInfo));
+  SOperatorInfo*     pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    goto _error;
+  }
+
+  pInfo->pRes = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
+  SExprInfo* pExprInfo = createExprInfo(pPhyFillNode->pFillExprs, NULL, &pInfo->numOfExpr);
+  pOperator->exprSupp.pExprInfo = pExprInfo;
+
+  SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp;
+  pNoFillSupp->pExprInfo = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &pNoFillSupp->numOfExprs);
+  int32_t code = createPrimaryTsExprIfNeeded(pInfo, pPhyFillNode, pNoFillSupp, pTaskInfo->id.str);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  code = initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  SInterval* pInterval =
+      QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL == downstream->operatorType
+      ? &((SMergeAlignedIntervalAggOperatorInfo*)downstream->info)->intervalAggOperatorInfo->interval
+      : &((SIntervalAggOperatorInfo*)downstream->info)->interval;
+
+  int32_t order = (pPhyFillNode->inputTsOrder == ORDER_ASC) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
+  int32_t type = convertFillType(pPhyFillNode->mode);
+
+  SResultInfo* pResultInfo = &pOperator->resultInfo;
+
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  code = initExprSupp(&pOperator->exprSupp, pExprInfo, pInfo->numOfExpr);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->primaryTsCol = ((STargetNode*)pPhyFillNode->pWStartTs)->slotId;
+  pInfo->primarySrcSlotId = ((SColumnNode*)((STargetNode*)pPhyFillNode->pWStartTs)->pExpr)->slotId;
+
+  int32_t numOfOutputCols = 0;
+  code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc, &numOfOutputCols,
+                             COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
+
+  code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs,
+                      (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity,
+                      pTaskInfo->id.str, pInterval, type, order);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->pFinalRes = createOneDataBlock(pInfo->pRes, false);
+  blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity);
+
+  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo);
+  pOperator->exprSupp.numOfExprs = pInfo->numOfExpr;
+  pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, NULL);
+
+  code = appendDownstream(pOperator, &downstream, 1);
+  return pOperator;
+
+  _error:
+  if (pInfo != NULL) {
+    destroyFillOperatorInfo(pInfo);
+  }
+
+  pTaskInfo->code = code;
+  taosMemoryFreeClear(pOperator);
+  return NULL;
+}
+
+TSKEY getNextWindowTs(TSKEY ts, SInterval* pInterval) {
+  STimeWindow win = {.skey = ts, .ekey = ts};
+  getNextIntervalWindow(pInterval, &win, TSDB_ORDER_ASC);
+  return win.skey;
+}
+
+TSKEY getPrevWindowTs(TSKEY ts, SInterval* pInterval) {
+  STimeWindow win = {.skey = ts, .ekey = ts};
+  getNextIntervalWindow(pInterval, &win, TSDB_ORDER_DESC);
+  return win.skey;
+}
+
+void setRowCell(SColumnInfoData* pCol, int32_t rowId, const SResultCellData* pCell) {
+  colDataAppend(pCol, rowId, pCell->pData, pCell->isNull);
+}
+
+SResultCellData* getResultCell(SResultRowData* pRaw, int32_t index) {
+  if (!pRaw || !pRaw->pRowVal) {
+    return NULL;
+  }
+  char*            pData = (char*)pRaw->pRowVal;
+  SResultCellData* pCell = pRaw->pRowVal;
+  for (int32_t i = 0; i < index; i++) {
+    pData += (pCell->bytes + sizeof(SResultCellData));
+    pCell = (SResultCellData*)pData;
+  }
+  return pCell;
+}
+
+void* destroyFillColumnInfo(SFillColInfo* pFillCol, int32_t start, int32_t end) {
+  for (int32_t i = start; i < end; i++) {
+    destroyExprInfo(pFillCol[i].pExpr, 1);
+    taosVariantDestroy(&pFillCol[i].fillVal);
+  }
+  taosMemoryFreeClear(pFillCol[start].pExpr);
+  taosMemoryFree(pFillCol);
+  return NULL;
+}
+
+void* destroyStreamFillSupporter(SStreamFillSupporter* pFillSup) {
+  pFillSup->pAllColInfo = destroyFillColumnInfo(pFillSup->pAllColInfo, pFillSup->numOfFillCols, pFillSup->numOfAllCols);
+  tSimpleHashCleanup(pFillSup->pResMap);
+  pFillSup->pResMap = NULL;
+  releaseOutputBuf(NULL, NULL, (SResultRow*)pFillSup->cur.pRowVal);
+  pFillSup->cur.pRowVal = NULL;
+  cleanupExprSupp(&pFillSup->notFillExprSup);
+
+  taosMemoryFree(pFillSup);
+  return NULL;
+}
+
+void* destroyStreamFillLinearInfo(SStreamFillLinearInfo* pFillLinear) {
+  taosArrayDestroy(pFillLinear->pDeltaVal);
+  taosArrayDestroy(pFillLinear->pNextDeltaVal);
+  taosMemoryFree(pFillLinear);
+  return NULL;
+}
+void* destroyStreamFillInfo(SStreamFillInfo* pFillInfo) {
+  if (pFillInfo->type == TSDB_FILL_SET_VALUE || pFillInfo->type == TSDB_FILL_NULL) {
+    taosMemoryFreeClear(pFillInfo->pResRow->pRowVal);
+    taosMemoryFreeClear(pFillInfo->pResRow);
+  }
+  pFillInfo->pLinearInfo = destroyStreamFillLinearInfo(pFillInfo->pLinearInfo);
+  taosArrayDestroy(pFillInfo->delRanges);
+  taosMemoryFree(pFillInfo);
+  return NULL;
+}
+
+static void destroyStreamFillOperatorInfo(void* param) {
+  SStreamFillOperatorInfo* pInfo = (SStreamFillOperatorInfo*)param;
+  pInfo->pFillInfo = destroyStreamFillInfo(pInfo->pFillInfo);
+  pInfo->pFillSup = destroyStreamFillSupporter(pInfo->pFillSup);
+  pInfo->pRes = blockDataDestroy(pInfo->pRes);
+  pInfo->pSrcBlock = blockDataDestroy(pInfo->pSrcBlock);
+  pInfo->pPrevSrcBlock = blockDataDestroy(pInfo->pPrevSrcBlock);
+  pInfo->pDelRes = blockDataDestroy(pInfo->pDelRes);
+  pInfo->matchInfo.pList = taosArrayDestroy(pInfo->matchInfo.pList);
+  taosMemoryFree(pInfo);
+}
+
+static void resetFillWindow(SResultRowData* pRowData) {
+  pRowData->key = INT64_MIN;
+  pRowData->pRowVal = NULL;
+}
+
+void resetPrevAndNextWindow(SStreamFillSupporter* pFillSup, SStreamState* pState) {
+  resetFillWindow(&pFillSup->prev);
+  releaseOutputBuf(NULL, NULL, (SResultRow*)pFillSup->cur.pRowVal);
+  resetFillWindow(&pFillSup->cur);
+  resetFillWindow(&pFillSup->next);
+  resetFillWindow(&pFillSup->nextNext);
+}
+
+void getCurWindowFromDiscBuf(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId, SStreamFillSupporter* pFillSup) {
+  SStreamState* pState = pOperator->pTaskInfo->streamInfo.pState;
+  resetPrevAndNextWindow(pFillSup, pState);
+
+  SWinKey key = {.ts = ts, .groupId = groupId};
+  int32_t curVLen = 0;
+  int32_t code = streamStateFillGet(pState, &key, (void**)&pFillSup->cur.pRowVal, &curVLen);
+  ASSERT(code == TSDB_CODE_SUCCESS);
+  pFillSup->cur.key = key.ts;
+}
+
+void getWindowFromDiscBuf(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId, SStreamFillSupporter* pFillSup) {
+  SStreamState* pState = pOperator->pTaskInfo->streamInfo.pState;
+  resetPrevAndNextWindow(pFillSup, pState);
+
+  SWinKey key = {.ts = ts, .groupId = groupId};
+  void*   curVal = NULL;
+  int32_t curVLen = 0;
+  int32_t code = streamStateFillGet(pState, &key, (void**)&curVal, &curVLen);
+  ASSERT(code == TSDB_CODE_SUCCESS);
+  pFillSup->cur.key = key.ts;
+  pFillSup->cur.pRowVal = curVal;
+
+  SStreamStateCur* pCur = streamStateFillSeekKeyPrev(pState, &key);
+  SWinKey          preKey = {.groupId = groupId};
+  void*            preVal = NULL;
+  int32_t          preVLen = 0;
+  code = streamStateGetGroupKVByCur(pCur, &preKey, (const void**)&preVal, &preVLen);
+
+  if (code == TSDB_CODE_SUCCESS) {
+    pFillSup->prev.key = preKey.ts;
+    pFillSup->prev.pRowVal = preVal;
+
+    code = streamStateCurNext(pState, pCur);
+    ASSERT(code == TSDB_CODE_SUCCESS);
+
+    code = streamStateCurNext(pState, pCur);
+    if (code != TSDB_CODE_SUCCESS) {
+      streamStateFreeCur(pCur);
+      pCur = NULL;
+    }
+  } else {
+    streamStateFreeCur(pCur);
+    pCur = streamStateFillSeekKeyNext(pState, &key);
+  }
+
+  SWinKey nextKey = {.groupId = groupId};
+  void*   nextVal = NULL;
+  int32_t nextVLen = 0;
+  code = streamStateGetGroupKVByCur(pCur, &nextKey, (const void**)&nextVal, &nextVLen);
+  if (code == TSDB_CODE_SUCCESS) {
+    pFillSup->next.key = nextKey.ts;
+    pFillSup->next.pRowVal = nextVal;
+    if (pFillSup->type == TSDB_FILL_PREV || pFillSup->type == TSDB_FILL_NEXT) {
+      code = streamStateCurNext(pState, pCur);
+      if (code == TSDB_CODE_SUCCESS) {
+        SWinKey nextNextKey = {.groupId = groupId};
+        void*   nextNextVal = NULL;
+        int32_t nextNextVLen = 0;
+        code = streamStateGetGroupKVByCur(pCur, &nextNextKey, (const void**)&nextNextVal, &nextNextVLen);
+        if (code == TSDB_CODE_SUCCESS) {
+          pFillSup->nextNext.key = nextNextKey.ts;
+          pFillSup->nextNext.pRowVal = nextNextVal;
+        }
+      }
+    }
+  }
+  streamStateFreeCur(pCur);
+}
+
+static bool hasPrevWindow(SStreamFillSupporter* pFillSup) { return pFillSup->prev.key != INT64_MIN; }
+static bool hasNextWindow(SStreamFillSupporter* pFillSup) { return pFillSup->next.key != INT64_MIN; }
+static bool hasNextNextWindow(SStreamFillSupporter* pFillSup) {
+  return pFillSup->nextNext.key != INT64_MIN;
+  return false;
+}
+
+static void transBlockToResultRow(const SSDataBlock* pBlock, int32_t rowId, TSKEY ts, SResultRowData* pRowVal) {
+  int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
+    SResultCellData* pCell = getResultCell(pRowVal, i);
+    if (!colDataIsNull_s(pColData, rowId)) {
+      pCell->isNull = false;
+      pCell->type = pColData->info.type;
+      pCell->bytes = pColData->info.bytes;
+      char* val = colDataGetData(pColData, rowId);
+      if (IS_VAR_DATA_TYPE(pCell->type)) {
+        memcpy(pCell->pData, val, varDataTLen(val));
+      } else {
+        memcpy(pCell->pData, val, pCell->bytes);
+      }
+    } else {
+      pCell->isNull = true;
+    }
+  }
+  pRowVal->key = ts;
+}
+
+static void calcDeltaData(SSDataBlock* pBlock, int32_t rowId, SResultRowData* pRowVal, SArray* pDelta,
+                          SFillColInfo* pFillCol, int32_t numOfCol, int32_t winCount, int32_t order) {
+  for (int32_t i = 0; i < numOfCol; i++) {
+    if (!pFillCol[i].notFillCol) {
+      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol + i);
+      SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+      char*            var = colDataGetData(pCol, rowId);
+      double           start = 0;
+      GET_TYPED_DATA(start, double, pCol->info.type, var);
+      SResultCellData* pCell = getResultCell(pRowVal, slotId);
+      double           end = 0;
+      GET_TYPED_DATA(end, double, pCell->type, pCell->pData);
+      double delta = 0;
+      if (order == TSDB_ORDER_ASC) {
+        delta = (end - start) / winCount;
+      } else {
+        delta = (start - end) / winCount;
+      }
+      taosArraySet(pDelta, slotId, &delta);
+    }
+  }
+}
+
+static void calcRowDeltaData(SResultRowData* pStartRow, SResultRowData* pEndRow, SArray* pDelta, SFillColInfo* pFillCol,
+                             int32_t numOfCol, int32_t winCount) {
+  for (int32_t i = 0; i < numOfCol; i++) {
+    if (!pFillCol[i].notFillCol) {
+      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol + i);
+      SResultCellData* pSCell = getResultCell(pStartRow, slotId);
+      double           start = 0.0;
+      GET_TYPED_DATA(start, double, pSCell->type, pSCell->pData);
+      SResultCellData* pECell = getResultCell(pEndRow, slotId);
+      double           end = 0.0;
+      GET_TYPED_DATA(end, double, pECell->type, pECell->pData);
+      double delta = (end - start) / winCount;
+      taosArraySet(pDelta, slotId, &delta);
+    }
+  }
+}
+
+static void setFillInfoStart(TSKEY ts, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
+  ts = taosTimeAdd(ts, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
+  pFillInfo->start = ts;
+}
+
+static void setFillInfoEnd(TSKEY ts, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
+  ts = taosTimeAdd(ts, pInterval->sliding * -1, pInterval->slidingUnit, pInterval->precision);
+  pFillInfo->end = ts;
+}
+
+static void setFillKeyInfo(TSKEY start, TSKEY end, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
+  setFillInfoStart(start, pInterval, pFillInfo);
+  pFillInfo->current = pFillInfo->start;
+  setFillInfoEnd(end, pInterval, pFillInfo);
+}
+
+void setDeleteFillValueInfo(TSKEY start, TSKEY end, SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo) {
+  if (!hasPrevWindow(pFillSup) || !hasNextWindow(pFillSup)) {
+    pFillInfo->needFill = false;
+    return;
+  }
+
+  TSKEY realStart = taosTimeAdd(pFillSup->prev.key, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
+                                pFillSup->interval.precision);
+
+  pFillInfo->needFill = true;
+  pFillInfo->start = realStart;
+  pFillInfo->current = pFillInfo->start;
+  pFillInfo->end = end;
+  pFillInfo->pos = FILL_POS_INVALID;
+  switch (pFillInfo->type) {
+    case TSDB_FILL_NULL:
+    case TSDB_FILL_SET_VALUE:
+      break;
+    case TSDB_FILL_PREV:
+      pFillInfo->pResRow = &pFillSup->prev;
+      break;
+    case TSDB_FILL_NEXT:
+      pFillInfo->pResRow = &pFillSup->next;
+      break;
+    case TSDB_FILL_LINEAR: {
+      setFillKeyInfo(pFillSup->prev.key, pFillSup->next.key, &pFillSup->interval, pFillInfo);
+      pFillInfo->pLinearInfo->hasNext = false;
+      pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
+      int32_t numOfWins = taosTimeCountInterval(pFillSup->prev.key, pFillSup->next.key, pFillSup->interval.sliding,
+                                                pFillSup->interval.slidingUnit, pFillSup->interval.precision);
+      calcRowDeltaData(&pFillSup->prev, &pFillSup->next, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
+                       pFillSup->numOfAllCols, numOfWins);
+      pFillInfo->pResRow = &pFillSup->prev;
+      pFillInfo->pLinearInfo->winIndex = 0;
+    } break;
+    default:
+      ASSERT(0);
+      break;
+  }
+}
+
+void copyNotFillExpData(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo) {
+  for (int32_t i = pFillSup->numOfFillCols; i < pFillSup->numOfAllCols; ++i) {
+    SFillColInfo*    pFillCol = pFillSup->pAllColInfo + i;
+    int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
+    SResultCellData* pCell = getResultCell(pFillInfo->pResRow, slotId);
+    SResultCellData* pCurCell = getResultCell(&pFillSup->cur, slotId);
+    pCell->isNull = pCurCell->isNull;
+    if (!pCurCell->isNull) {
+      memcpy(pCell->pData, pCurCell->pData, pCell->bytes);
+    }
+  }
+}
+
+void setFillValueInfo(SSDataBlock* pBlock, TSKEY ts, int32_t rowId, SStreamFillSupporter* pFillSup,
+                      SStreamFillInfo* pFillInfo) {
+  pFillInfo->preRowKey = pFillSup->cur.key;
+  if (!hasPrevWindow(pFillSup) && !hasNextWindow(pFillSup)) {
+    pFillInfo->needFill = false;
+    pFillInfo->pos = FILL_POS_START;
+    return;
+  }
+  TSKEY prevWKey = INT64_MIN;
+  TSKEY nextWKey = INT64_MIN;
+  if (hasPrevWindow(pFillSup)) {
+    prevWKey = pFillSup->prev.key;
+  }
+  if (hasNextWindow(pFillSup)) {
+    nextWKey = pFillSup->next.key;
+  }
+
+  pFillInfo->needFill = true;
+  pFillInfo->pos = FILL_POS_INVALID;
+  switch (pFillInfo->type) {
+    case TSDB_FILL_NULL:
+    case TSDB_FILL_SET_VALUE: {
+      if (pFillSup->prev.key == pFillInfo->preRowKey) {
+        resetFillWindow(&pFillSup->prev);
+      }
+      if (hasPrevWindow(pFillSup) && hasNextWindow(pFillSup)) {
+        if (pFillSup->next.key == pFillInfo->nextRowKey) {
+          pFillInfo->preRowKey = INT64_MIN;
+          setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+          pFillInfo->pos = FILL_POS_END;
+        } else {
+          pFillInfo->needFill = false;
+          pFillInfo->pos = FILL_POS_START;
+        }
+      } else if (hasPrevWindow(pFillSup)) {
+        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_END;
+      } else {
+        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_START;
+      }
+      copyNotFillExpData(pFillSup, pFillInfo);
+    } break;
+    case TSDB_FILL_PREV: {
+      if (hasNextWindow(pFillSup) && ((pFillSup->next.key != pFillInfo->nextRowKey) ||
+                                      (pFillSup->next.key == pFillInfo->nextRowKey && hasNextNextWindow(pFillSup)) ||
+                                      (pFillSup->next.key == pFillInfo->nextRowKey && !hasPrevWindow(pFillSup)))) {
+        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_START;
+        pFillSup->prev.key = pFillSup->cur.key;
+        pFillSup->prev.pRowVal = pFillSup->cur.pRowVal;
+      } else if (hasPrevWindow(pFillSup)) {
+        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_END;
+        pFillInfo->preRowKey = INT64_MIN;
+      }
+      pFillInfo->pResRow = &pFillSup->prev;
+    } break;
+    case TSDB_FILL_NEXT: {
+      if (hasPrevWindow(pFillSup)) {
+        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_END;
+        pFillSup->next.key = pFillSup->cur.key;
+        pFillSup->next.pRowVal = pFillSup->cur.pRowVal;
+        pFillInfo->preRowKey = INT64_MIN;
+      } else {
+        ASSERT(hasNextWindow(pFillSup));
+        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_START;
+      }
+      pFillInfo->pResRow = &pFillSup->next;
+    } break;
+    case TSDB_FILL_LINEAR: {
+      pFillInfo->pLinearInfo->winIndex = 0;
+      if (hasPrevWindow(pFillSup) && hasNextWindow(pFillSup)) {
+        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_MID;
+        pFillInfo->pLinearInfo->nextEnd = nextWKey;
+        int32_t numOfWins = taosTimeCountInterval(prevWKey, ts, pFillSup->interval.sliding,
+                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
+        calcRowDeltaData(&pFillSup->prev, &pFillSup->cur, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
+                         pFillSup->numOfAllCols, numOfWins);
+        pFillInfo->pResRow = &pFillSup->prev;
+
+        numOfWins = taosTimeCountInterval(ts, nextWKey, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
+                                          pFillSup->interval.precision);
+        calcRowDeltaData(&pFillSup->cur, &pFillSup->next, pFillInfo->pLinearInfo->pNextDeltaVal, pFillSup->pAllColInfo,
+                         pFillSup->numOfAllCols, numOfWins);
+        pFillInfo->pLinearInfo->hasNext = true;
+      } else if (hasPrevWindow(pFillSup)) {
+        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_END;
+        pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
+        int32_t numOfWins = taosTimeCountInterval(prevWKey, ts, pFillSup->interval.sliding,
+                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
+        calcRowDeltaData(&pFillSup->prev, &pFillSup->cur, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
+                         pFillSup->numOfAllCols, numOfWins);
+        pFillInfo->pResRow = &pFillSup->prev;
+        pFillInfo->pLinearInfo->hasNext = false;
+      } else {
+        ASSERT(hasNextWindow(pFillSup));
+        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
+        pFillInfo->pos = FILL_POS_START;
+        pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
+        int32_t numOfWins = taosTimeCountInterval(ts, nextWKey, pFillSup->interval.sliding,
+                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
+        calcRowDeltaData(&pFillSup->cur, &pFillSup->next, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
+                         pFillSup->numOfAllCols, numOfWins);
+        pFillInfo->pResRow = &pFillSup->cur;
+        pFillInfo->pLinearInfo->hasNext = false;
+      }
+    } break;
+    default:
+      ASSERT(0);
+      break;
+  }
+  ASSERT(pFillInfo->pos != FILL_POS_INVALID);
+}
+
+static bool checkResult(SStreamFillSupporter* pFillSup, TSKEY ts, uint64_t groupId) {
+  SWinKey key = {.groupId = groupId, .ts = ts};
+  if (tSimpleHashGet(pFillSup->pResMap, &key, sizeof(SWinKey)) != NULL) {
+    return false;
+  }
+  tSimpleHashPut(pFillSup->pResMap, &key, sizeof(SWinKey), NULL, 0);
+  return true;
+}
+
+static void buildFillResult(SResultRowData* pResRow, SStreamFillSupporter* pFillSup, TSKEY ts, SSDataBlock* pBlock) {
+  uint64_t groupId = pBlock->info.id.groupId;
+  if (pFillSup->hasDelete && !checkResult(pFillSup, ts, groupId)) {
+    return;
+  }
+  for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
+    SFillColInfo*    pFillCol = pFillSup->pAllColInfo + i;
+    int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
+    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, slotId);
+    SFillInfo        tmpInfo = {
+        .currentKey = ts,
+        .order = TSDB_ORDER_ASC,
+        .interval = pFillSup->interval,
+    };
+    bool filled = fillIfWindowPseudoColumn(&tmpInfo, pFillCol, pColData, pBlock->info.rows);
+    if (!filled) {
+      SResultCellData* pCell = getResultCell(pResRow, slotId);
+      setRowCell(pColData, pBlock->info.rows, pCell);
+    }
+  }
+  pBlock->info.rows++;
+}
+
+static bool hasRemainCalc(SStreamFillInfo* pFillInfo) {
+  if (pFillInfo->current != INT64_MIN && pFillInfo->current <= pFillInfo->end) {
+    return true;
+  }
+  return false;
+}
+
+static void doStreamFillNormal(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock) {
+  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
+    buildFillResult(pFillInfo->pResRow, pFillSup, pFillInfo->current, pBlock);
+    pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
+                                     pFillSup->interval.precision);
+  }
+}
+
+static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock) {
+  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
+    uint64_t groupId = pBlock->info.id.groupId;
+    SWinKey  key = {.groupId = groupId, .ts = pFillInfo->current};
+    if (pFillSup->hasDelete && !checkResult(pFillSup, pFillInfo->current, groupId)) {
+      pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
+                                       pFillSup->interval.precision);
+      pFillInfo->pLinearInfo->winIndex++;
+      continue;
+    }
+    pFillInfo->pLinearInfo->winIndex++;
+    for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
+      SFillColInfo* pFillCol = pFillSup->pAllColInfo + i;
+      SFillInfo     tmp = {
+          .currentKey = pFillInfo->current,
+          .order = TSDB_ORDER_ASC,
+          .interval = pFillSup->interval,
+      };
+
+      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
+      SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, slotId);
+      int16_t          type = pColData->info.type;
+      SResultCellData* pCell = getResultCell(pFillInfo->pResRow, slotId);
+      int32_t          index = pBlock->info.rows;
+      if (pFillCol->notFillCol) {
+        bool filled = fillIfWindowPseudoColumn(&tmp, pFillCol, pColData, index);
+        if (!filled) {
+          setRowCell(pColData, index, pCell);
+        }
+      } else {
+        if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pCell->isNull) {
+          colDataAppendNULL(pColData, index);
+          continue;
+        }
+        double* pDelta = taosArrayGet(pFillInfo->pLinearInfo->pDeltaVal, slotId);
+        double  vCell = 0;
+        GET_TYPED_DATA(vCell, double, pCell->type, pCell->pData);
+        vCell += (*pDelta) * pFillInfo->pLinearInfo->winIndex;
+        int64_t result = 0;
+        SET_TYPED_DATA(&result, pCell->type, vCell);
+        colDataAppend(pColData, index, (const char*)&result, false);
+      }
+    }
+    pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
+                                     pFillSup->interval.precision);
+    pBlock->info.rows++;
+  }
+}
+
+static void keepResultInDiscBuf(SOperatorInfo* pOperator, uint64_t groupId, SResultRowData* pRow, int32_t len) {
+  SWinKey key = {.groupId = groupId, .ts = pRow->key};
+  int32_t code = streamStateFillPut(pOperator->pTaskInfo->streamInfo.pState, &key, pRow->pRowVal, len);
+  ASSERT(code == TSDB_CODE_SUCCESS);
+}
+
+static void doStreamFillRange(SStreamFillInfo* pFillInfo, SStreamFillSupporter* pFillSup, SSDataBlock* pRes) {
+  if (pFillInfo->needFill == false) {
+    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
+    return;
+  }
+
+  if (pFillInfo->pos == FILL_POS_START) {
+    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
+  }
+  if (pFillInfo->type != TSDB_FILL_LINEAR) {
+    doStreamFillNormal(pFillSup, pFillInfo, pRes);
+  } else {
+    doStreamFillLinear(pFillSup, pFillInfo, pRes);
+
+    if (pFillInfo->pos == FILL_POS_MID) {
+      buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
+    }
+
+    if (pFillInfo->current > pFillInfo->end && pFillInfo->pLinearInfo->hasNext) {
+      pFillInfo->pLinearInfo->hasNext = false;
+      pFillInfo->pLinearInfo->winIndex = 0;
+      taosArrayClear(pFillInfo->pLinearInfo->pDeltaVal);
+      taosArrayAddAll(pFillInfo->pLinearInfo->pDeltaVal, pFillInfo->pLinearInfo->pNextDeltaVal);
+      pFillInfo->pResRow = &pFillSup->cur;
+      setFillKeyInfo(pFillSup->cur.key, pFillInfo->pLinearInfo->nextEnd, &pFillSup->interval, pFillInfo);
+      doStreamFillLinear(pFillSup, pFillInfo, pRes);
+    }
+  }
+  if (pFillInfo->pos == FILL_POS_END) {
+    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
+  }
+}
+
+void keepBlockRowInDiscBuf(SOperatorInfo* pOperator, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock, TSKEY* tsCol,
+                           int32_t rowId, uint64_t groupId, int32_t rowSize) {
+  TSKEY ts = tsCol[rowId];
+  pFillInfo->nextRowKey = ts;
+  SResultRowData tmpNextRow = {.key = ts};
+  tmpNextRow.pRowVal = taosMemoryCalloc(1, rowSize);
+  transBlockToResultRow(pBlock, rowId, ts, &tmpNextRow);
+  keepResultInDiscBuf(pOperator, groupId, &tmpNextRow, rowSize);
+  taosMemoryFreeClear(tmpNextRow.pRowVal);
+}
+
+static void doFillResults(SOperatorInfo* pOperator, SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo,
+                          SSDataBlock* pBlock, TSKEY* tsCol, int32_t rowId, SSDataBlock* pRes) {
+  uint64_t groupId = pBlock->info.id.groupId;
+  getWindowFromDiscBuf(pOperator, tsCol[rowId], groupId, pFillSup);
+  if (pFillSup->prev.key == pFillInfo->preRowKey) {
+    resetFillWindow(&pFillSup->prev);
+  }
+  setFillValueInfo(pBlock, tsCol[rowId], rowId, pFillSup, pFillInfo);
+  doStreamFillRange(pFillInfo, pFillSup, pRes);
+}
+
+static void doStreamFillImpl(SOperatorInfo* pOperator) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;
+  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
+  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
+  SSDataBlock*             pBlock = pInfo->pSrcBlock;
+  uint64_t                 groupId = pBlock->info.id.groupId;
+  SSDataBlock*             pRes = pInfo->pRes;
+  pRes->info.id.groupId = groupId;
+  if (hasRemainCalc(pFillInfo)) {
+    doStreamFillRange(pFillInfo, pFillSup, pRes);
+  }
+
+  SColumnInfoData* pTsCol = taosArrayGet(pInfo->pSrcBlock->pDataBlock, pInfo->primaryTsCol);
+  TSKEY*           tsCol = (TSKEY*)pTsCol->pData;
+
+  if (pInfo->srcRowIndex == 0) {
+    keepBlockRowInDiscBuf(pOperator, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex, groupId, pFillSup->rowSize);
+    SSDataBlock* preBlock = pInfo->pPrevSrcBlock;
+    if (preBlock->info.rows > 0) {
+      int              preRowId = preBlock->info.rows - 1;
+      SColumnInfoData* pPreTsCol = taosArrayGet(preBlock->pDataBlock, pInfo->primaryTsCol);
+      doFillResults(pOperator, pFillSup, pFillInfo, preBlock, (TSKEY*)pPreTsCol->pData, preRowId, pRes);
+    }
+    pInfo->srcRowIndex++;
+  }
+
+  while (pInfo->srcRowIndex < pBlock->info.rows) {
+    TSKEY ts = tsCol[pInfo->srcRowIndex];
+    keepBlockRowInDiscBuf(pOperator, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex, groupId, pFillSup->rowSize);
+    doFillResults(pOperator, pFillSup, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex - 1, pRes);
+    if (pInfo->pRes->info.rows == pInfo->pRes->info.capacity) {
+      blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol);
+      return;
+    }
+    pInfo->srcRowIndex++;
+  }
+  blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol);
+  blockDataCleanup(pInfo->pPrevSrcBlock);
+  copyDataBlock(pInfo->pPrevSrcBlock, pInfo->pSrcBlock);
+  blockDataCleanup(pInfo->pSrcBlock);
+}
+
+static void buildDeleteRange(SOperatorInfo* pOp, TSKEY start, TSKEY end, uint64_t groupId, SSDataBlock* delRes) {
+  SStreamState* pState = pOp->pTaskInfo->streamInfo.pState;
+
+  SSDataBlock*     pBlock = delRes;
+  SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+  SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+  SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
+  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  SColumnInfoData* pCalStartCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
+  SColumnInfoData* pCalEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
+  SColumnInfoData* pTbNameCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
+  colDataAppend(pStartCol, pBlock->info.rows, (const char*)&start, false);
+  colDataAppend(pEndCol, pBlock->info.rows, (const char*)&end, false);
+  colDataAppendNULL(pUidCol, pBlock->info.rows);
+  colDataAppend(pGroupCol, pBlock->info.rows, (const char*)&groupId, false);
+  colDataAppendNULL(pCalStartCol, pBlock->info.rows);
+  colDataAppendNULL(pCalEndCol, pBlock->info.rows);
+
+  SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
+
+  void* tbname = NULL;
+  streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, groupId, &tbname);
+  if (tbname == NULL) {
+    colDataAppendNULL(pTableCol, pBlock->info.rows);
+  } else {
+    char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
+    STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
+    colDataAppend(pTableCol, pBlock->info.rows, (const char*)parTbName, false);
+    tdbFree(tbname);
+  }
+
+  pBlock->info.rows++;
+}
+
+static void buildDeleteResult(SOperatorInfo* pOperator, TSKEY startTs, TSKEY endTs, uint64_t groupId,
+                              SSDataBlock* delRes) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
+  if (hasPrevWindow(pFillSup)) {
+    TSKEY start = getNextWindowTs(pFillSup->prev.key, &pFillSup->interval);
+    buildDeleteRange(pOperator, start, endTs, groupId, delRes);
+  } else if (hasNextWindow(pFillSup)) {
+    TSKEY end = getPrevWindowTs(pFillSup->next.key, &pFillSup->interval);
+    buildDeleteRange(pOperator, startTs, end, groupId, delRes);
+  } else {
+    buildDeleteRange(pOperator, startTs, endTs, groupId, delRes);
+  }
+}
+
+static void doDeleteFillResultImpl(SOperatorInfo* pOperator, TSKEY startTs, TSKEY endTs, uint64_t groupId) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  getWindowFromDiscBuf(pOperator, startTs, groupId, pInfo->pFillSup);
+  setDeleteFillValueInfo(startTs, endTs, pInfo->pFillSup, pInfo->pFillInfo);
+  SWinKey key = {.ts = startTs, .groupId = groupId};
+  if (!pInfo->pFillInfo->needFill) {
+    streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &key);
+    buildDeleteResult(pOperator, startTs, endTs, groupId, pInfo->pDelRes);
+  } else {
+    STimeRange tw = {
+        .skey = startTs,
+        .ekey = endTs,
+        .groupId = groupId,
+    };
+    taosArrayPush(pInfo->pFillInfo->delRanges, &tw);
+    while (key.ts <= endTs) {
+      key.ts = taosTimeAdd(key.ts, pInfo->pFillSup->interval.sliding, pInfo->pFillSup->interval.slidingUnit,
+                           pInfo->pFillSup->interval.precision);
+      tSimpleHashPut(pInfo->pFillSup->pResMap, &key, sizeof(SWinKey), NULL, 0);
+    }
+  }
+}
+
+static void doDeleteFillFinalize(SOperatorInfo* pOperator) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
+  int32_t                  size = taosArrayGetSize(pFillInfo->delRanges);
+  tSimpleHashClear(pInfo->pFillSup->pResMap);
+  for (; pFillInfo->delIndex < size; pFillInfo->delIndex++) {
+    STimeRange* range = taosArrayGet(pFillInfo->delRanges, pFillInfo->delIndex);
+    if (pInfo->pRes->info.id.groupId != 0 && pInfo->pRes->info.id.groupId != range->groupId) {
+      return;
+    }
+    getWindowFromDiscBuf(pOperator, range->skey, range->groupId, pInfo->pFillSup);
+    setDeleteFillValueInfo(range->skey, range->ekey, pInfo->pFillSup, pInfo->pFillInfo);
+    if (pInfo->pFillInfo->needFill) {
+      doStreamFillRange(pInfo->pFillInfo, pInfo->pFillSup, pInfo->pRes);
+      pInfo->pRes->info.id.groupId = range->groupId;
+    }
+    SWinKey key = {.ts = range->skey, .groupId = range->groupId};
+    streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &key);
+  }
+}
+
+static void doDeleteFillResult(SOperatorInfo* pOperator) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
+  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
+  SSDataBlock*             pBlock = pInfo->pSrcDelBlock;
+  SSDataBlock*             pRes = pInfo->pRes;
+  SSDataBlock*             pDelRes = pInfo->pDelRes;
+
+  SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
+  TSKEY*           tsStarts = (TSKEY*)pStartCol->pData;
+  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
+  uint64_t*        groupIds = (uint64_t*)pGroupCol->pData;
+  while (pInfo->srcDelRowIndex < pBlock->info.rows) {
+    TSKEY            ts = tsStarts[pInfo->srcDelRowIndex];
+    TSKEY            endTs = ts;
+    uint64_t         groupId = groupIds[pInfo->srcDelRowIndex];
+    SWinKey          key = {.ts = ts, .groupId = groupId};
+    SStreamStateCur* pCur = streamStateGetAndCheckCur(pOperator->pTaskInfo->streamInfo.pState, &key);
+    if (!pCur) {
+      pInfo->srcDelRowIndex++;
+      continue;
+    }
+
+    SWinKey nextKey = {.groupId = groupId, .ts = ts};
+    while (pInfo->srcDelRowIndex < pBlock->info.rows) {
+      void*    nextVal = NULL;
+      int32_t  nextLen = 0;
+      TSKEY    delTs = tsStarts[pInfo->srcDelRowIndex];
+      uint64_t delGroupId = groupIds[pInfo->srcDelRowIndex];
+      int32_t  code = TSDB_CODE_SUCCESS;
+      if (groupId != delGroupId) {
+        break;
+      }
+      if (delTs > nextKey.ts) {
+        break;
+      }
+      endTs = delTs;
+      SWinKey delKey = {.groupId = delGroupId, .ts = delTs};
+      if (delTs == nextKey.ts) {
+        code = streamStateCurNext(pOperator->pTaskInfo->streamInfo.pState, pCur);
+        if (code == TSDB_CODE_SUCCESS) {
+          code = streamStateGetGroupKVByCur(pCur, &nextKey, (const void**)&nextVal, &nextLen);
+        }
+        // ts will be deleted later
+        if (delTs != ts) {
+          streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &delKey);
+          streamStateFreeCur(pCur);
+          pCur = streamStateGetAndCheckCur(pOperator->pTaskInfo->streamInfo.pState, &nextKey);
+        }
+        endTs = TMAX(ts, nextKey.ts - 1);
+        if (code != TSDB_CODE_SUCCESS) {
+          break;
+        }
+      }
+      pInfo->srcDelRowIndex++;
+    }
+    streamStateFreeCur(pCur);
+    doDeleteFillResultImpl(pOperator, ts, endTs, groupId);
+  }
+  pFillInfo->current = pFillInfo->end + 1;
+}
+
+static void resetStreamFillInfo(SStreamFillOperatorInfo* pInfo) {
+  blockDataCleanup(pInfo->pPrevSrcBlock);
+  tSimpleHashClear(pInfo->pFillSup->pResMap);
+  pInfo->pFillSup->hasDelete = false;
+  taosArrayClear(pInfo->pFillInfo->delRanges);
+  pInfo->pFillInfo->delIndex = 0;
+}
+
+static void doApplyStreamScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pSrcBlock, SSDataBlock* pDstBlock) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SExprSupp*               pSup = &pOperator->exprSupp;
+
+  blockDataCleanup(pDstBlock);
+  blockDataEnsureCapacity(pDstBlock, pSrcBlock->info.rows);
+  setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false);
+  projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL);
+
+  pDstBlock->info.rows = 0;
+  pSup = &pInfo->pFillSup->notFillExprSup;
+  setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false);
+  projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL);
+  pDstBlock->info.id.groupId = pSrcBlock->info.id.groupId;
+
+  blockDataUpdateTsWindow(pDstBlock, pInfo->primaryTsCol);
+}
+
+static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
+  SStreamFillOperatorInfo* pInfo = pOperator->info;
+  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;
+
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+  blockDataCleanup(pInfo->pRes);
+  if (pOperator->status == OP_RES_TO_RETURN) {
+    if (hasRemainCalc(pInfo->pFillInfo)) {
+      doStreamFillRange(pInfo->pFillInfo, pInfo->pFillSup, pInfo->pRes);
+      if (pInfo->pRes->info.rows > 0) {
+        return pInfo->pRes;
+      }
+    }
+    doDeleteFillFinalize(pOperator);
+    if (pInfo->pRes->info.rows > 0) {
+      printDataBlock(pInfo->pRes, "stream fill");
+      return pInfo->pRes;
+    }
+    setOperatorCompleted(pOperator);
+    resetStreamFillInfo(pInfo);
+    return NULL;
+  }
+
+  SSDataBlock*   fillResult = NULL;
+  SOperatorInfo* downstream = pOperator->pDownstream[0];
+  while (1) {
+    if (pInfo->srcRowIndex >= pInfo->pSrcBlock->info.rows) {
+      // If there are delete datablocks, we receive  them first.
+      SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+      if (pBlock == NULL) {
+        pOperator->status = OP_RES_TO_RETURN;
+        SSDataBlock* preBlock = pInfo->pPrevSrcBlock;
+        if (preBlock->info.rows > 0) {
+          int              preRowId = preBlock->info.rows - 1;
+          SColumnInfoData* pPreTsCol = taosArrayGet(preBlock->pDataBlock, pInfo->primaryTsCol);
+          doFillResults(pOperator, pInfo->pFillSup, pInfo->pFillInfo, preBlock, (TSKEY*)pPreTsCol->pData, preRowId,
+                        pInfo->pRes);
+        }
+        pInfo->pFillInfo->preRowKey = INT64_MIN;
+        if (pInfo->pRes->info.rows > 0) {
+          printDataBlock(pInfo->pRes, "stream fill");
+          return pInfo->pRes;
+        }
+        break;
+      }
+      printDataBlock(pBlock, "stream fill recv");
+
+      switch (pBlock->info.type) {
+        case STREAM_RETRIEVE:
+          return pBlock;
+        case STREAM_DELETE_RESULT: {
+          pInfo->pSrcDelBlock = pBlock;
+          pInfo->srcDelRowIndex = 0;
+          blockDataCleanup(pInfo->pDelRes);
+          pInfo->pFillSup->hasDelete = true;
+          doDeleteFillResult(pOperator);
+          if (pInfo->pDelRes->info.rows > 0) {
+            printDataBlock(pInfo->pDelRes, "stream fill delete");
+            return pInfo->pDelRes;
+          }
+          continue;
+        } break;
+        case STREAM_NORMAL:
+        case STREAM_INVALID: {
+          doApplyStreamScalarCalculation(pOperator, pBlock, pInfo->pSrcBlock);
+          memcpy(pInfo->pSrcBlock->info.parTbName, pBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
+          pInfo->srcRowIndex = 0;
+        } break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+
+    doStreamFillImpl(pOperator);
+    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
+    memcpy(pInfo->pRes->info.parTbName, pInfo->pSrcBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
+    pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
+    if (pInfo->pRes->info.rows > 0) {
+      break;
+    }
+  }
+  if (pOperator->status == OP_RES_TO_RETURN) {
+    doDeleteFillFinalize(pOperator);
+  }
+
+  if (pInfo->pRes->info.rows == 0) {
+    setOperatorCompleted(pOperator);
+    resetStreamFillInfo(pInfo);
+    return NULL;
+  }
+
+  pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
+  printDataBlock(pInfo->pRes, "stream fill");
+  return pInfo->pRes;
+}
+
+static int32_t initResultBuf(SStreamFillSupporter* pFillSup) {
+  pFillSup->rowSize = sizeof(SResultCellData) * pFillSup->numOfAllCols;
+  for (int i = 0; i < pFillSup->numOfAllCols; i++) {
+    SFillColInfo* pCol = &pFillSup->pAllColInfo[i];
+    SResSchema*   pSchema = &pCol->pExpr->base.resSchema;
+    pFillSup->rowSize += pSchema->bytes;
+  }
+  pFillSup->next.key = INT64_MIN;
+  pFillSup->nextNext.key = INT64_MIN;
+  pFillSup->prev.key = INT64_MIN;
+  pFillSup->cur.key = INT64_MIN;
+  pFillSup->next.pRowVal = NULL;
+  pFillSup->nextNext.pRowVal = NULL;
+  pFillSup->prev.pRowVal = NULL;
+  pFillSup->cur.pRowVal = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static SStreamFillSupporter* initStreamFillSup(SStreamFillPhysiNode* pPhyFillNode, SInterval* pInterval,
+                                               SExprInfo* pFillExprInfo, int32_t numOfFillCols) {
+  SStreamFillSupporter* pFillSup = taosMemoryCalloc(1, sizeof(SStreamFillSupporter));
+  if (!pFillSup) {
+    return NULL;
+  }
+  pFillSup->numOfFillCols = numOfFillCols;
+  int32_t    numOfNotFillCols = 0;
+  SExprInfo* noFillExprInfo = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &numOfNotFillCols);
+  pFillSup->pAllColInfo = createFillColInfo(pFillExprInfo, pFillSup->numOfFillCols, noFillExprInfo, numOfNotFillCols,
+                                            (const SNodeListNode*)(pPhyFillNode->pValues));
+  pFillSup->type = convertFillType(pPhyFillNode->mode);
+  pFillSup->numOfAllCols = pFillSup->numOfFillCols + numOfNotFillCols;
+  pFillSup->interval = *pInterval;
+
+  int32_t code = initResultBuf(pFillSup);
+  if (code != TSDB_CODE_SUCCESS) {
+    destroyStreamFillSupporter(pFillSup);
+    return NULL;
+  }
+
+  SExprInfo* noFillExpr = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &numOfNotFillCols);
+  code = initExprSupp(&pFillSup->notFillExprSup, noFillExpr, numOfNotFillCols);
+  if (code != TSDB_CODE_SUCCESS) {
+    destroyStreamFillSupporter(pFillSup);
+    return NULL;
+  }
+
+  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  pFillSup->pResMap = tSimpleHashInit(16, hashFn);
+  pFillSup->hasDelete = false;
+  return pFillSup;
+}
+
+SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pRes) {
+  SStreamFillInfo* pFillInfo = taosMemoryCalloc(1, sizeof(SStreamFillInfo));
+  pFillInfo->start = INT64_MIN;
+  pFillInfo->current = INT64_MIN;
+  pFillInfo->end = INT64_MIN;
+  pFillInfo->preRowKey = INT64_MIN;
+  pFillInfo->needFill = false;
+  pFillInfo->pLinearInfo = taosMemoryCalloc(1, sizeof(SStreamFillLinearInfo));
+  pFillInfo->pLinearInfo->hasNext = false;
+  pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
+  pFillInfo->pLinearInfo->pDeltaVal = NULL;
+  pFillInfo->pLinearInfo->pNextDeltaVal = NULL;
+  if (pFillSup->type == TSDB_FILL_LINEAR) {
+    pFillInfo->pLinearInfo->pDeltaVal = taosArrayInit(pFillSup->numOfAllCols, sizeof(double));
+    pFillInfo->pLinearInfo->pNextDeltaVal = taosArrayInit(pFillSup->numOfAllCols, sizeof(double));
+    for (int32_t i = 0; i < pFillSup->numOfAllCols; i++) {
+      double value = 0.0;
+      taosArrayPush(pFillInfo->pLinearInfo->pDeltaVal, &value);
+      taosArrayPush(pFillInfo->pLinearInfo->pNextDeltaVal, &value);
+    }
+  }
+  pFillInfo->pLinearInfo->winIndex = 0;
+
+  pFillInfo->pResRow = NULL;
+  if (pFillSup->type == TSDB_FILL_SET_VALUE || pFillSup->type == TSDB_FILL_NULL) {
+    pFillInfo->pResRow = taosMemoryCalloc(1, sizeof(SResultRowData));
+    pFillInfo->pResRow->key = INT64_MIN;
+    pFillInfo->pResRow->pRowVal = taosMemoryCalloc(1, pFillSup->rowSize);
+    for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
+      SColumnInfoData* pColData = taosArrayGet(pRes->pDataBlock, i);
+      SResultCellData* pCell = getResultCell(pFillInfo->pResRow, i);
+      pCell->bytes = pColData->info.bytes;
+      pCell->type = pColData->info.type;
+    }
+  }
+
+  pFillInfo->type = pFillSup->type;
+  pFillInfo->delRanges = taosArrayInit(16, sizeof(STimeRange));
+  pFillInfo->delIndex = 0;
+  return pFillInfo;
+}
+
+SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode,
+                                            SExecTaskInfo* pTaskInfo) {
+  SStreamFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamFillOperatorInfo));
+  SOperatorInfo*           pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
+  if (pInfo == NULL || pOperator == NULL) {
+    goto _error;
+  }
+
+  SInterval* pInterval = &((SStreamIntervalOperatorInfo*)downstream->info)->interval;
+  int32_t    numOfFillCols = 0;
+  SExprInfo* pFillExprInfo = createExprInfo(pPhyFillNode->pFillExprs, NULL, &numOfFillCols);
+  pInfo->pFillSup = initStreamFillSup(pPhyFillNode, pInterval, pFillExprInfo, numOfFillCols);
+  if (!pInfo->pFillSup) {
+    goto _error;
+  }
+
+  initResultSizeInfo(&pOperator->resultInfo, 4096);
+  pInfo->pRes = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
+  pInfo->pSrcBlock = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
+  pInfo->pPrevSrcBlock = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  blockDataEnsureCapacity(pInfo->pSrcBlock, pOperator->resultInfo.capacity);
+  blockDataEnsureCapacity(pInfo->pPrevSrcBlock, pOperator->resultInfo.capacity);
+
+  pInfo->pFillInfo = initStreamFillInfo(pInfo->pFillSup, pInfo->pRes);
+  if (!pInfo->pFillInfo) {
+    goto _error;
+  }
+
+  if (pInfo->pFillInfo->type == TSDB_FILL_SET_VALUE) {
+    for (int32_t i = 0; i < pInfo->pFillSup->numOfAllCols; ++i) {
+      SFillColInfo*    pFillCol = pInfo->pFillSup->pAllColInfo + i;
+      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
+      SResultCellData* pCell = getResultCell(pInfo->pFillInfo->pResRow, slotId);
+      SVariant*        pVar = &(pFillCol->fillVal);
+      if (pCell->type == TSDB_DATA_TYPE_FLOAT) {
+        float v = 0;
+        GET_TYPED_DATA(v, float, pVar->nType, &pVar->i);
+        SET_TYPED_DATA(pCell->pData, pCell->type, v);
+      } else if (pCell->type == TSDB_DATA_TYPE_DOUBLE) {
+        double v = 0;
+        GET_TYPED_DATA(v, double, pVar->nType, &pVar->i);
+        SET_TYPED_DATA(pCell->pData, pCell->type, v);
+      } else if (IS_SIGNED_NUMERIC_TYPE(pCell->type)) {
+        int64_t v = 0;
+        GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
+        SET_TYPED_DATA(pCell->pData, pCell->type, v);
+      } else {
+        pCell->isNull = true;
+      }
+    }
+  } else if (pInfo->pFillInfo->type == TSDB_FILL_NULL) {
+    for (int32_t i = 0; i < pInfo->pFillSup->numOfAllCols; ++i) {
+      SFillColInfo*    pFillCol = pInfo->pFillSup->pAllColInfo + i;
+      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
+      SResultCellData* pCell = getResultCell(pInfo->pFillInfo->pResRow, slotId);
+      pCell->isNull = true;
+    }
+  }
+
+  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
+  blockDataEnsureCapacity(pInfo->pDelRes, pOperator->resultInfo.capacity);
+
+  pInfo->primaryTsCol = ((STargetNode*)pPhyFillNode->pWStartTs)->slotId;
+  pInfo->primarySrcSlotId = ((SColumnNode*)((STargetNode*)pPhyFillNode->pWStartTs)->pExpr)->slotId;
+
+  int32_t numOfOutputCols = 0;
+  int32_t code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc,
+                                     &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  code = initExprSupp(&pOperator->exprSupp, pFillExprInfo, numOfFillCols);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->srcRowIndex = 0;
+  setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo,
+                  pTaskInfo);
+  pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, NULL);
+
+  code = appendDownstream(pOperator, &downstream, 1);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+  return pOperator;
+
+  _error:
+  destroyStreamFillOperatorInfo(pInfo);
+  taosMemoryFreeClear(pOperator);
+  pTaskInfo->code = code;
+  return NULL;
+}
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index a4e609ae81..b6353061fb 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -1052,6 +1052,9 @@ static uint64_t getGroupIdByData(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts,
 }
 
 static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t* pRowIndex) {
+  if (pBlock->info.rows == 0) {
+    return false;
+  }
   if ((*pRowIndex) == pBlock->info.rows) {
     return false;
   }
@@ -1184,10 +1187,10 @@ static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32
 }
 
 static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock) {
+  blockDataCleanup(pDestBlock);
   if (pSrcBlock->info.rows == 0) {
     return TSDB_CODE_SUCCESS;
   }
-  blockDataCleanup(pDestBlock);
   int32_t code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
@@ -1336,30 +1339,6 @@ static int32_t generateScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock,
   return code;
 }
 
-static void calBlockTag(SExprSupp* pTagCalSup, SSDataBlock* pBlock, SSDataBlock* pResBlock) {
-  if (pTagCalSup == NULL || pTagCalSup->numOfExprs == 0) return;
-  if (pBlock == NULL || pBlock->info.rows == 0) return;
-
-  SSDataBlock* pSrcBlock = blockCopyOneRow(pBlock, 0);
-  ASSERT(pSrcBlock->info.rows == 1);
-
-  blockDataEnsureCapacity(pResBlock, 1);
-
-  projectApplyFunctions(pTagCalSup->pExprInfo, pResBlock, pSrcBlock, pTagCalSup->pCtx, 1, NULL);
-  ASSERT(pResBlock->info.rows == 1);
-
-  // build tagArray
-  /*SArray* tagArray = taosArrayInit(0, sizeof(void*));*/
-  /*STagVal tagVal = {*/
-  /*.cid = 0,*/
-  /*.type = 0,*/
-  /*};*/
-  // build STag
-  // set STag
-
-  blockDataDestroy(pSrcBlock);
-}
-
 void calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock) {
   SExprSupp*    pTbNameCalSup = &pInfo->tbnameCalSup;
   SStreamState* pState = pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState;
@@ -1837,6 +1816,12 @@ FETCH_NEXT_BLOCK:
         }
         setBlockGroupIdByUid(pInfo, pDelBlock);
         printDataBlock(pDelBlock, "stream scan delete recv filtered");
+        if (pDelBlock->info.rows == 0) {
+          if (pInfo->tqReader) {
+            blockDataDestroy(pDelBlock);
+          }
+          goto FETCH_NEXT_BLOCK;
+        }
         if (!isIntervalWindow(pInfo) && !isSessionWindow(pInfo) && !isStateWindow(pInfo)) {
           generateDeleteResultBlock(pInfo, pDelBlock, pInfo->pDeleteDataRes);
           pInfo->pDeleteDataRes->info.type = STREAM_DELETE_RESULT;
diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c
index 2300fc3359..a66a5e7089 100644
--- a/source/libs/executor/src/tfill.c
+++ b/source/libs/executor/src/tfill.c
@@ -35,22 +35,7 @@
 #define DO_INTERPOLATION(_v1, _v2, _k1, _k2, _k) \
   ((_v1) + ((_v2) - (_v1)) * (((double)(_k)) - ((double)(_k1))) / (((double)(_k2)) - ((double)(_k1))))
 
-#define GET_DEST_SLOT_ID(_p) ((_p)->pExpr->base.resSchema.slotId)
-
-#define FILL_POS_INVALID 0
-#define FILL_POS_START   1
-#define FILL_POS_MID     2
-#define FILL_POS_END     3
-
-typedef struct STimeRange {
-  TSKEY    skey;
-  TSKEY    ekey;
-  uint64_t groupId;
-} STimeRange;
-
 static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
-static bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
-                                     int32_t rowIndex);
 
 static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowIndex) {
   for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
@@ -91,8 +76,8 @@ static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32
 }
 
 // fill windows pseudo column, _wstart, _wend, _wduration and return true, otherwise return false
-static bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
-                                     int32_t rowIndex) {
+bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
+                              int32_t rowIndex) {
   if (!pCol->notFillCol) {
     return false;
   }
@@ -663,1097 +648,3 @@ SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfFillExpr, SExprIn
 
   return pFillCol;
 }
-
-TSKEY getNextWindowTs(TSKEY ts, SInterval* pInterval) {
-  STimeWindow win = {.skey = ts, .ekey = ts};
-  getNextIntervalWindow(pInterval, &win, TSDB_ORDER_ASC);
-  return win.skey;
-}
-
-TSKEY getPrevWindowTs(TSKEY ts, SInterval* pInterval) {
-  STimeWindow win = {.skey = ts, .ekey = ts};
-  getNextIntervalWindow(pInterval, &win, TSDB_ORDER_DESC);
-  return win.skey;
-}
-
-void setRowCell(SColumnInfoData* pCol, int32_t rowId, const SResultCellData* pCell) {
-  colDataAppend(pCol, rowId, pCell->pData, pCell->isNull);
-}
-
-SResultCellData* getResultCell(SResultRowData* pRaw, int32_t index) {
-  if (!pRaw || !pRaw->pRowVal) {
-    return NULL;
-  }
-  char*            pData = (char*)pRaw->pRowVal;
-  SResultCellData* pCell = pRaw->pRowVal;
-  for (int32_t i = 0; i < index; i++) {
-    pData += (pCell->bytes + sizeof(SResultCellData));
-    pCell = (SResultCellData*)pData;
-  }
-  return pCell;
-}
-
-void* destroyFillColumnInfo(SFillColInfo* pFillCol, int32_t start, int32_t end) {
-  for (int32_t i = start; i < end; i++) {
-    destroyExprInfo(pFillCol[i].pExpr, 1);
-    taosVariantDestroy(&pFillCol[i].fillVal);
-  }
-  taosMemoryFreeClear(pFillCol[start].pExpr);
-  taosMemoryFree(pFillCol);
-  return NULL;
-}
-
-void* destroyStreamFillSupporter(SStreamFillSupporter* pFillSup) {
-  pFillSup->pAllColInfo = destroyFillColumnInfo(pFillSup->pAllColInfo, pFillSup->numOfFillCols, pFillSup->numOfAllCols);
-  tSimpleHashCleanup(pFillSup->pResMap);
-  pFillSup->pResMap = NULL;
-  releaseOutputBuf(NULL, NULL, (SResultRow*)pFillSup->cur.pRowVal);
-  pFillSup->cur.pRowVal = NULL;
-  cleanupExprSupp(&pFillSup->notFillExprSup);
-
-  taosMemoryFree(pFillSup);
-  return NULL;
-}
-
-void* destroyStreamFillLinearInfo(SStreamFillLinearInfo* pFillLinear) {
-  taosArrayDestroy(pFillLinear->pDeltaVal);
-  taosArrayDestroy(pFillLinear->pNextDeltaVal);
-  taosMemoryFree(pFillLinear);
-  return NULL;
-}
-void* destroyStreamFillInfo(SStreamFillInfo* pFillInfo) {
-  if (pFillInfo->type == TSDB_FILL_SET_VALUE || pFillInfo->type == TSDB_FILL_NULL) {
-    taosMemoryFreeClear(pFillInfo->pResRow->pRowVal);
-    taosMemoryFreeClear(pFillInfo->pResRow);
-  }
-  pFillInfo->pLinearInfo = destroyStreamFillLinearInfo(pFillInfo->pLinearInfo);
-  taosArrayDestroy(pFillInfo->delRanges);
-  taosMemoryFree(pFillInfo);
-  return NULL;
-}
-
-void destroyStreamFillOperatorInfo(void* param) {
-  SStreamFillOperatorInfo* pInfo = (SStreamFillOperatorInfo*)param;
-  pInfo->pFillInfo = destroyStreamFillInfo(pInfo->pFillInfo);
-  pInfo->pFillSup = destroyStreamFillSupporter(pInfo->pFillSup);
-  pInfo->pRes = blockDataDestroy(pInfo->pRes);
-  pInfo->pSrcBlock = blockDataDestroy(pInfo->pSrcBlock);
-  pInfo->pPrevSrcBlock = blockDataDestroy(pInfo->pPrevSrcBlock);
-  pInfo->pDelRes = blockDataDestroy(pInfo->pDelRes);
-  pInfo->matchInfo.pList = taosArrayDestroy(pInfo->matchInfo.pList);
-  taosMemoryFree(pInfo);
-}
-
-static void resetFillWindow(SResultRowData* pRowData) {
-  pRowData->key = INT64_MIN;
-  pRowData->pRowVal = NULL;
-}
-
-void resetPrevAndNextWindow(SStreamFillSupporter* pFillSup, SStreamState* pState) {
-  resetFillWindow(&pFillSup->prev);
-  releaseOutputBuf(NULL, NULL, (SResultRow*)pFillSup->cur.pRowVal);
-  resetFillWindow(&pFillSup->cur);
-  resetFillWindow(&pFillSup->next);
-  resetFillWindow(&pFillSup->nextNext);
-}
-
-void getCurWindowFromDiscBuf(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId, SStreamFillSupporter* pFillSup) {
-  SStreamState* pState = pOperator->pTaskInfo->streamInfo.pState;
-  resetPrevAndNextWindow(pFillSup, pState);
-
-  SWinKey key = {.ts = ts, .groupId = groupId};
-  int32_t curVLen = 0;
-  int32_t code = streamStateFillGet(pState, &key, (void**)&pFillSup->cur.pRowVal, &curVLen);
-  ASSERT(code == TSDB_CODE_SUCCESS);
-  pFillSup->cur.key = key.ts;
-}
-
-void getWindowFromDiscBuf(SOperatorInfo* pOperator, TSKEY ts, uint64_t groupId, SStreamFillSupporter* pFillSup) {
-  SStreamState* pState = pOperator->pTaskInfo->streamInfo.pState;
-  resetPrevAndNextWindow(pFillSup, pState);
-
-  SWinKey key = {.ts = ts, .groupId = groupId};
-  void*   curVal = NULL;
-  int32_t curVLen = 0;
-  int32_t code = streamStateFillGet(pState, &key, (void**)&curVal, &curVLen);
-  ASSERT(code == TSDB_CODE_SUCCESS);
-  pFillSup->cur.key = key.ts;
-  pFillSup->cur.pRowVal = curVal;
-
-  SStreamStateCur* pCur = streamStateFillSeekKeyPrev(pState, &key);
-  SWinKey          preKey = {.groupId = groupId};
-  void*            preVal = NULL;
-  int32_t          preVLen = 0;
-  code = streamStateGetGroupKVByCur(pCur, &preKey, (const void**)&preVal, &preVLen);
-
-  if (code == TSDB_CODE_SUCCESS) {
-    pFillSup->prev.key = preKey.ts;
-    pFillSup->prev.pRowVal = preVal;
-
-    code = streamStateCurNext(pState, pCur);
-    ASSERT(code == TSDB_CODE_SUCCESS);
-
-    code = streamStateCurNext(pState, pCur);
-    if (code != TSDB_CODE_SUCCESS) {
-      streamStateFreeCur(pCur);
-      pCur = NULL;
-    }
-  } else {
-    streamStateFreeCur(pCur);
-    pCur = streamStateFillSeekKeyNext(pState, &key);
-  }
-
-  SWinKey nextKey = {.groupId = groupId};
-  void*   nextVal = NULL;
-  int32_t nextVLen = 0;
-  code = streamStateGetGroupKVByCur(pCur, &nextKey, (const void**)&nextVal, &nextVLen);
-  if (code == TSDB_CODE_SUCCESS) {
-    pFillSup->next.key = nextKey.ts;
-    pFillSup->next.pRowVal = nextVal;
-    if (pFillSup->type == TSDB_FILL_PREV || pFillSup->type == TSDB_FILL_NEXT) {
-      code = streamStateCurNext(pState, pCur);
-      if (code == TSDB_CODE_SUCCESS) {
-        SWinKey nextNextKey = {.groupId = groupId};
-        void*   nextNextVal = NULL;
-        int32_t nextNextVLen = 0;
-        code = streamStateGetGroupKVByCur(pCur, &nextNextKey, (const void**)&nextNextVal, &nextNextVLen);
-        if (code == TSDB_CODE_SUCCESS) {
-          pFillSup->nextNext.key = nextNextKey.ts;
-          pFillSup->nextNext.pRowVal = nextNextVal;
-        }
-      }
-    }
-  }
-  streamStateFreeCur(pCur);
-}
-
-static bool hasPrevWindow(SStreamFillSupporter* pFillSup) { return pFillSup->prev.key != INT64_MIN; }
-static bool hasNextWindow(SStreamFillSupporter* pFillSup) { return pFillSup->next.key != INT64_MIN; }
-static bool hasNextNextWindow(SStreamFillSupporter* pFillSup) {
-  return pFillSup->nextNext.key != INT64_MIN;
-  return false;
-}
-
-static void transBlockToResultRow(const SSDataBlock* pBlock, int32_t rowId, TSKEY ts, SResultRowData* pRowVal) {
-  int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
-    SResultCellData* pCell = getResultCell(pRowVal, i);
-    if (!colDataIsNull_s(pColData, rowId)) {
-      pCell->isNull = false;
-      pCell->type = pColData->info.type;
-      pCell->bytes = pColData->info.bytes;
-      char* val = colDataGetData(pColData, rowId);
-      if (IS_VAR_DATA_TYPE(pCell->type)) {
-        memcpy(pCell->pData, val, varDataTLen(val));
-      } else {
-        memcpy(pCell->pData, val, pCell->bytes);
-      }
-    } else {
-      pCell->isNull = true;
-    }
-  }
-  pRowVal->key = ts;
-}
-
-static void calcDeltaData(SSDataBlock* pBlock, int32_t rowId, SResultRowData* pRowVal, SArray* pDelta,
-                          SFillColInfo* pFillCol, int32_t numOfCol, int32_t winCount, int32_t order) {
-  for (int32_t i = 0; i < numOfCol; i++) {
-    if (!pFillCol[i].notFillCol) {
-      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol + i);
-      SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
-      char*            var = colDataGetData(pCol, rowId);
-      double           start = 0;
-      GET_TYPED_DATA(start, double, pCol->info.type, var);
-      SResultCellData* pCell = getResultCell(pRowVal, slotId);
-      double           end = 0;
-      GET_TYPED_DATA(end, double, pCell->type, pCell->pData);
-      double delta = 0;
-      if (order == TSDB_ORDER_ASC) {
-        delta = (end - start) / winCount;
-      } else {
-        delta = (start - end) / winCount;
-      }
-      taosArraySet(pDelta, slotId, &delta);
-    }
-  }
-}
-
-static void calcRowDeltaData(SResultRowData* pStartRow, SResultRowData* pEndRow, SArray* pDelta, SFillColInfo* pFillCol,
-                             int32_t numOfCol, int32_t winCount) {
-  for (int32_t i = 0; i < numOfCol; i++) {
-    if (!pFillCol[i].notFillCol) {
-      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol + i);
-      SResultCellData* pSCell = getResultCell(pStartRow, slotId);
-      double           start = 0.0;
-      GET_TYPED_DATA(start, double, pSCell->type, pSCell->pData);
-      SResultCellData* pECell = getResultCell(pEndRow, slotId);
-      double           end = 0.0;
-      GET_TYPED_DATA(end, double, pECell->type, pECell->pData);
-      double delta = (end - start) / winCount;
-      taosArraySet(pDelta, slotId, &delta);
-    }
-  }
-}
-
-static void setFillInfoStart(TSKEY ts, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
-  ts = taosTimeAdd(ts, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
-  pFillInfo->start = ts;
-}
-
-static void setFillInfoEnd(TSKEY ts, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
-  ts = taosTimeAdd(ts, pInterval->sliding * -1, pInterval->slidingUnit, pInterval->precision);
-  pFillInfo->end = ts;
-}
-
-static void setFillKeyInfo(TSKEY start, TSKEY end, SInterval* pInterval, SStreamFillInfo* pFillInfo) {
-  setFillInfoStart(start, pInterval, pFillInfo);
-  pFillInfo->current = pFillInfo->start;
-  setFillInfoEnd(end, pInterval, pFillInfo);
-}
-
-void setDeleteFillValueInfo(TSKEY start, TSKEY end, SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo) {
-  if (!hasPrevWindow(pFillSup) || !hasNextWindow(pFillSup)) {
-    pFillInfo->needFill = false;
-    return;
-  }
-
-  TSKEY realStart = taosTimeAdd(pFillSup->prev.key, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
-                                pFillSup->interval.precision);
-
-  pFillInfo->needFill = true;
-  pFillInfo->start = realStart;
-  pFillInfo->current = pFillInfo->start;
-  pFillInfo->end = end;
-  pFillInfo->pos = FILL_POS_INVALID;
-  switch (pFillInfo->type) {
-    case TSDB_FILL_NULL:
-    case TSDB_FILL_SET_VALUE:
-      break;
-    case TSDB_FILL_PREV:
-      pFillInfo->pResRow = &pFillSup->prev;
-      break;
-    case TSDB_FILL_NEXT:
-      pFillInfo->pResRow = &pFillSup->next;
-      break;
-    case TSDB_FILL_LINEAR: {
-      setFillKeyInfo(pFillSup->prev.key, pFillSup->next.key, &pFillSup->interval, pFillInfo);
-      pFillInfo->pLinearInfo->hasNext = false;
-      pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
-      int32_t numOfWins = taosTimeCountInterval(pFillSup->prev.key, pFillSup->next.key, pFillSup->interval.sliding,
-                                                pFillSup->interval.slidingUnit, pFillSup->interval.precision);
-      calcRowDeltaData(&pFillSup->prev, &pFillSup->next, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
-                       pFillSup->numOfAllCols, numOfWins);
-      pFillInfo->pResRow = &pFillSup->prev;
-      pFillInfo->pLinearInfo->winIndex = 0;
-    } break;
-    default:
-      ASSERT(0);
-      break;
-  }
-}
-
-void copyNotFillExpData(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo) {
-  for (int32_t i = pFillSup->numOfFillCols; i < pFillSup->numOfAllCols; ++i) {
-    SFillColInfo*    pFillCol = pFillSup->pAllColInfo + i;
-    int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
-    SResultCellData* pCell = getResultCell(pFillInfo->pResRow, slotId);
-    SResultCellData* pCurCell = getResultCell(&pFillSup->cur, slotId);
-    pCell->isNull = pCurCell->isNull;
-    if (!pCurCell->isNull) {
-      memcpy(pCell->pData, pCurCell->pData, pCell->bytes);
-    }
-  }
-}
-
-void setFillValueInfo(SSDataBlock* pBlock, TSKEY ts, int32_t rowId, SStreamFillSupporter* pFillSup,
-                      SStreamFillInfo* pFillInfo) {
-  pFillInfo->preRowKey = pFillSup->cur.key;
-  if (!hasPrevWindow(pFillSup) && !hasNextWindow(pFillSup)) {
-    pFillInfo->needFill = false;
-    pFillInfo->pos = FILL_POS_START;
-    return;
-  }
-  TSKEY prevWKey = INT64_MIN;
-  TSKEY nextWKey = INT64_MIN;
-  if (hasPrevWindow(pFillSup)) {
-    prevWKey = pFillSup->prev.key;
-  }
-  if (hasNextWindow(pFillSup)) {
-    nextWKey = pFillSup->next.key;
-  }
-
-  pFillInfo->needFill = true;
-  pFillInfo->pos = FILL_POS_INVALID;
-  switch (pFillInfo->type) {
-    case TSDB_FILL_NULL:
-    case TSDB_FILL_SET_VALUE: {
-      if (pFillSup->prev.key == pFillInfo->preRowKey) {
-        resetFillWindow(&pFillSup->prev);
-      }
-      if (hasPrevWindow(pFillSup) && hasNextWindow(pFillSup)) {
-        if (pFillSup->next.key == pFillInfo->nextRowKey) {
-          pFillInfo->preRowKey = INT64_MIN;
-          setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-          pFillInfo->pos = FILL_POS_END;
-        } else {
-          pFillInfo->needFill = false;
-          pFillInfo->pos = FILL_POS_START;
-        }
-      } else if (hasPrevWindow(pFillSup)) {
-        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_END;
-      } else {
-        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_START;
-      }
-      copyNotFillExpData(pFillSup, pFillInfo);
-    } break;
-    case TSDB_FILL_PREV: {
-      if (hasNextWindow(pFillSup) && ((pFillSup->next.key != pFillInfo->nextRowKey) ||
-                                      (pFillSup->next.key == pFillInfo->nextRowKey && hasNextNextWindow(pFillSup)) ||
-                                      (pFillSup->next.key == pFillInfo->nextRowKey && !hasPrevWindow(pFillSup)))) {
-        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_START;
-        pFillSup->prev.key = pFillSup->cur.key;
-        pFillSup->prev.pRowVal = pFillSup->cur.pRowVal;
-      } else if (hasPrevWindow(pFillSup)) {
-        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_END;
-        pFillInfo->preRowKey = INT64_MIN;
-      }
-      pFillInfo->pResRow = &pFillSup->prev;
-    } break;
-    case TSDB_FILL_NEXT: {
-      if (hasPrevWindow(pFillSup)) {
-        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_END;
-        pFillSup->next.key = pFillSup->cur.key;
-        pFillSup->next.pRowVal = pFillSup->cur.pRowVal;
-        pFillInfo->preRowKey = INT64_MIN;
-      } else {
-        ASSERT(hasNextWindow(pFillSup));
-        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_START;
-      }
-      pFillInfo->pResRow = &pFillSup->next;
-    } break;
-    case TSDB_FILL_LINEAR: {
-      pFillInfo->pLinearInfo->winIndex = 0;
-      if (hasPrevWindow(pFillSup) && hasNextWindow(pFillSup)) {
-        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_MID;
-        pFillInfo->pLinearInfo->nextEnd = nextWKey;
-        int32_t numOfWins = taosTimeCountInterval(prevWKey, ts, pFillSup->interval.sliding,
-                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
-        calcRowDeltaData(&pFillSup->prev, &pFillSup->cur, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
-                         pFillSup->numOfAllCols, numOfWins);
-        pFillInfo->pResRow = &pFillSup->prev;
-
-        numOfWins = taosTimeCountInterval(ts, nextWKey, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
-                                          pFillSup->interval.precision);
-        calcRowDeltaData(&pFillSup->cur, &pFillSup->next, pFillInfo->pLinearInfo->pNextDeltaVal, pFillSup->pAllColInfo,
-                         pFillSup->numOfAllCols, numOfWins);
-        pFillInfo->pLinearInfo->hasNext = true;
-      } else if (hasPrevWindow(pFillSup)) {
-        setFillKeyInfo(prevWKey, ts, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_END;
-        pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
-        int32_t numOfWins = taosTimeCountInterval(prevWKey, ts, pFillSup->interval.sliding,
-                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
-        calcRowDeltaData(&pFillSup->prev, &pFillSup->cur, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
-                         pFillSup->numOfAllCols, numOfWins);
-        pFillInfo->pResRow = &pFillSup->prev;
-        pFillInfo->pLinearInfo->hasNext = false;
-      } else {
-        ASSERT(hasNextWindow(pFillSup));
-        setFillKeyInfo(ts, nextWKey, &pFillSup->interval, pFillInfo);
-        pFillInfo->pos = FILL_POS_START;
-        pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
-        int32_t numOfWins = taosTimeCountInterval(ts, nextWKey, pFillSup->interval.sliding,
-                                                  pFillSup->interval.slidingUnit, pFillSup->interval.precision);
-        calcRowDeltaData(&pFillSup->cur, &pFillSup->next, pFillInfo->pLinearInfo->pDeltaVal, pFillSup->pAllColInfo,
-                         pFillSup->numOfAllCols, numOfWins);
-        pFillInfo->pResRow = &pFillSup->cur;
-        pFillInfo->pLinearInfo->hasNext = false;
-      }
-    } break;
-    default:
-      ASSERT(0);
-      break;
-  }
-  ASSERT(pFillInfo->pos != FILL_POS_INVALID);
-}
-
-static bool checkResult(SStreamFillSupporter* pFillSup, TSKEY ts, uint64_t groupId) {
-  SWinKey key = {.groupId = groupId, .ts = ts};
-  if (tSimpleHashGet(pFillSup->pResMap, &key, sizeof(SWinKey)) != NULL) {
-    return false;
-  }
-  tSimpleHashPut(pFillSup->pResMap, &key, sizeof(SWinKey), NULL, 0);
-  return true;
-}
-
-static void buildFillResult(SResultRowData* pResRow, SStreamFillSupporter* pFillSup, TSKEY ts, SSDataBlock* pBlock) {
-  uint64_t groupId = pBlock->info.id.groupId;
-  if (pFillSup->hasDelete && !checkResult(pFillSup, ts, groupId)) {
-    return;
-  }
-  for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
-    SFillColInfo*    pFillCol = pFillSup->pAllColInfo + i;
-    int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
-    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, slotId);
-    SFillInfo        tmpInfo = {
-               .currentKey = ts,
-               .order = TSDB_ORDER_ASC,
-               .interval = pFillSup->interval,
-    };
-    bool filled = fillIfWindowPseudoColumn(&tmpInfo, pFillCol, pColData, pBlock->info.rows);
-    if (!filled) {
-      SResultCellData* pCell = getResultCell(pResRow, slotId);
-      setRowCell(pColData, pBlock->info.rows, pCell);
-    }
-  }
-  pBlock->info.rows++;
-}
-
-static bool hasRemainCalc(SStreamFillInfo* pFillInfo) {
-  if (pFillInfo->current != INT64_MIN && pFillInfo->current <= pFillInfo->end) {
-    return true;
-  }
-  return false;
-}
-
-static void doStreamFillNormal(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock) {
-  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
-    buildFillResult(pFillInfo->pResRow, pFillSup, pFillInfo->current, pBlock);
-    pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
-                                     pFillSup->interval.precision);
-  }
-}
-
-static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock) {
-  while (hasRemainCalc(pFillInfo) && pBlock->info.rows < pBlock->info.capacity) {
-    uint64_t groupId = pBlock->info.id.groupId;
-    SWinKey  key = {.groupId = groupId, .ts = pFillInfo->current};
-    if (pFillSup->hasDelete && !checkResult(pFillSup, pFillInfo->current, groupId)) {
-      pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
-                                       pFillSup->interval.precision);
-      pFillInfo->pLinearInfo->winIndex++;
-      continue;
-    }
-    pFillInfo->pLinearInfo->winIndex++;
-    for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
-      SFillColInfo* pFillCol = pFillSup->pAllColInfo + i;
-      SFillInfo     tmp = {
-              .currentKey = pFillInfo->current,
-              .order = TSDB_ORDER_ASC,
-              .interval = pFillSup->interval,
-      };
-
-      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
-      SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, slotId);
-      int16_t          type = pColData->info.type;
-      SResultCellData* pCell = getResultCell(pFillInfo->pResRow, slotId);
-      int32_t          index = pBlock->info.rows;
-      if (pFillCol->notFillCol) {
-        bool filled = fillIfWindowPseudoColumn(&tmp, pFillCol, pColData, index);
-        if (!filled) {
-          setRowCell(pColData, index, pCell);
-        }
-      } else {
-        if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pCell->isNull) {
-          colDataAppendNULL(pColData, index);
-          continue;
-        }
-        double* pDelta = taosArrayGet(pFillInfo->pLinearInfo->pDeltaVal, slotId);
-        double  vCell = 0;
-        GET_TYPED_DATA(vCell, double, pCell->type, pCell->pData);
-        vCell += (*pDelta) * pFillInfo->pLinearInfo->winIndex;
-        int64_t result = 0;
-        SET_TYPED_DATA(&result, pCell->type, vCell);
-        colDataAppend(pColData, index, (const char*)&result, false);
-      }
-    }
-    pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit,
-                                     pFillSup->interval.precision);
-    pBlock->info.rows++;
-  }
-}
-
-static void keepResultInDiscBuf(SOperatorInfo* pOperator, uint64_t groupId, SResultRowData* pRow, int32_t len) {
-  SWinKey key = {.groupId = groupId, .ts = pRow->key};
-  int32_t code = streamStateFillPut(pOperator->pTaskInfo->streamInfo.pState, &key, pRow->pRowVal, len);
-  ASSERT(code == TSDB_CODE_SUCCESS);
-}
-
-static void doStreamFillRange(SStreamFillInfo* pFillInfo, SStreamFillSupporter* pFillSup, SSDataBlock* pRes) {
-  if (pFillInfo->needFill == false) {
-    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
-    return;
-  }
-
-  if (pFillInfo->pos == FILL_POS_START) {
-    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
-  }
-  if (pFillInfo->type != TSDB_FILL_LINEAR) {
-    doStreamFillNormal(pFillSup, pFillInfo, pRes);
-  } else {
-    doStreamFillLinear(pFillSup, pFillInfo, pRes);
-
-    if (pFillInfo->pos == FILL_POS_MID) {
-      buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
-    }
-
-    if (pFillInfo->current > pFillInfo->end && pFillInfo->pLinearInfo->hasNext) {
-      pFillInfo->pLinearInfo->hasNext = false;
-      pFillInfo->pLinearInfo->winIndex = 0;
-      taosArrayClear(pFillInfo->pLinearInfo->pDeltaVal);
-      taosArrayAddAll(pFillInfo->pLinearInfo->pDeltaVal, pFillInfo->pLinearInfo->pNextDeltaVal);
-      pFillInfo->pResRow = &pFillSup->cur;
-      setFillKeyInfo(pFillSup->cur.key, pFillInfo->pLinearInfo->nextEnd, &pFillSup->interval, pFillInfo);
-      doStreamFillLinear(pFillSup, pFillInfo, pRes);
-    }
-  }
-  if (pFillInfo->pos == FILL_POS_END) {
-    buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes);
-  }
-}
-
-void keepBlockRowInDiscBuf(SOperatorInfo* pOperator, SStreamFillInfo* pFillInfo, SSDataBlock* pBlock, TSKEY* tsCol,
-                           int32_t rowId, uint64_t groupId, int32_t rowSize) {
-  TSKEY ts = tsCol[rowId];
-  pFillInfo->nextRowKey = ts;
-  SResultRowData tmpNextRow = {.key = ts};
-  tmpNextRow.pRowVal = taosMemoryCalloc(1, rowSize);
-  transBlockToResultRow(pBlock, rowId, ts, &tmpNextRow);
-  keepResultInDiscBuf(pOperator, groupId, &tmpNextRow, rowSize);
-  taosMemoryFreeClear(tmpNextRow.pRowVal);
-}
-
-static void doFillResults(SOperatorInfo* pOperator, SStreamFillSupporter* pFillSup, SStreamFillInfo* pFillInfo,
-                          SSDataBlock* pBlock, TSKEY* tsCol, int32_t rowId, SSDataBlock* pRes) {
-  uint64_t groupId = pBlock->info.id.groupId;
-  getWindowFromDiscBuf(pOperator, tsCol[rowId], groupId, pFillSup);
-  if (pFillSup->prev.key == pFillInfo->preRowKey) {
-    resetFillWindow(&pFillSup->prev);
-  }
-  setFillValueInfo(pBlock, tsCol[rowId], rowId, pFillSup, pFillInfo);
-  doStreamFillRange(pFillInfo, pFillSup, pRes);
-}
-
-static void doStreamFillImpl(SOperatorInfo* pOperator) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;
-  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
-  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
-  SSDataBlock*             pBlock = pInfo->pSrcBlock;
-  uint64_t                 groupId = pBlock->info.id.groupId;
-  SSDataBlock*             pRes = pInfo->pRes;
-  pRes->info.id.groupId = groupId;
-  if (hasRemainCalc(pFillInfo)) {
-    doStreamFillRange(pFillInfo, pFillSup, pRes);
-  }
-
-  SColumnInfoData* pTsCol = taosArrayGet(pInfo->pSrcBlock->pDataBlock, pInfo->primaryTsCol);
-  TSKEY*           tsCol = (TSKEY*)pTsCol->pData;
-
-  if (pInfo->srcRowIndex == 0) {
-    keepBlockRowInDiscBuf(pOperator, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex, groupId, pFillSup->rowSize);
-    SSDataBlock* preBlock = pInfo->pPrevSrcBlock;
-    if (preBlock->info.rows > 0) {
-      int              preRowId = preBlock->info.rows - 1;
-      SColumnInfoData* pPreTsCol = taosArrayGet(preBlock->pDataBlock, pInfo->primaryTsCol);
-      doFillResults(pOperator, pFillSup, pFillInfo, preBlock, (TSKEY*)pPreTsCol->pData, preRowId, pRes);
-    }
-    pInfo->srcRowIndex++;
-  }
-
-  while (pInfo->srcRowIndex < pBlock->info.rows) {
-    TSKEY ts = tsCol[pInfo->srcRowIndex];
-    keepBlockRowInDiscBuf(pOperator, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex, groupId, pFillSup->rowSize);
-    doFillResults(pOperator, pFillSup, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex - 1, pRes);
-    if (pInfo->pRes->info.rows == pInfo->pRes->info.capacity) {
-      blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol);
-      return;
-    }
-    pInfo->srcRowIndex++;
-  }
-  blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol);
-  blockDataCleanup(pInfo->pPrevSrcBlock);
-  copyDataBlock(pInfo->pPrevSrcBlock, pInfo->pSrcBlock);
-  blockDataCleanup(pInfo->pSrcBlock);
-}
-
-static void buildDeleteRange(SOperatorInfo* pOp, TSKEY start, TSKEY end, uint64_t groupId, SSDataBlock* delRes) {
-  SStreamState* pState = pOp->pTaskInfo->streamInfo.pState;
-
-  SSDataBlock*     pBlock = delRes;
-  SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-  SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
-  SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX);
-  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  SColumnInfoData* pCalStartCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
-  SColumnInfoData* pCalEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-  SColumnInfoData* pTbNameCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
-  colDataAppend(pStartCol, pBlock->info.rows, (const char*)&start, false);
-  colDataAppend(pEndCol, pBlock->info.rows, (const char*)&end, false);
-  colDataAppendNULL(pUidCol, pBlock->info.rows);
-  colDataAppend(pGroupCol, pBlock->info.rows, (const char*)&groupId, false);
-  colDataAppendNULL(pCalStartCol, pBlock->info.rows);
-  colDataAppendNULL(pCalEndCol, pBlock->info.rows);
-
-  SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX);
-
-  void* tbname = NULL;
-  streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, groupId, &tbname);
-  if (tbname == NULL) {
-    colDataAppendNULL(pTableCol, pBlock->info.rows);
-  } else {
-    char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN];
-    STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName));
-    colDataAppend(pTableCol, pBlock->info.rows, (const char*)parTbName, false);
-    tdbFree(tbname);
-  }
-
-  pBlock->info.rows++;
-}
-
-static void buildDeleteResult(SOperatorInfo* pOperator, TSKEY startTs, TSKEY endTs, uint64_t groupId,
-                              SSDataBlock* delRes) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
-  if (hasPrevWindow(pFillSup)) {
-    TSKEY start = getNextWindowTs(pFillSup->prev.key, &pFillSup->interval);
-    buildDeleteRange(pOperator, start, endTs, groupId, delRes);
-  } else if (hasNextWindow(pFillSup)) {
-    TSKEY end = getPrevWindowTs(pFillSup->next.key, &pFillSup->interval);
-    buildDeleteRange(pOperator, startTs, end, groupId, delRes);
-  } else {
-    buildDeleteRange(pOperator, startTs, endTs, groupId, delRes);
-  }
-}
-
-static void doDeleteFillResultImpl(SOperatorInfo* pOperator, TSKEY startTs, TSKEY endTs, uint64_t groupId) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  getWindowFromDiscBuf(pOperator, startTs, groupId, pInfo->pFillSup);
-  setDeleteFillValueInfo(startTs, endTs, pInfo->pFillSup, pInfo->pFillInfo);
-  SWinKey key = {.ts = startTs, .groupId = groupId};
-  if (!pInfo->pFillInfo->needFill) {
-    streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &key);
-    buildDeleteResult(pOperator, startTs, endTs, groupId, pInfo->pDelRes);
-  } else {
-    STimeRange tw = {
-        .skey = startTs,
-        .ekey = endTs,
-        .groupId = groupId,
-    };
-    taosArrayPush(pInfo->pFillInfo->delRanges, &tw);
-    while (key.ts <= endTs) {
-      key.ts = taosTimeAdd(key.ts, pInfo->pFillSup->interval.sliding, pInfo->pFillSup->interval.slidingUnit,
-                           pInfo->pFillSup->interval.precision);
-      tSimpleHashPut(pInfo->pFillSup->pResMap, &key, sizeof(SWinKey), NULL, 0);
-    }
-  }
-}
-
-static void doDeleteFillFinalize(SOperatorInfo* pOperator) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
-  int32_t                  size = taosArrayGetSize(pFillInfo->delRanges);
-  tSimpleHashClear(pInfo->pFillSup->pResMap);
-  for (; pFillInfo->delIndex < size; pFillInfo->delIndex++) {
-    STimeRange* range = taosArrayGet(pFillInfo->delRanges, pFillInfo->delIndex);
-    if (pInfo->pRes->info.id.groupId != 0 && pInfo->pRes->info.id.groupId != range->groupId) {
-      return;
-    }
-    getWindowFromDiscBuf(pOperator, range->skey, range->groupId, pInfo->pFillSup);
-    setDeleteFillValueInfo(range->skey, range->ekey, pInfo->pFillSup, pInfo->pFillInfo);
-    if (pInfo->pFillInfo->needFill) {
-      doStreamFillRange(pInfo->pFillInfo, pInfo->pFillSup, pInfo->pRes);
-      pInfo->pRes->info.id.groupId = range->groupId;
-    }
-    SWinKey key = {.ts = range->skey, .groupId = range->groupId};
-    streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &key);
-  }
-}
-
-static void doDeleteFillResult(SOperatorInfo* pOperator) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SStreamFillSupporter*    pFillSup = pInfo->pFillSup;
-  SStreamFillInfo*         pFillInfo = pInfo->pFillInfo;
-  SSDataBlock*             pBlock = pInfo->pSrcDelBlock;
-  SSDataBlock*             pRes = pInfo->pRes;
-  SSDataBlock*             pDelRes = pInfo->pDelRes;
-
-  SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
-  TSKEY*           tsStarts = (TSKEY*)pStartCol->pData;
-  SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
-  uint64_t*        groupIds = (uint64_t*)pGroupCol->pData;
-  while (pInfo->srcDelRowIndex < pBlock->info.rows) {
-    TSKEY            ts = tsStarts[pInfo->srcDelRowIndex];
-    TSKEY            endTs = ts;
-    uint64_t         groupId = groupIds[pInfo->srcDelRowIndex];
-    SWinKey          key = {.ts = ts, .groupId = groupId};
-    SStreamStateCur* pCur = streamStateGetAndCheckCur(pOperator->pTaskInfo->streamInfo.pState, &key);
-    if (!pCur) {
-      pInfo->srcDelRowIndex++;
-      continue;
-    }
-
-    SWinKey nextKey = {.groupId = groupId, .ts = ts};
-    while (pInfo->srcDelRowIndex < pBlock->info.rows) {
-      void*    nextVal = NULL;
-      int32_t  nextLen = 0;
-      TSKEY    delTs = tsStarts[pInfo->srcDelRowIndex];
-      uint64_t delGroupId = groupIds[pInfo->srcDelRowIndex];
-      int32_t  code = TSDB_CODE_SUCCESS;
-      if (groupId != delGroupId) {
-        break;
-      }
-      if (delTs > nextKey.ts) {
-        break;
-      }
-      endTs = delTs;
-      SWinKey delKey = {.groupId = delGroupId, .ts = delTs};
-      if (delTs == nextKey.ts) {
-        code = streamStateCurNext(pOperator->pTaskInfo->streamInfo.pState, pCur);
-        if (code == TSDB_CODE_SUCCESS) {
-          code = streamStateGetGroupKVByCur(pCur, &nextKey, (const void**)&nextVal, &nextLen);
-        }
-        // ts will be deleted later
-        if (delTs != ts) {
-          streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &delKey);
-          streamStateFreeCur(pCur);
-          pCur = streamStateGetAndCheckCur(pOperator->pTaskInfo->streamInfo.pState, &nextKey);
-        }
-        endTs = TMAX(ts, nextKey.ts - 1);
-        if (code != TSDB_CODE_SUCCESS) {
-          break;
-        }
-      }
-      pInfo->srcDelRowIndex++;
-    }
-    streamStateFreeCur(pCur);
-    doDeleteFillResultImpl(pOperator, ts, endTs, groupId);
-  }
-  pFillInfo->current = pFillInfo->end + 1;
-}
-
-static void resetStreamFillInfo(SStreamFillOperatorInfo* pInfo) {
-  blockDataCleanup(pInfo->pPrevSrcBlock);
-  tSimpleHashClear(pInfo->pFillSup->pResMap);
-  pInfo->pFillSup->hasDelete = false;
-  taosArrayClear(pInfo->pFillInfo->delRanges);
-  pInfo->pFillInfo->delIndex = 0;
-}
-
-static void doApplyStreamScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pSrcBlock, SSDataBlock* pDstBlock) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SExprSupp*               pSup = &pOperator->exprSupp;
-
-  blockDataCleanup(pDstBlock);
-  blockDataEnsureCapacity(pDstBlock, pSrcBlock->info.rows);
-  setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false);
-  projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL);
-
-  pDstBlock->info.rows = 0;
-  pSup = &pInfo->pFillSup->notFillExprSup;
-  setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false);
-  projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL);
-  pDstBlock->info.id.groupId = pSrcBlock->info.id.groupId;
-
-  blockDataUpdateTsWindow(pDstBlock, pInfo->primaryTsCol);
-}
-
-static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
-  SStreamFillOperatorInfo* pInfo = pOperator->info;
-  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;
-
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-  blockDataCleanup(pInfo->pRes);
-  if (pOperator->status == OP_RES_TO_RETURN) {
-    if (hasRemainCalc(pInfo->pFillInfo)) {
-      doStreamFillRange(pInfo->pFillInfo, pInfo->pFillSup, pInfo->pRes);
-      if (pInfo->pRes->info.rows > 0) {
-        return pInfo->pRes;
-      }
-    }
-    doDeleteFillFinalize(pOperator);
-    if (pInfo->pRes->info.rows > 0) {
-      printDataBlock(pInfo->pRes, "stream fill");
-      return pInfo->pRes;
-    }
-    setOperatorCompleted(pOperator);
-    resetStreamFillInfo(pInfo);
-    return NULL;
-  }
-
-  SSDataBlock*   fillResult = NULL;
-  SOperatorInfo* downstream = pOperator->pDownstream[0];
-  while (1) {
-    if (pInfo->srcRowIndex >= pInfo->pSrcBlock->info.rows) {
-      // If there are delete datablocks, we receive  them first.
-      SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
-      if (pBlock == NULL) {
-        pOperator->status = OP_RES_TO_RETURN;
-        SSDataBlock* preBlock = pInfo->pPrevSrcBlock;
-        if (preBlock->info.rows > 0) {
-          int              preRowId = preBlock->info.rows - 1;
-          SColumnInfoData* pPreTsCol = taosArrayGet(preBlock->pDataBlock, pInfo->primaryTsCol);
-          doFillResults(pOperator, pInfo->pFillSup, pInfo->pFillInfo, preBlock, (TSKEY*)pPreTsCol->pData, preRowId,
-                        pInfo->pRes);
-        }
-        pInfo->pFillInfo->preRowKey = INT64_MIN;
-        if (pInfo->pRes->info.rows > 0) {
-          printDataBlock(pInfo->pRes, "stream fill");
-          return pInfo->pRes;
-        }
-        break;
-      }
-      printDataBlock(pBlock, "stream fill recv");
-
-      switch (pBlock->info.type) {
-        case STREAM_RETRIEVE:
-          return pBlock;
-        case STREAM_DELETE_RESULT: {
-          pInfo->pSrcDelBlock = pBlock;
-          pInfo->srcDelRowIndex = 0;
-          blockDataCleanup(pInfo->pDelRes);
-          pInfo->pFillSup->hasDelete = true;
-          doDeleteFillResult(pOperator);
-          if (pInfo->pDelRes->info.rows > 0) {
-            printDataBlock(pInfo->pDelRes, "stream fill delete");
-            return pInfo->pDelRes;
-          }
-          continue;
-        } break;
-        case STREAM_NORMAL:
-        case STREAM_INVALID: {
-          doApplyStreamScalarCalculation(pOperator, pBlock, pInfo->pSrcBlock);
-          memcpy(pInfo->pSrcBlock->info.parTbName, pBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
-          pInfo->srcRowIndex = 0;
-        } break;
-        default:
-          ASSERT(0);
-          break;
-      }
-    }
-
-    doStreamFillImpl(pOperator);
-    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
-    memcpy(pInfo->pRes->info.parTbName, pInfo->pSrcBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
-    pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
-    if (pInfo->pRes->info.rows > 0) {
-      break;
-    }
-  }
-  if (pOperator->status == OP_RES_TO_RETURN) {
-    doDeleteFillFinalize(pOperator);
-  }
-
-  if (pInfo->pRes->info.rows == 0) {
-    setOperatorCompleted(pOperator);
-    resetStreamFillInfo(pInfo);
-    return NULL;
-  }
-
-  pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
-  printDataBlock(pInfo->pRes, "stream fill");
-  return pInfo->pRes;
-}
-
-static int32_t initResultBuf(SStreamFillSupporter* pFillSup) {
-  pFillSup->rowSize = sizeof(SResultCellData) * pFillSup->numOfAllCols;
-  for (int i = 0; i < pFillSup->numOfAllCols; i++) {
-    SFillColInfo* pCol = &pFillSup->pAllColInfo[i];
-    SResSchema*   pSchema = &pCol->pExpr->base.resSchema;
-    pFillSup->rowSize += pSchema->bytes;
-  }
-  pFillSup->next.key = INT64_MIN;
-  pFillSup->nextNext.key = INT64_MIN;
-  pFillSup->prev.key = INT64_MIN;
-  pFillSup->cur.key = INT64_MIN;
-  pFillSup->next.pRowVal = NULL;
-  pFillSup->nextNext.pRowVal = NULL;
-  pFillSup->prev.pRowVal = NULL;
-  pFillSup->cur.pRowVal = NULL;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static SStreamFillSupporter* initStreamFillSup(SStreamFillPhysiNode* pPhyFillNode, SInterval* pInterval,
-                                               SExprInfo* pFillExprInfo, int32_t numOfFillCols) {
-  SStreamFillSupporter* pFillSup = taosMemoryCalloc(1, sizeof(SStreamFillSupporter));
-  if (!pFillSup) {
-    return NULL;
-  }
-  pFillSup->numOfFillCols = numOfFillCols;
-  int32_t    numOfNotFillCols = 0;
-  SExprInfo* noFillExprInfo = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &numOfNotFillCols);
-  pFillSup->pAllColInfo = createFillColInfo(pFillExprInfo, pFillSup->numOfFillCols, noFillExprInfo, numOfNotFillCols,
-                                            (const SNodeListNode*)(pPhyFillNode->pValues));
-  pFillSup->type = convertFillType(pPhyFillNode->mode);
-  pFillSup->numOfAllCols = pFillSup->numOfFillCols + numOfNotFillCols;
-  pFillSup->interval = *pInterval;
-
-  int32_t code = initResultBuf(pFillSup);
-  if (code != TSDB_CODE_SUCCESS) {
-    destroyStreamFillSupporter(pFillSup);
-    return NULL;
-  }
-
-  SExprInfo* noFillExpr = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &numOfNotFillCols);
-  code = initExprSupp(&pFillSup->notFillExprSup, noFillExpr, numOfNotFillCols);
-  if (code != TSDB_CODE_SUCCESS) {
-    destroyStreamFillSupporter(pFillSup);
-    return NULL;
-  }
-
-  _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  pFillSup->pResMap = tSimpleHashInit(16, hashFn);
-  pFillSup->hasDelete = false;
-  return pFillSup;
-}
-
-SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pRes) {
-  SStreamFillInfo* pFillInfo = taosMemoryCalloc(1, sizeof(SStreamFillInfo));
-  pFillInfo->start = INT64_MIN;
-  pFillInfo->current = INT64_MIN;
-  pFillInfo->end = INT64_MIN;
-  pFillInfo->preRowKey = INT64_MIN;
-  pFillInfo->needFill = false;
-  pFillInfo->pLinearInfo = taosMemoryCalloc(1, sizeof(SStreamFillLinearInfo));
-  pFillInfo->pLinearInfo->hasNext = false;
-  pFillInfo->pLinearInfo->nextEnd = INT64_MIN;
-  pFillInfo->pLinearInfo->pDeltaVal = NULL;
-  pFillInfo->pLinearInfo->pNextDeltaVal = NULL;
-  if (pFillSup->type == TSDB_FILL_LINEAR) {
-    pFillInfo->pLinearInfo->pDeltaVal = taosArrayInit(pFillSup->numOfAllCols, sizeof(double));
-    pFillInfo->pLinearInfo->pNextDeltaVal = taosArrayInit(pFillSup->numOfAllCols, sizeof(double));
-    for (int32_t i = 0; i < pFillSup->numOfAllCols; i++) {
-      double value = 0.0;
-      taosArrayPush(pFillInfo->pLinearInfo->pDeltaVal, &value);
-      taosArrayPush(pFillInfo->pLinearInfo->pNextDeltaVal, &value);
-    }
-  }
-  pFillInfo->pLinearInfo->winIndex = 0;
-
-  pFillInfo->pResRow = NULL;
-  if (pFillSup->type == TSDB_FILL_SET_VALUE || pFillSup->type == TSDB_FILL_NULL) {
-    pFillInfo->pResRow = taosMemoryCalloc(1, sizeof(SResultRowData));
-    pFillInfo->pResRow->key = INT64_MIN;
-    pFillInfo->pResRow->pRowVal = taosMemoryCalloc(1, pFillSup->rowSize);
-    for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) {
-      SColumnInfoData* pColData = taosArrayGet(pRes->pDataBlock, i);
-      SResultCellData* pCell = getResultCell(pFillInfo->pResRow, i);
-      pCell->bytes = pColData->info.bytes;
-      pCell->type = pColData->info.type;
-    }
-  }
-
-  pFillInfo->type = pFillSup->type;
-  pFillInfo->delRanges = taosArrayInit(16, sizeof(STimeRange));
-  pFillInfo->delIndex = 0;
-  return pFillInfo;
-}
-
-SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode,
-                                            SExecTaskInfo* pTaskInfo) {
-  SStreamFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamFillOperatorInfo));
-  SOperatorInfo*           pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL) {
-    goto _error;
-  }
-
-  SInterval* pInterval = &((SStreamIntervalOperatorInfo*)downstream->info)->interval;
-  int32_t    numOfFillCols = 0;
-  SExprInfo* pFillExprInfo = createExprInfo(pPhyFillNode->pFillExprs, NULL, &numOfFillCols);
-  pInfo->pFillSup = initStreamFillSup(pPhyFillNode, pInterval, pFillExprInfo, numOfFillCols);
-  if (!pInfo->pFillSup) {
-    goto _error;
-  }
-
-  initResultSizeInfo(&pOperator->resultInfo, 4096);
-  pInfo->pRes = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
-  pInfo->pSrcBlock = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
-  pInfo->pPrevSrcBlock = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc);
-  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
-  blockDataEnsureCapacity(pInfo->pSrcBlock, pOperator->resultInfo.capacity);
-  blockDataEnsureCapacity(pInfo->pPrevSrcBlock, pOperator->resultInfo.capacity);
-
-  pInfo->pFillInfo = initStreamFillInfo(pInfo->pFillSup, pInfo->pRes);
-  if (!pInfo->pFillInfo) {
-    goto _error;
-  }
-
-  if (pInfo->pFillInfo->type == TSDB_FILL_SET_VALUE) {
-    for (int32_t i = 0; i < pInfo->pFillSup->numOfAllCols; ++i) {
-      SFillColInfo*    pFillCol = pInfo->pFillSup->pAllColInfo + i;
-      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
-      SResultCellData* pCell = getResultCell(pInfo->pFillInfo->pResRow, slotId);
-      SVariant*        pVar = &(pFillCol->fillVal);
-      if (pCell->type == TSDB_DATA_TYPE_FLOAT) {
-        float v = 0;
-        GET_TYPED_DATA(v, float, pVar->nType, &pVar->i);
-        SET_TYPED_DATA(pCell->pData, pCell->type, v);
-      } else if (pCell->type == TSDB_DATA_TYPE_DOUBLE) {
-        double v = 0;
-        GET_TYPED_DATA(v, double, pVar->nType, &pVar->i);
-        SET_TYPED_DATA(pCell->pData, pCell->type, v);
-      } else if (IS_SIGNED_NUMERIC_TYPE(pCell->type)) {
-        int64_t v = 0;
-        GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
-        SET_TYPED_DATA(pCell->pData, pCell->type, v);
-      } else {
-        pCell->isNull = true;
-      }
-    }
-  } else if (pInfo->pFillInfo->type == TSDB_FILL_NULL) {
-    for (int32_t i = 0; i < pInfo->pFillSup->numOfAllCols; ++i) {
-      SFillColInfo*    pFillCol = pInfo->pFillSup->pAllColInfo + i;
-      int32_t          slotId = GET_DEST_SLOT_ID(pFillCol);
-      SResultCellData* pCell = getResultCell(pInfo->pFillInfo->pResRow, slotId);
-      pCell->isNull = true;
-    }
-  }
-
-  pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT);
-  blockDataEnsureCapacity(pInfo->pDelRes, pOperator->resultInfo.capacity);
-
-  pInfo->primaryTsCol = ((STargetNode*)pPhyFillNode->pWStartTs)->slotId;
-  pInfo->primarySrcSlotId = ((SColumnNode*)((STargetNode*)pPhyFillNode->pWStartTs)->pExpr)->slotId;
-
-  int32_t numOfOutputCols = 0;
-  int32_t code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc,
-                                     &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
-
-  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  code = initExprSupp(&pOperator->exprSupp, pFillExprInfo, numOfFillCols);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-
-  pInfo->srcRowIndex = 0;
-  setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo,
-                  pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo, NULL);
-
-  code = appendDownstream(pOperator, &downstream, 1);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _error;
-  }
-  return pOperator;
-
-_error:
-  destroyStreamFillOperatorInfo(pInfo);
-  taosMemoryFreeClear(pOperator);
-  pTaskInfo->code = code;
-  return NULL;
-}
diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c
index d8cef86971..90f5dde7c3 100644
--- a/source/libs/executor/src/timesliceoperator.c
+++ b/source/libs/executor/src/timesliceoperator.c
@@ -467,11 +467,11 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
         // add current row if timestamp match
         if (ts == pSliceInfo->current && pSliceInfo->current <= pSliceInfo->win.ekey) {
           addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
-          doKeepPrevRows(pSliceInfo, pBlock, i);
 
           pSliceInfo->current =
               taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
         }
+        doKeepPrevRows(pSliceInfo, pBlock, i);
 
         if (pSliceInfo->current > pSliceInfo->win.ekey) {
           setOperatorCompleted(pOperator);
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index d598fd09ca..f2c2e24a41 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -677,16 +677,6 @@ static void doInterpUnclosedTimeWindow(SOperatorInfo* pOperatorInfo, int32_t num
   }
 }
 
-void printDataBlock(SSDataBlock* pBlock, const char* flag) {
-  if (!pBlock || pBlock->info.rows == 0) {
-    qDebug("===stream===printDataBlock: Block is Null or Empty");
-    return;
-  }
-  char* pBuf = NULL;
-  qDebug("%s", dumpBlockData(pBlock, flag, &pBuf));
-  taosMemoryFree(pBuf);
-}
-
 typedef int32_t (*__compare_fn_t)(void* pKey, void* data, int32_t index);
 
 int32_t binarySearchCom(void* keyList, int num, void* pKey, int order, __compare_fn_t comparefn) {
@@ -3854,7 +3844,7 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl
   SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;
   SStreamStateAggOperatorInfo* pInfo = pOperator->info;
   int32_t                      numOfOutput = pOperator->exprSupp.numOfExprs;
-  int64_t                      groupId = pSDataBlock->info.id.groupId;
+  uint64_t                     groupId = pSDataBlock->info.id.groupId;
   int64_t                      code = TSDB_CODE_SUCCESS;
   TSKEY*                       tsCols = NULL;
   SResultRow*                  pResult = NULL;
diff --git a/source/libs/function/src/detail/tavgfunction.c b/source/libs/function/src/detail/tavgfunction.c
index 4cafbd4e6e..f06bafafe3 100644
--- a/source/libs/function/src/detail/tavgfunction.c
+++ b/source/libs/function/src/detail/tavgfunction.c
@@ -133,6 +133,14 @@ static void i8VectorSumAVX2(const int8_t* plist, int32_t numOfRows, int32_t type
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const int64_t* q = (const int64_t*)&sum;
+    pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.isum += plist[j + rounds * width];
+    }
   } else {
     const uint8_t* p = (const uint8_t*)plist;
 
@@ -142,16 +150,16 @@ static void i8VectorSumAVX2(const int8_t* plist, int32_t numOfRows, int32_t type
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const uint64_t* q = (const uint64_t*)&sum;
+    pRes->sum.usum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.usum += (uint8_t)plist[j + rounds * width];
+    }
   }
 
-  // let sum up the final results
-  const int64_t* q = (const int64_t*)&sum;
-  pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
-
-  int32_t startIndex = rounds * width;
-  for (int32_t j = 0; j < remainder; ++j) {
-    pRes->sum.isum += plist[j + startIndex];
-  }
 #endif
 }
 
@@ -176,8 +184,16 @@ static void i16VectorSumAVX2(const int16_t* plist, int32_t numOfRows, int32_t ty
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const int64_t* q = (const int64_t*)&sum;
+    pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.isum += plist[j + rounds * width];
+    }
   } else {
-    const uint8_t* p = (const uint8_t*)plist;
+    const uint16_t* p = (const uint16_t*)plist;
 
     for(int32_t i = 0; i < rounds; ++i) {
       __m128i val = _mm_lddqu_si128((__m128i*)p);
@@ -185,16 +201,16 @@ static void i16VectorSumAVX2(const int16_t* plist, int32_t numOfRows, int32_t ty
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const uint64_t* q = (const uint64_t*)&sum;
+    pRes->sum.usum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.usum += (uint16_t)plist[j + rounds * width];
+    }
   }
 
-  // let sum up the final results
-  const int64_t* q = (const int64_t*)&sum;
-  pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
-
-  int32_t startIndex = rounds * width;
-  for (int32_t j = 0; j < remainder; ++j) {
-    pRes->sum.isum += plist[j + startIndex];
-  }
 #endif
 }
 
@@ -219,6 +235,14 @@ static void i32VectorSumAVX2(const int32_t* plist, int32_t numOfRows, int32_t ty
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const int64_t* q = (const int64_t*)&sum;
+    pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.isum += plist[j + rounds * width];
+    }
   } else {
     const uint32_t* p = (const uint32_t*)plist;
 
@@ -228,16 +252,16 @@ static void i32VectorSumAVX2(const int32_t* plist, int32_t numOfRows, int32_t ty
       sum = _mm256_add_epi64(sum, extVal);
       p += width;
     }
+
+    // let sum up the final results
+    const uint64_t* q = (const uint64_t*)&sum;
+    pRes->sum.usum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.usum += (uint32_t)plist[j + rounds * width];
+    }
   }
 
-  // let sum up the final results
-  const int64_t* q = (const int64_t*)&sum;
-  pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
-
-  int32_t startIndex = rounds * width;
-  for (int32_t j = 0; j < remainder; ++j) {
-    pRes->sum.isum += plist[j + startIndex];
-  }
 #endif
 }
 
@@ -262,13 +286,22 @@ static void i64VectorSumAVX2(const int64_t* plist, int32_t numOfRows, SAvgRes* p
   }
 
   // let sum up the final results
-  const int64_t* q = (const int64_t*)&sum;
-  pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
+  if (type == TSDB_DATA_TYPE_BIGINT) {
+    const int64_t* q = (const int64_t*)&sum;
+    pRes->sum.isum += q[0] + q[1] + q[2] + q[3];
 
-  int32_t startIndex = rounds * width;
-  for (int32_t j = 0; j < remainder; ++j) {
-    pRes->sum.isum += plist[j + startIndex];
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.isum += plist[j + rounds * width];
+    }
+  } else {
+    const uint64_t* q = (const uint64_t*)&sum;
+    pRes->sum.usum += q[0] + q[1] + q[2] + q[3];
+
+    for (int32_t j = 0; j < remainder; ++j) {
+      pRes->sum.usum += (uint64_t)plist[j + rounds * width];
+    }
   }
+
 #endif
 }
 
@@ -502,7 +535,11 @@ int32_t avgFunction(SqlFunctionCtx* pCtx) {
           i8VectorSumAVX2(plist, numOfRows, type, pAvgRes);
         } else {
           for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
-            pAvgRes->sum.usum += plist[i];
+            if (type == TSDB_DATA_TYPE_TINYINT) {
+              pAvgRes->sum.isum += plist[i];
+            } else {
+              pAvgRes->sum.usum += (uint8_t)plist[i];
+            }
           }
         }
         break;
@@ -517,7 +554,11 @@ int32_t avgFunction(SqlFunctionCtx* pCtx) {
           i16VectorSumAVX2(plist, numOfRows, type, pAvgRes);
         } else {
           for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
-            pAvgRes->sum.isum += plist[i];
+            if (type == TSDB_DATA_TYPE_SMALLINT) {
+              pAvgRes->sum.isum += plist[i];
+            } else {
+              pAvgRes->sum.usum += (uint16_t)plist[i];
+            }
           }
         }
         break;
@@ -532,7 +573,11 @@ int32_t avgFunction(SqlFunctionCtx* pCtx) {
           i32VectorSumAVX2(plist, numOfRows, type, pAvgRes);
         } else {
           for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
-            pAvgRes->sum.isum += plist[i];
+            if (type == TSDB_DATA_TYPE_INT) {
+              pAvgRes->sum.isum += plist[i];
+            } else {
+              pAvgRes->sum.usum += (uint32_t)plist[i];
+            }
           }
         }
         break;
@@ -547,7 +592,11 @@ int32_t avgFunction(SqlFunctionCtx* pCtx) {
           i64VectorSumAVX2(plist, numOfRows, pAvgRes);
         } else {
           for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
-            pAvgRes->sum.isum += plist[i];
+            if (type == TSDB_DATA_TYPE_BIGINT) {
+              pAvgRes->sum.isum += plist[i];
+            } else {
+              pAvgRes->sum.isum += (uint64_t)plist[i];
+            }
           }
         }
         break;
diff --git a/source/libs/index/src/indexFilter.c b/source/libs/index/src/indexFilter.c
index 2a2865a955..72828e1daa 100644
--- a/source/libs/index/src/indexFilter.c
+++ b/source/libs/index/src/indexFilter.c
@@ -231,8 +231,10 @@ static int32_t sifInitParam(SNode *node, SIFParam *param, SIFCtx *ctx) {
       SIF_ERR_RET(sifGetValueFromNode(node, &param->condValue));
       param->colId = -1;
       param->colValType = (uint8_t)(vn->node.resType.type);
-      if (strlen(vn->literal) <= sizeof(param->colName)) {
+      if (vn->literal != NULL && strlen(vn->literal) <= sizeof(param->colName)) {
         memcpy(param->colName, vn->literal, strlen(vn->literal));
+      } else {
+        param->status = SFLT_NOT_INDEX;
       }
       break;
     }
diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c
index 1589fddda4..1ce4a35dff 100644
--- a/source/libs/stream/src/streamUpdate.c
+++ b/source/libs/stream/src/streamUpdate.c
@@ -44,6 +44,11 @@ static void windowSBfAdd(SUpdateInfo *pInfo, uint64_t count) {
   }
 }
 
+static void clearItemHelper(void* p) {
+  SScalableBf** pBf = p;
+  tScalableBfDestroy(*pBf);
+}
+
 static void windowSBfDelete(SUpdateInfo *pInfo, uint64_t count) {
   if (count < pInfo->numSBFs) {
     for (uint64_t i = 0; i < count; ++i) {
@@ -52,7 +57,7 @@ static void windowSBfDelete(SUpdateInfo *pInfo, uint64_t count) {
       taosArrayRemove(pInfo->pTsSBFs, 0);
     }
   } else {
-    taosArrayClearP(pInfo->pTsSBFs, (FDelete)tScalableBfDestroy);
+    taosArrayClearEx(pInfo->pTsSBFs, clearItemHelper);
   }
   pInfo->minTS += pInfo->interval * count;
 }
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index 3117f6e4c9..b08bcfb6fc 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -1142,12 +1142,21 @@ void syncNodeClose(SSyncNode* pSyncNode) {
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
     if ((pSyncNode->senders)[i] != NULL) {
       sSTrace((pSyncNode->senders)[i], "snapshot sender destroy while close, data:%p", (pSyncNode->senders)[i]);
+
+      if (snapshotSenderIsStart((pSyncNode->senders)[i])) {
+        snapshotSenderStop((pSyncNode->senders)[i], false);
+      }
+
       snapshotSenderDestroy((pSyncNode->senders)[i]);
       (pSyncNode->senders)[i] = NULL;
     }
   }
 
   if (pSyncNode->pNewNodeReceiver != NULL) {
+    if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) {
+      snapshotReceiverForceStop(pSyncNode->pNewNodeReceiver);
+    }
+
     snapshotReceiverDestroy(pSyncNode->pNewNodeReceiver);
     pSyncNode->pNewNodeReceiver = NULL;
   }
@@ -2458,8 +2467,12 @@ const char* syncStr(ESyncState state) {
       return "candidate";
     case TAOS_SYNC_STATE_LEADER:
       return "leader";
-    default:
+    case TAOS_SYNC_STATE_ERROR:
       return "error";
+    case TAOS_SYNC_STATE_OFFLINE:
+      return "offline";
+    default:
+      return "unknown";
   }
 }
 
diff --git a/source/libs/sync/src/syncSnapshot.c b/source/libs/sync/src/syncSnapshot.c
index 222b7c4e1e..3722b0f6f5 100644
--- a/source/libs/sync/src/syncSnapshot.c
+++ b/source/libs/sync/src/syncSnapshot.c
@@ -541,6 +541,10 @@ _START_RECEIVER:
       taosMsleep(10);
     }
 
+    if (snapshotReceiverIsStart(pReceiver)) {
+      snapshotReceiverForceStop(pReceiver);
+    }
+
     snapshotReceiverStart(pReceiver, pMsg);  // set start-time same with sender
   }
 
diff --git a/source/libs/transport/inc/transComm.h b/source/libs/transport/inc/transComm.h
index 9add91cdeb..479c1a5af7 100644
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
@@ -169,6 +169,7 @@ typedef struct {
   char spi : 2;
   char hasEpSet : 2;  // contain epset or not, 0(default): no epset, 1: contain epset
 
+  uint64_t timestamp;
   char     user[TSDB_UNI_LEN];
   uint32_t magicNum;
   STraceId traceId;
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 180540ba6b..fbcc1fb525 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -758,6 +758,14 @@ static void cliSendCb(uv_write_t* req, int status) {
   SCliConn* pConn = transReqQueueRemove(req);
   if (pConn == NULL) return;
 
+  SCliMsg* pMsg = !transQueueEmpty(&pConn->cliMsgs) ? transQueueGet(&pConn->cliMsgs, 0) : NULL;
+  if (pMsg != NULL) {
+    int64_t cost = taosGetTimestampUs() - pMsg->st;
+    if (cost > 1000) {
+      tWarn("%s conn %p send cost:%dus, send exception", CONN_GET_INST_LABEL(pConn), pConn, (int)cost);
+    }
+  }
+
   if (status == 0) {
     tTrace("%s conn %p data already was written out", CONN_GET_INST_LABEL(pConn), pConn);
   } else {
@@ -806,6 +814,7 @@ void cliSend(SCliConn* pConn) {
     pHead->traceId = pMsg->info.traceId;
     pHead->magicNum = htonl(TRANS_MAGIC_NUM);
   }
+  pHead->timestamp = taosHton64(taosGetTimestampUs());
 
   if (pHead->persist == 1) {
     CONN_SET_PERSIST_BY_APP(pConn);
@@ -1662,6 +1671,7 @@ int transReleaseCliHandle(void* handle) {
 
   SCliMsg* cmsg = taosMemoryCalloc(1, sizeof(SCliMsg));
   cmsg->msg = tmsg;
+  cmsg->st = taosGetTimestampUs();
   cmsg->type = Release;
   cmsg->ctx = pCtx;
 
diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c
index 3b41590440..a600b2a61a 100644
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@@ -231,14 +231,29 @@ static bool uvHandleReq(SSvrConn* pConn) {
     }
   }
   STraceId* trace = &pHead->traceId;
+
+  int64_t        cost = taosGetTimestampUs() - taosNtoh64(pHead->timestamp);
+  static int64_t EXCEPTION_LIMIT_US = 100 * 1000;
+
   if (pConn->status == ConnNormal && pHead->noResp == 0) {
     transRefSrvHandle(pConn);
-
-    tGDebug("%s conn %p %s received from %s, local info:%s, len:%d", transLabel(pTransInst), pConn,
-            TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen);
+    if (cost >= EXCEPTION_LIMIT_US) {
+      tGWarn("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus, recv exception", transLabel(pTransInst),
+             pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
+    } else {
+      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus", transLabel(pTransInst), pConn,
+              TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
+    }
   } else {
-    tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, resp:%d, code:%d", transLabel(pTransInst), pConn,
-            TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp, transMsg.code);
+    if (cost >= EXCEPTION_LIMIT_US) {
+      tGWarn("%s conn %p %s received from %s, local info:%s, len:%d, resp:%d, code:%d, cost:%dus, recv exception",
+             transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
+             transMsg.code, (int)(cost));
+    } else {
+      tGWarn("%s conn %p %s received from %s, local info:%s, len:%d, resp:%d, code:%d, cost:%dus",
+             transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
+             transMsg.code, (int)(cost));
+    }
   }
 
   // pHead->noResp = 1,
diff --git a/source/os/src/osSocket.c b/source/os/src/osSocket.c
index fd5bde90ba..db2a9937b5 100644
--- a/source/os/src/osSocket.c
+++ b/source/os/src/osSocket.c
@@ -1103,3 +1103,30 @@ void taosWinSocketInit() {
 #else
 #endif
 }
+
+uint64_t taosHton64(uint64_t val) {
+#if defined(WINDOWS) || defined(DARWIN)
+  return ((val & 0x00000000000000ff) << 7 * 8) | ((val & 0x000000000000ff00) << 5 * 8) |
+         ((val & 0x0000000000ff0000) << 3 * 8) | ((val & 0x00000000ff000000) << 1 * 8) |
+         ((val & 0x000000ff00000000) >> 1 * 8) | ((val & 0x0000ff0000000000) >> 3 * 8) |
+         ((val & 0x00ff000000000000) >> 5 * 8) | ((val & 0xff00000000000000) >> 7 * 8);
+#else
+  if (__BYTE_ORDER == __LITTLE_ENDIAN) {
+    return (((uint64_t)htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));
+  } else if (__BYTE_ORDER == __BIG_ENDIAN) {
+    return val;
+  }
+#endif
+}
+
+uint64_t taosNtoh64(uint64_t val) {
+#if defined(WINDOWS) || defined(DARWIN)
+  return taosHton64(val);
+#else
+  if (__BYTE_ORDER == __LITTLE_ENDIAN) {
+    return (((uint64_t)htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));
+  } else if (__BYTE_ORDER == __BIG_ENDIAN) {
+    return val;
+  }
+#endif
+}
diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c
index f53b1cfd7f..ae25786375 100644
--- a/source/util/src/tarray.c
+++ b/source/util/src/tarray.c
@@ -399,9 +399,7 @@ void taosArrayDestroyEx(SArray* pArray, FDelete fp) {
 }
 
 void taosArraySort(SArray* pArray, __compar_fn_t compar) {
-  assert(pArray != NULL);
-  assert(compar != NULL);
-
+  ASSERT(pArray != NULL && compar != NULL);
   taosSort(pArray->pData, pArray->size, pArray->elemSize, compar);
 }
 
@@ -417,11 +415,6 @@ int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t
   return item == NULL ? -1 : (int32_t)((char*)item - (char*)pArray->pData) / pArray->elemSize;
 }
 
-void taosArraySortString(SArray* pArray, __compar_fn_t comparFn) {
-  assert(pArray != NULL);
-  taosSort(pArray->pData, pArray->size, pArray->elemSize, comparFn);
-}
-
 static int32_t taosArrayPartition(SArray* pArray, int32_t i, int32_t j, __ext_compar_fn_t fn, const void* userData) {
   void* key = taosArrayGetP(pArray, i);
   while (i < j) {
diff --git a/tests/system-test/0-others/compatibility.py b/tests/system-test/0-others/compatibility.py
index 30513ac020..9d4d14dcd0 100644
--- a/tests/system-test/0-others/compatibility.py
+++ b/tests/system-test/0-others/compatibility.py
@@ -15,155 +15,160 @@ from util.cluster import *
 
 
 class TDTestCase:
-    def caseDescription(self):
-        '''
-        3.0 data compatibility test 
-        case1: basedata version is 3.0.1.0
-        '''
-        return
+	def caseDescription(self):
+		'''
+		3.0 data compatibility test 
+		case1: basedata version is 3.0.1.0
+		'''
+		return
 
-    def init(self, conn, logSql, replicaVar=1):
-        self.replicaVar = int(replicaVar)
-        tdLog.debug(f"start to excute {__file__}")
-        tdSql.init(conn.cursor())
+	def init(self, conn, logSql, replicaVar=1):
+		self.replicaVar = int(replicaVar)
+		tdLog.debug(f"start to excute {__file__}")
+		tdSql.init(conn.cursor())
 
 
-    def getBuildPath(self):
-        selfPath = os.path.dirname(os.path.realpath(__file__))
+	def getBuildPath(self):
+		selfPath = os.path.dirname(os.path.realpath(__file__))
 
-        if ("community" in selfPath):
-            projPath = selfPath[:selfPath.find("community")]
-        else:
-            projPath = selfPath[:selfPath.find("tests")]
+		if ("community" in selfPath):
+			projPath = selfPath[:selfPath.find("community")]
+		else:
+			projPath = selfPath[:selfPath.find("tests")]
 
-        for root, dirs, files in os.walk(projPath):
-            if ("taosd" in files or "taosd.exe" in files):
-                rootRealPath = os.path.dirname(os.path.realpath(root))
-                if ("packaging" not in rootRealPath):
-                    buildPath = root[:len(root)-len("/build/bin")]
-                    break
-        return buildPath
+		for root, dirs, files in os.walk(projPath):
+			if ("taosd" in files or "taosd.exe" in files):
+				rootRealPath = os.path.dirname(os.path.realpath(root))
+				if ("packaging" not in rootRealPath):
+					buildPath = root[:len(root)-len("/build/bin")]
+					break
+		return buildPath
 
-    def getCfgPath(self):
-        buildPath = self.getBuildPath()
-        selfPath = os.path.dirname(os.path.realpath(__file__))
+	def getCfgPath(self):
+		buildPath = self.getBuildPath()
+		selfPath = os.path.dirname(os.path.realpath(__file__))
 
-        if ("community" in selfPath):
-            cfgPath = buildPath + "/../sim/dnode1/cfg/"
-        else:
-            cfgPath = buildPath + "/../sim/dnode1/cfg/"
+		if ("community" in selfPath):
+			cfgPath = buildPath + "/../sim/dnode1/cfg/"
+		else:
+			cfgPath = buildPath + "/../sim/dnode1/cfg/"
 
-        return cfgPath
+		return cfgPath
 
-    def installTaosd(self,bPath,cPath):
-        # os.system(f"rmtaos && mkdir -p {self.getBuildPath()}/build/lib/temp &&  mv {self.getBuildPath()}/build/lib/libtaos.so*  {self.getBuildPath()}/build/lib/temp/ ")
-        # os.system(f" mv {bPath}/build  {bPath}/build_bak ")
-        # os.system(f"mv {self.getBuildPath()}/build/lib/libtaos.so  {self.getBuildPath()}/build/lib/libtaos.so_bak ")
-        # os.system(f"mv {self.getBuildPath()}/build/lib/libtaos.so.1  {self.getBuildPath()}/build/lib/libtaos.so.1_bak ")
+	def installTaosd(self,bPath,cPath):
+		# os.system(f"rmtaos && mkdir -p {self.getBuildPath()}/build/lib/temp &&  mv {self.getBuildPath()}/build/lib/libtaos.so*  {self.getBuildPath()}/build/lib/temp/ ")
+		# os.system(f" mv {bPath}/build  {bPath}/build_bak ")
+		# os.system(f"mv {self.getBuildPath()}/build/lib/libtaos.so  {self.getBuildPath()}/build/lib/libtaos.so_bak ")
+		# os.system(f"mv {self.getBuildPath()}/build/lib/libtaos.so.1  {self.getBuildPath()}/build/lib/libtaos.so.1_bak ")
 
-        packagePath="/usr/local/src/"
-        packageName="TDengine-server-3.0.1.0-Linux-x64.tar.gz"
-        os.system(f"cd {packagePath} &&  tar xvf  TDengine-server-3.0.1.0-Linux-x64.tar.gz && cd TDengine-server-3.0.1.0 && ./install.sh  -e no  " )
-        tdDnodes.stop(1)
-        print(f"start taosd: nohup taosd -c {cPath} & ")
-        os.system(f" nohup taosd -c {cPath} & " )
-        sleep(1)
+		packagePath="/usr/local/src/"
+		packageName="TDengine-server-3.0.1.0-Linux-x64.tar.gz"
+		os.system(f"cd {packagePath} &&  tar xvf  TDengine-server-3.0.1.0-Linux-x64.tar.gz && cd TDengine-server-3.0.1.0 && ./install.sh  -e no  " )
+		tdDnodes.stop(1)
+		print(f"start taosd: nohup taosd -c {cPath} & ")
+		os.system(f" nohup taosd -c {cPath} & " )
+		sleep(1)
 
 
-        
-    def buildTaosd(self,bPath):
-        # os.system(f"mv {bPath}/build_bak  {bPath}/build ")
-        os.system(f" cd {bPath}  &&  make install ")
+		
+	def buildTaosd(self,bPath):
+		# os.system(f"mv {bPath}/build_bak  {bPath}/build ")
+		os.system(f" cd {bPath}  &&  make install ")
 
 
-    def run(self):
-        bPath=self.getBuildPath()
-        cPath=self.getCfgPath()
-        dbname = "test"
-        stb = f"{dbname}.meters"
-        self.installTaosd(bPath,cPath)
-        os.system("echo 'debugFlag 143' > /etc/taos/taos.cfg ")
-        tableNumbers=100
-        recordNumbers1=100
-        recordNumbers2=1000
-        tdsqlF=tdCom.newTdSql()
-        print(tdsqlF)
-        tdsqlF.query(f"SELECT SERVER_VERSION();")
-        print(tdsqlF.query(f"SELECT SERVER_VERSION();"))
-        oldServerVersion=tdsqlF.queryResult[0][0]
-        tdLog.info(f"Base server version is {oldServerVersion}")
-        tdsqlF.query(f"SELECT CLIENT_VERSION();")
-        
-        # the oldClientVersion can't be updated in the same python process,so the version is new compiled verison
-        oldClientVersion=tdsqlF.queryResult[0][0]
-        tdLog.info(f"Base client version is {oldClientVersion}")
+	def run(self):
+		print(f"start taosd run")
+		bPath=self.getBuildPath()
+		cPath=self.getCfgPath()
+		dbname = "test"
+		stb = f"{dbname}.meters"
+		self.installTaosd(bPath,cPath)
+		os.system("echo 'debugFlag 143' > /etc/taos/taos.cfg ")
+		os.system("echo ' supportVnodes 256' > /etc/taos/taos.cfg ")
+		tableNumbers=100
+		recordNumbers1=100
+		recordNumbers2=1000
+		#tdsqlF=tdCom.newTdSql()
+		#print(tdsqlF)
 
-        tdLog.printNoPrefix(f"==========step1:prepare and check data in old version-{oldServerVersion}")
-        tdLog.info(f" LD_LIBRARY_PATH=/usr/lib  taosBenchmark -t {tableNumbers} -n {recordNumbers1} -y  ")
-        os.system(f"LD_LIBRARY_PATH=/usr/lib taosBenchmark -t {tableNumbers} -n {recordNumbers1} -y  ")
-        sleep(3)
+		oldServerVersion = '3.0.1.0' 
+		#tdsqlF.query(f"SELECT SERVER_VERSION();")
+		#print(tdsqlF.query(f"SELECT SERVER_VERSION();"))
+		#oldServerVersion=tdsqlF.queryResult[0][0]
+		#tdLog.info(f"Base server version is {oldServerVersion}")
+		#tdsqlF.query(f"SELECT CLIENT_VERSION();")
+		#	
+		## the oldClientVersion can't be updated in the same python process,so the version is new compiled verison
+		#oldClientVersion=tdsqlF.queryResult[0][0]
 
-        # tdsqlF.query(f"select count(*) from {stb}")
-        # tdsqlF.checkData(0,0,tableNumbers*recordNumbers1)
-        os.system("pkill taosd")
-        sleep(2)
+		#tdLog.info(f"Base client version is {oldClientVersion}")
 
-        print(f"start taosd: nohup taosd -c {cPath} & ")
-        os.system(f" nohup taosd -c {cPath} & " )
-        sleep(10)
-        tdLog.info(" LD_LIBRARY_PATH=/usr/lib  taosBenchmark -f 0-others/compa4096.json -y  ")
-        os.system("LD_LIBRARY_PATH=/usr/lib  taosBenchmark -f 0-others/compa4096.json -y")
-        os.system("pkill -9 taosd")
+		tdLog.printNoPrefix(f"==========step1:prepare and check data in old version-{oldServerVersion}")
+		tdLog.info(f" LD_LIBRARY_PATH=/usr/lib  taosBenchmark -t {tableNumbers} -n {recordNumbers1} -y  ")
+		os.system(f"LD_LIBRARY_PATH=/usr/lib taosBenchmark -t {tableNumbers} -n {recordNumbers1} -y  ")
+		sleep(3)
+
+		# tdsqlF.query(f"select count(*) from {stb}")
+		# tdsqlF.checkData(0,0,tableNumbers*recordNumbers1)
+		os.system("pkill taosd")
+		sleep(2)
+
+		print(f"start taosd: nohup taosd -c {cPath} & ")
+		os.system(f" nohup taosd -c {cPath} & " )
+		sleep(10)
+		tdLog.info(" LD_LIBRARY_PATH=/usr/lib  taosBenchmark -f 0-others/compa4096.json -y  ")
+		os.system("LD_LIBRARY_PATH=/usr/lib  taosBenchmark -f 0-others/compa4096.json -y")
+		os.system("pkill -9 taosd")
 
 
 
-        tdLog.printNoPrefix("==========step2:update new version ")
-        self.buildTaosd(bPath)
-        tdDnodes.start(1)
-        sleep(1)
-        tdsql=tdCom.newTdSql()
-        print(tdsql)
+		tdLog.printNoPrefix("==========step2:update new version ")
+		self.buildTaosd(bPath)
+		tdDnodes.start(1)
+		sleep(1)
+		tdsql=tdCom.newTdSql()
+		print(tdsql)
 
 
-        tdsql.query(f"SELECT SERVER_VERSION();")
-        nowServerVersion=tdsql.queryResult[0][0]
-        tdLog.info(f"New server version is {nowServerVersion}")
-        tdsql.query(f"SELECT CLIENT_VERSION();")
-        nowClientVersion=tdsql.queryResult[0][0]
-        tdLog.info(f"New client version is {nowClientVersion}")
+		tdsql.query(f"SELECT SERVER_VERSION();")
+		nowServerVersion=tdsql.queryResult[0][0]
+		tdLog.info(f"New server version is {nowServerVersion}")
+		tdsql.query(f"SELECT CLIENT_VERSION();")
+		nowClientVersion=tdsql.queryResult[0][0]
+		tdLog.info(f"New client version is {nowClientVersion}")
 
-        tdLog.printNoPrefix(f"==========step3:prepare and check data in new version-{nowServerVersion}")
-        tdsql.query(f"select count(*) from {stb}")
-        tdsql.checkData(0,0,tableNumbers*recordNumbers1)        
-        os.system(f"taosBenchmark -t {tableNumbers} -n {recordNumbers2} -y  ")
-        tdsql.query(f"select count(*) from {stb}")
-        tdsql.checkData(0,0,tableNumbers*recordNumbers2)
+		tdLog.printNoPrefix(f"==========step3:prepare and check data in new version-{nowServerVersion}")
+		tdsql.query(f"select count(*) from {stb}")
+		tdsql.checkData(0,0,tableNumbers*recordNumbers1)		
+		os.system(f"taosBenchmark -t {tableNumbers} -n {recordNumbers2} -y  ")
+		tdsql.query(f"select count(*) from {stb}")
+		tdsql.checkData(0,0,tableNumbers*recordNumbers2)
 
-        tdsql=tdCom.newTdSql()
-        tdLog.printNoPrefix(f"==========step4:verify backticks in taos Sql-TD18542")
-        tdsql.execute("drop database if exists db")
-        tdsql.execute("create database db")
-        tdsql.execute("use db")
-        tdsql.execute("create stable db.stb1 (ts timestamp, c1 int) tags (t1 int);")
-        tdsql.execute("insert into db.ct1 using db.stb1 TAGS(1) values(now(),11);")
-        tdsql.error(" insert into `db.ct2` using db.stb1 TAGS(9) values(now(),11);")
-        tdsql.error(" insert into db.`db.ct2` using db.stb1 TAGS(9) values(now(),11);")
-        tdsql.execute("insert into `db`.ct3 using db.stb1 TAGS(3) values(now(),13);")
-        tdsql.query("select * from db.ct3")
-        tdsql.checkData(0,1,13)
-        tdsql.execute("insert into db.`ct4` using db.stb1 TAGS(4) values(now(),14);")
-        tdsql.query("select * from db.ct4")
-        tdsql.checkData(0,1,14)
-        tdsql.query("describe  information_schema.ins_databases;")
-        qRows=tdsql.queryRows   
-        for i in  range(qRows) :
-            if tdsql.queryResult[i][0]=="retentions" :
-                return True
-            else:
-                return False
-    def stop(self):
-        tdSql.close()
-        tdLog.success(f"{__file__} successfully executed")
+		tdsql=tdCom.newTdSql()
+		tdLog.printNoPrefix(f"==========step4:verify backticks in taos Sql-TD18542")
+		tdsql.execute("drop database if exists db")
+		tdsql.execute("create database db")
+		tdsql.execute("use db")
+		tdsql.execute("create stable db.stb1 (ts timestamp, c1 int) tags (t1 int);")
+		tdsql.execute("insert into db.ct1 using db.stb1 TAGS(1) values(now(),11);")
+		tdsql.error(" insert into `db.ct2` using db.stb1 TAGS(9) values(now(),11);")
+		tdsql.error(" insert into db.`db.ct2` using db.stb1 TAGS(9) values(now(),11);")
+		tdsql.execute("insert into `db`.ct3 using db.stb1 TAGS(3) values(now(),13);")
+		tdsql.query("select * from db.ct3")
+		tdsql.checkData(0,1,13)
+		tdsql.execute("insert into db.`ct4` using db.stb1 TAGS(4) values(now(),14);")
+		tdsql.query("select * from db.ct4")
+		tdsql.checkData(0,1,14)
+		tdsql.query("describe  information_schema.ins_databases;")
+		qRows=tdsql.queryRows   
+		for i in  range(qRows) :
+			if tdsql.queryResult[i][0]=="retentions" :
+				return True
+			else:
+				return False
+	def stop(self):
+		tdSql.close()
+		tdLog.success(f"{__file__} successfully executed")
 
 tdCases.addLinux(__file__, TDTestCase())
 tdCases.addWindows(__file__, TDTestCase())